testautoa 0.4.0.pre16

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/actions/view/SelectTab.java

@@ -0,0 +1,110 @@
+package sh.calaba.instrumentationbackend.actions.view;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import android.app.Activity;
+import android.app.TabActivity;
+import android.util.Log;
+import android.view.View;
+import android.widget.TabHost;
+import android.widget.TextView;
+import sh.calaba.instrumentationbackend.InstrumentationBackend;
+import sh.calaba.instrumentationbackend.Result;
+import sh.calaba.instrumentationbackend.actions.Action;
+
+/**
+ * Select the tab by 1-based index or by name
+ * 
+ * @author Nicholas Albion
+ */
+@SuppressWarnings("deprecation")
+public class SelectTab implements Action {
+	@Override
+	public Result execute(String... args) {
+		
+		Activity currentActivity = InstrumentationBackend.solo.getCurrentActivity();
+		
+		if( currentActivity instanceof TabActivity == false ) {
+			Activity parent = currentActivity.getParent();
+			if( parent != null ) {
+				currentActivity = parent;
+			}
+		}
+		
+		if( currentActivity instanceof TabActivity ) {
+			final TabHost tabHost = ((TabActivity)currentActivity).getTabHost();
+			
+			String tabName = args[0];
+			if( tabName.length() == 1 ) {
+				char c = tabName.charAt(0);
+				if( c >= '0' && c <= '9' ) {
+					int index = (c - '0') - 1;
+					tabHost.setCurrentTab( index );
+					return Result.successResult();
+				}
+			}
+
+			List<String> foundTabs = new LinkedList<String>();
+			int numberOfTabs = ((TabActivity)currentActivity).getTabWidget().getTabCount();
+			Log.i("SelectTab", "numberOfTabs: " + numberOfTabs);
+			
+			String resultMessage = null;
+			int tabIndex;
+FIND_TAB:			
+			for( tabIndex = 0; tabIndex < numberOfTabs; tabIndex++ ) {
+				if( tabName.equals( tabHost.getTag(tabIndex) ) ) {
+					resultMessage = "Selected the tab by tag";
+					break;
+				}
+				
+				String currentTab;
+				View view = tabHost.getTabWidget().getChildTabViewAt(tabIndex);
+        		if( view instanceof TextView ) {
+        			currentTab = ((TextView)view).getText().toString();	
+        			if( tabName.equals(currentTab) ) {
+        				resultMessage = "Selected the tab by text view";
+        				break;
+            		}
+        			foundTabs.add(currentTab);
+        		} else {
+        			Log.i("SelectTab", "current tab view: " + view.getId() + ", " + view.getClass().getSimpleName());
+        			List<TextView> textViews = InstrumentationBackend.solo.getCurrentTextViews(view);
+        			for( TextView textView : textViews ) {
+        				currentTab = textView.getText().toString();
+        				Log.i("SelectTab", " child text view: " + currentTab);
+            			if( tabName.equals(currentTab) ) {
+            				resultMessage = "Selected the tab by child text view";
+            				break FIND_TAB;
+                		}
+            			foundTabs.add(currentTab);
+					}
+        		}
+			}
+			
+			if( resultMessage != null ) {
+				final int matchingTabIndex = tabIndex;
+				
+				currentActivity.runOnUiThread( new Runnable() {
+					@Override
+					public void run() {
+						tabHost.setCurrentTab( matchingTabIndex );
+					}
+				});
+				
+				return new Result(true, resultMessage);
+			}
+			
+			Result result = new Result(false, "Was unable to find a matching tab");
+			result.setExtras( foundTabs );
+			return result;
+		} else {
+			return new Result(false, "The current activity is not a TabActivity: " + currentActivity.getLocalClassName() );
+		}
+	}
+
+	@Override
+	public String key() {
+		return "select_tab";
+	}
+}

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/actions/wait/Wait.java

@@ -0,0 +1,24 @@
+package sh.calaba.instrumentationbackend.actions.wait;
+
+
+import sh.calaba.instrumentationbackend.Result;
+import sh.calaba.instrumentationbackend.TestHelpers;
+import sh.calaba.instrumentationbackend.actions.Action;
+
+
+public class Wait implements Action {
+
+    @Override
+    public Result execute(String... args) {
+        int seconds = Integer.parseInt(args[0]);
+
+        TestHelpers.wait(seconds);
+
+        return Result.successResult();
+    }
+
+    @Override
+    public String key() {
+        return "wait";
+    }
+}

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/actions/wait/WaitForDialogClose.java

@@ -0,0 +1,21 @@
+package sh.calaba.instrumentationbackend.actions.wait;
+
+
+import sh.calaba.instrumentationbackend.InstrumentationBackend;
+import sh.calaba.instrumentationbackend.Result;
+import sh.calaba.instrumentationbackend.actions.Action;
+
+
+public class WaitForDialogClose implements Action {
+
+    @Override
+    public Result execute(String... args) {
+        InstrumentationBackend.solo.waitForDialogToClose(30000);
+        return Result.successResult();
+    }
+
+    @Override
+    public String key() {
+        return "wait_for_dialog_to_close";
+    }
+}

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/actions/wait/WaitForProgress.java

@@ -0,0 +1,47 @@
+package sh.calaba.instrumentationbackend.actions.wait;
+
+
+import sh.calaba.instrumentationbackend.InstrumentationBackend;
+import sh.calaba.instrumentationbackend.Result;
+import sh.calaba.instrumentationbackend.actions.Action;
+import android.view.View;
+import android.widget.ProgressBar;
+
+
+public class WaitForProgress implements Action {
+
+    @Override
+    public Result execute(String... args) {
+        int timeout = 60000;
+        long waitUntil = System.currentTimeMillis() + timeout;
+
+        while (numberOfVisibleProgressBars() > 0) {
+            if (System.currentTimeMillis() > waitUntil) {
+                return new Result(false, "Timedout waiting for no visible progressbars (" + numberOfVisibleProgressBars() +" still visible).");
+            }
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+        return Result.successResult();
+    }
+
+    @Override
+    public String key() {
+        return "wait_for_no_progress_bars";
+    }
+
+    private int numberOfVisibleProgressBars() {
+        int visibleProgressBars = 0;
+        for (ProgressBar v : InstrumentationBackend.solo.getCurrentProgressBars()) {
+            if (v != null & v.getVisibility() != View.GONE && v.getVisibility() != View.INVISIBLE) {
+                visibleProgressBars++;
+                System.out.println("Found visible progressbar number:" + visibleProgressBars);
+            }
+        }
+        return visibleProgressBars;
+    }
+
+}

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/actions/wait/WaitForScreen.java

@@ -0,0 +1,54 @@
+package sh.calaba.instrumentationbackend.actions.wait;
+
+import sh.calaba.instrumentationbackend.InstrumentationBackend;
+import sh.calaba.instrumentationbackend.Result;
+import sh.calaba.instrumentationbackend.actions.Action;
+
+public class WaitForScreen implements Action {
+	private static final int DEFAULT_TIMEOUT = 5 * 1000;
+
+    @Override
+    public Result execute(String... args) {
+        switch (args.length) {
+        case 0:
+            return new Result(false, "Cannot check for correct screen. No Activity name supplied!");
+        case 1: {
+            if (InstrumentationBackend.solo.waitForActivity(args[0], DEFAULT_TIMEOUT)) {
+                return Result.successResult();
+            } else {
+            	String currentActivity = InstrumentationBackend.solo.getCurrentActivity().getLocalClassName();
+            	Result result = new Result(false, "Screen " + args[0] + " not found.  Current activity is " + currentActivity);
+            	result.addBonusInformation(currentActivity);
+            	return result;
+            }
+        }
+        case 2: { // 1st arg is Activity name, 2nd arg is timeout
+            int timeout;
+            
+            try {
+                // given seconds; want milliseconds
+                timeout = 1000 * Integer.parseInt(args[1]);
+            } catch (NumberFormatException e) {
+                return new Result(false, "Invalid timeout supplied. Should be an integer!"); 
+            }
+            
+            if (InstrumentationBackend.solo.waitForActivity(args[0], timeout)) {
+                return Result.successResult();
+            } else {
+                String currentActivity = InstrumentationBackend.solo.getCurrentActivity().getLocalClassName();
+            	Result result = new Result(false, "Screen " + args[0] + " not found.  Current activity is " + currentActivity);
+            	result.addBonusInformation(currentActivity);
+            	return result;
+            }
+        }
+        default:
+            return new Result(false, "Too many argument supplied to wait_for_screen!");
+        }
+    }
+
+    @Override
+    public String key() {
+        return "wait_for_screen";
+    }
+
+}

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/actions/wait/WaitForTab.java

@@ -0,0 +1,108 @@
+package sh.calaba.instrumentationbackend.actions.wait;
+
+import java.util.List;
+
+import android.os.SystemClock;
+import android.util.Log;
+import android.view.View;
+import android.widget.TabHost;
+import android.widget.TextView;
+import sh.calaba.instrumentationbackend.InstrumentationBackend;
+import sh.calaba.instrumentationbackend.Result;
+import sh.calaba.instrumentationbackend.actions.Action;
+
+/**
+ * Waits for a tab by name
+ * 
+ * @author Nicholas Albion
+ */
+public class WaitForTab implements Action {
+
+    @Override
+    public Result execute(String... args) {
+
+        final int DEFAULT_TIMEOUT = 5 * 1000;
+        int timeout = DEFAULT_TIMEOUT;
+
+        switch (args.length) {
+        case 0:
+            return new Result(false, "Cannot check for correct screen. No tab name supplied!");
+        case 1: {
+        	return waitForTab( args[0], DEFAULT_TIMEOUT );
+        }
+        case 2: { // 1st arg is Activity name, 2nd arg is timeout
+            try {
+                timeout = Integer.parseInt(args[1]);
+            } catch (NumberFormatException e) {
+                return new Result(false, "Invalid timeout supplied. Should be an integer!"); 
+            }            
+            return waitForTab( args[0], timeout );
+        }
+        default:
+            return new Result(false, "Too many argument supplied to wait_for_tab!");
+        }
+    }
+    
+    private Result waitForTab( String tabName, int timeout ) {
+    	int tabHostIndex = 0;
+    	long startTime = SystemClock.uptimeMillis();
+    	// TabHost tabHost = InstrumentationBackend.solo.getView( TabHost.class, tabHostIndex );		// waits 10 seconds
+    	
+    	if( InstrumentationBackend.solo.waitForView( TabHost.class, 1, timeout ) ) {
+        	TabHost tabHost = (TabHost)InstrumentationBackend.solo.getView(TabHost.class, tabHostIndex);
+        	
+        	boolean tabFound = false;
+        	int numberOfTabs = tabHost.getChildCount();
+        	for( int i = 0; i < numberOfTabs; i++ ) {
+        		if( tabName.equals( tabHost.getTag(i) ) ) {
+        			tabFound = true;
+        			break;
+        		}
+        	}
+        	if( tabFound == false ) {
+        		Log.w("WaitForTab", "Tab was not found: " + tabName);
+//        		return new Result(false, "Tab " + tabName + " not found");
+        	}
+        	
+        	String currentTab;
+        	do {
+        		int tabIndex = tabHost.getCurrentTab();
+        		View view = tabHost.getTabWidget().getChildTabViewAt(tabIndex);
+        		if( view instanceof TextView ) {
+        			currentTab = ((TextView)view).getText().toString();	
+        			if( tabName.equals(currentTab) ) {
+        				return new Result(true, "The current tab text view matches");
+            		}
+        		} else {
+        			Log.i("WaitForTab", "current tab view: " + view.getId() + ", " + view.getClass().getSimpleName());
+        			List<TextView> textViews = InstrumentationBackend.solo.getCurrentTextViews(view);
+        			for( TextView textView : textViews ) {
+        				currentTab = textView.getText().toString();
+        				Log.i("WaitForTab", " child text view: " + currentTab);
+            			if( tabName.equals(currentTab) ) {
+            				return new Result(true, "The current tab text view matches");
+                		}
+					}
+        		}
+        		
+        		currentTab = tabHost.getCurrentTabTag();
+        		
+        		if( tabName.equals(currentTab) ) {
+        			return new Result(true, "The current tab's tag matches");
+        		}
+        		try {
+					Thread.sleep(500);
+				} catch (InterruptedException e) {}
+        	} while( (SystemClock.uptimeMillis() - startTime) < timeout );
+        
+            return new Result(false, "The current tab is: " + currentTab + ", was tab even found? " + tabFound);
+        } else {
+            return new Result(false, "Timed out waiting for a TabActivity. Current activity is " + InstrumentationBackend.solo.getCurrentActivity().getLocalClassName());
+        }
+    }
+
+    @Override
+    public String key() {
+        return "wait_for_tab";
+    }
+}

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/actions/wait/WaitForText.java

@@ -0,0 +1,37 @@
+package sh.calaba.instrumentationbackend.actions.wait;
+
+
+import sh.calaba.instrumentationbackend.InstrumentationBackend;
+import sh.calaba.instrumentationbackend.Result;
+import sh.calaba.instrumentationbackend.actions.Action;
+
+
+public class WaitForText implements Action {
+
+    @Override
+    public Result execute(String... args) {
+        
+        int timeout = 90 * 1000;
+        if (args.length > 1) { // a second argument is a timeout
+            try {
+                // the argument is in seconds but robotium takes milliseconds
+                timeout = 1000 * Integer.parseInt(args[1]);
+            } catch (NumberFormatException e) {
+                return new Result(false, "Invalid timeout supplied. Should be an integer."); 
+            }
+        }
+ 
+        boolean timedOut = !InstrumentationBackend.solo.waitForText(args[0], 1, timeout);
+        if(timedOut) {
+            return new Result(false, "Time out while waiting for text:" + args[0]);
+        } else {
+            return Result.successResult();
+        }
+
+    }
+
+    @Override
+    public String key() {
+        return "wait_for_text";
+    }
+}

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/actions/wait/WaitForView.java

@@ -0,0 +1,43 @@
+package sh.calaba.instrumentationbackend.actions.wait;
+
+import sh.calaba.instrumentationbackend.InstrumentationBackend;
+import sh.calaba.instrumentationbackend.Result;
+import sh.calaba.instrumentationbackend.TestHelpers;
+import sh.calaba.instrumentationbackend.actions.Action;
+import android.view.View;
+
+public class WaitForView implements Action {
+
+    @Override
+    public Result execute(String... args) {
+        String text = args[0];
+        long endTime = System.currentTimeMillis() + 60000;
+        while (System.currentTimeMillis() < endTime) {
+            if (InstrumentationBackend.solo.searchButton(text) || searchForViewWithContentDescription(text)) {
+                return Result.successResult();
+            } else {
+                try {
+                    Thread.sleep(500);
+                } catch (InterruptedException e) {
+                    return Result.fromThrowable(e);
+                }
+            }
+        }
+        return new Result(false, "Timed out while waiting for view with text or contentDescription:'" + text + "'");
+    }
+
+    @Override
+    public String key() {
+        return "wait_for_view";
+    }
+
+    private boolean searchForViewWithContentDescription(String description) {
+        View view = TestHelpers.getViewByDescription(description);
+        if (view != null) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+}

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/actions/wait/WaitForViewById.java

@@ -0,0 +1,51 @@
+package sh.calaba.instrumentationbackend.actions.wait;
+
+
+import sh.calaba.instrumentationbackend.Result;
+import sh.calaba.instrumentationbackend.TestHelpers;
+import sh.calaba.instrumentationbackend.actions.Action;
+import android.view.View;
+
+
+public class WaitForViewById implements Action {
+
+    @Override
+    public Result execute(String... args) {
+        String viewId = args[0];
+        
+        try {
+        	if( getViewById(viewId, 60000) != null ) {
+        		return Result.successResult();
+        	} else {
+        		return new Result(false, "Timed out while waiting for view with id:'" + viewId + "'");
+        	}
+        } catch( InterruptedException e ) {
+    		return Result.fromThrowable(e);
+    	}
+    }
+    
+    protected View getViewById( String viewId, long timeout ) throws InterruptedException {
+    	System.out.println("Waiting for view with id '" + viewId + "'");
+        long endTime = System.currentTimeMillis() + timeout;
+        while (System.currentTimeMillis() < endTime) {
+            View view = TestHelpers.getViewById(viewId);
+            System.out.println("Waiting for view with id '" + viewId + "' found view " + view);
+
+            if (view != null) {
+                System.out.println("Waiting for view with id '" + viewId + "' Success");
+                return view;
+            } else {
+            	System.out.println("Waiting for view with id '" + viewId + "' sleeping...");
+            	Thread.sleep(500);
+            }
+        }
+        
+        System.out.println("Waiting for view with id '" + viewId + "' Timed out");
+        return null;
+    }
+
+    @Override
+    public String key() {
+        return "wait_for_view_by_id";
+    }
+}

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/actions/webview/CalabashChromeClient.java

@@ -0,0 +1,180 @@
+package sh.calaba.instrumentationbackend.actions.webview;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import android.os.Looper;
+import sh.calaba.instrumentationbackend.InstrumentationBackend;
+import android.os.Build;
+import android.os.ConditionVariable;
+import android.view.View;
+import android.webkit.JsPromptResult;
+import android.webkit.WebChromeClient;
+import android.webkit.WebView;
+
+public class CalabashChromeClient extends WebChromeClient {
+	private WebChromeClient mWebChromeClient;
+	private final WebView webView;
+	private final WebFuture scriptFuture;
+
+	public CalabashChromeClient(final WebView webView) {
+		this.webView = webView;
+		this.scriptFuture = new WebFuture(webView);
+		if (Build.VERSION.SDK_INT < 16) { // jelly bean
+			try {
+				Method methodGetConfiguration = webView.getClass().getMethod(
+						"getWebChromeClient");
+				mWebChromeClient = (WebChromeClient) methodGetConfiguration
+						.invoke(webView);
+			} catch (Exception e) {
+				throw new RuntimeException(e);
+			}
+		}
+
+        if ( Looper.getMainLooper().getThread() == Thread.currentThread()) {
+            webView.setWebChromeClient(this);
+        } else {
+            InstrumentationBackend.instrumentation.runOnMainSync(new Runnable() {
+                @Override
+                public void run() {
+                    webView.setWebChromeClient(CalabashChromeClient.this);
+                }
+            });
+        }
+	}
+
+	@Override
+	public boolean onJsPrompt(WebView view, String url, String message,
+			String defaultValue, JsPromptResult r) {
+		if (message != null && message.startsWith("calabash:")) {
+			r.confirm("CALABASH_ACK");
+			System.out.println("onJsPrompt: " + message);
+			String jsonResponse = message.replaceFirst("calabash:", "");
+			scriptFuture.setResult(jsonResponse);			
+			return true;
+		} else {
+			if (mWebChromeClient == null) {
+				r.confirm("CALABASH_ERROR");
+				scriptFuture.complete();
+				return true;
+			} else {
+				// TODO I'm not what this case does...
+				return mWebChromeClient.onJsPrompt(view, url, message,
+						defaultValue, r);
+			}
+		}
+	}
+
+	public WebView getWebView() {
+		return webView;
+	}
+
+	public static CalabashChromeClient prepareWebView(WebView webView) {
+		CalabashChromeClient calabashChromeClient = new CalabashChromeClient(
+				webView);
+		webView.getSettings().setJavaScriptEnabled(true);
+		return calabashChromeClient;
+	}
+
+	public static List<CalabashChromeClient> findAndPrepareWebViews() {
+		List<CalabashChromeClient> webViews = new ArrayList<CalabashChromeClient>();
+		ArrayList<View> views = InstrumentationBackend.solo.getCurrentViews();
+		for (View view : views) {
+			if (view instanceof WebView) {
+				WebView webView = (WebView) view;
+				webViews.add(prepareWebView(webView));
+			}
+		}
+		return webViews;
+
+	}
+
+	public WebFuture getResult() {
+		return scriptFuture;
+	}
+
+	@SuppressWarnings("rawtypes")
+	public static class WebFuture implements Future {
+		private final ConditionVariable eventHandled;
+		private volatile boolean complete;
+		private String result;
+		private final WebView webView;
+
+		public WebView getWebView() {
+			return webView;
+		}
+
+		public void complete() {
+			this.complete = true;
+			this.eventHandled.open();
+		}
+
+		public WebFuture(WebView webView) {
+			this.webView = webView;
+			eventHandled = new ConditionVariable();
+			result = null;
+		}
+
+		public synchronized void setResult(String result) {
+			this.result = result;
+			this.complete();
+		}
+
+		public synchronized String getResult() {
+			return this.result;
+		}
+
+		public boolean cancel(boolean mayInterruptIfRunning) {
+			return false;
+		}
+
+		@Override
+		public Object get() throws InterruptedException, ExecutionException {
+			eventHandled.block();
+			return asMap();
+		}
+
+		@Override
+		public Object get(long timeout, TimeUnit unit)
+				throws InterruptedException, ExecutionException,
+				TimeoutException {
+			eventHandled.block(unit.convert(timeout, TimeUnit.MILLISECONDS));
+			return asMap();
+		}
+
+		@Override
+		public boolean isCancelled() {
+			return false;
+		}
+
+		@Override
+		public boolean isDone() {
+			return complete;
+		}
+
+		public String getAsString() {				
+			try {
+				get(10,TimeUnit.SECONDS);
+				return getResult();
+			} catch (Exception e) {
+				e.printStackTrace();
+				throw new RuntimeException(e);
+			}			
+		}
+		
+		@SuppressWarnings("unchecked")
+		public Map asMap() {			
+			HashMap m = new HashMap();
+			m.put("webView", webView);
+			m.put("result",getResult());			
+			return m;
+		}
+	}
+}