testautoa 0.4.0.pre16

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

@@ -0,0 +1,87 @@
+package sh.calaba.instrumentationbackend.actions.webview;
+
+
+import java.util.List;
+import java.util.Map;
+
+import sh.calaba.instrumentationbackend.InstrumentationBackend;
+import sh.calaba.instrumentationbackend.Result;
+import sh.calaba.instrumentationbackend.actions.Action;
+import sh.calaba.instrumentationbackend.actions.Actions;
+import android.test.TouchUtils;
+import android.webkit.WebView;
+
+
+public class ScrollTo implements Action {
+    
+	@Override
+    public Result execute(String... args) {
+    	//TODO: Should do horizontal scrolling if needed
+    	final String uiQuery = "webView " + args[0] + ":'"+ args[1] + "'";
+
+        CalabashChromeClient calabashChromeClient = CalabashChromeClient.findAndPrepareWebViews().get(0);
+        WebView webView = calabashChromeClient.getWebView();
+
+        scrollToTop(webView);
+
+        while (keepScrolling(uiQuery, webView)) {
+            TouchUtils.dragQuarterScreenUp(Actions.parentTestCase, InstrumentationBackend.solo.getCurrentActivity());
+        }
+
+		return new Result(isVisible(uiQuery, webView), "");
+    }
+
+    private void scrollToTop(final WebView webView) {
+        InstrumentationBackend.instrumentation.runOnMainSync(new Runnable() {
+            @Override
+            public void run() {
+                webView.scrollTo(0, 0);
+            }
+        });
+    }
+
+    private boolean keepScrolling(String uiQuery, WebView webView) {
+        int centerY = getCenterY(uiQuery, webView);
+        System.out.println("Keep scrolling centerY: "+  centerY);
+
+        int[] location = new int[2];
+        webView.getLocationOnScreen(location);
+        int top = location[1];
+        int bottom = top + webView.getHeight();
+
+        System.out.println("isVisible top: "+  top);
+        System.out.println("isVisible bottom: "+  bottom);
+
+        return centerY > bottom;
+    }
+
+    private boolean isVisible(String uiQuery, WebView webView) {
+        int centerY = getCenterY(uiQuery, webView);
+        System.out.println("isVisible centerY: "+  centerY);
+
+        int[] location = new int[2];
+        webView.getLocationOnScreen(location);
+        int top = location[1];
+        int bottom = top + webView.getHeight();
+        System.out.println("isVisible top: "+  top);
+        System.out.println("isVisible bottom: "+  bottom);
+
+        return top < centerY && centerY < bottom;
+    }
+
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+	private int getCenterY(String uiQuery, WebView webView) {
+        List queryResult = new sh.calaba.instrumentationbackend.query.Query(uiQuery).executeQuery();
+        if (queryResult.isEmpty()) {
+            throw new RuntimeException("Query found no elements");
+        }
+        final Map<String, Object> firstVisibleRectangle = QueryHelper.findFirstVisibleRectangle(queryResult);
+
+        return Math.round((Float)firstVisibleRectangle.get("center_y"));
+    }
+
+    @Override
+    public String key() {
+        return "scroll_to";
+    }
+}

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

@@ -0,0 +1,69 @@
+package sh.calaba.instrumentationbackend.actions.webview;
+
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Callable;
+
+import sh.calaba.instrumentationbackend.Result;
+import sh.calaba.instrumentationbackend.actions.Action;
+import sh.calaba.instrumentationbackend.actions.webview.CalabashChromeClient.WebFuture;
+import sh.calaba.instrumentationbackend.query.ast.UIQueryUtils;
+import android.webkit.WebView;
+
+
+public class SetPropertyByCssSelector implements Action {
+
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+	@Override
+    public Result execute(String... args) {
+    	final String cssSelector = args[0];
+    	final String propertyName = args[1];
+    	final String value = args[2];
+    	      
+    	List<WebFuture> webResults = (List<WebFuture>) UIQueryUtils.evaluateSyncInMainThread(new Callable() {			
+			
+			public Object call() throws Exception {
+				
+				List<WebFuture> webResults = new ArrayList();
+		    	for (CalabashChromeClient ccc : CalabashChromeClient.findAndPrepareWebViews()) {
+		    		WebView webView = ccc.getWebView();
+					
+		    		final String assignment = "document.querySelector(\"" + cssSelector + "\")." + propertyName + " = " + value + ";";
+		    		System.out.println(assignment);
+		            webView.loadUrl("javascript:(function() {" +
+		                    assignment +
+		                    "prompt('calabash:true');" +
+		                    "})()");
+		            webResults.add(ccc.getResult());		            		            
+		        }
+
+				return webResults;
+				
+			}
+		});
+    	
+    	List<String> allResults = new ArrayList<String>(webResults.size());
+    	boolean success = false;
+    	for (WebFuture f : webResults) {
+    		String result = f.getAsString();
+			allResults.add(result);
+    		if ("true".equals(result)) {	               
+               success = true;
+            }
+    	}
+    		
+    	if (allResults.size() == 0) {
+    		return new Result(false, "No WebView found");	
+    	}
+    	else {
+    		return new Result(success, allResults);
+    	}
+    }
+
+    @Override
+    public String key() {
+        return "set_property_by_css_selector";
+    }
+
+}

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

@@ -0,0 +1,47 @@
+package sh.calaba.instrumentationbackend.actions.webview;
+
+
+import java.util.List;
+import java.util.Map;
+
+import sh.calaba.instrumentationbackend.Result;
+import sh.calaba.instrumentationbackend.actions.Action;
+import sh.calaba.instrumentationbackend.actions.webview.CalabashChromeClient.WebFuture;
+
+
+public class SetText implements Action {
+
+	/**
+	 * args[0]: Selector type "xpath" or "css"
+	 * args[1]: xpath or css selector
+	 * args[2]: text to enter into the first selected element 
+	 */
+	@SuppressWarnings({ "rawtypes", "unchecked"})
+	@Override
+    public Result execute(final String... args) {
+		final String uiQuery = "webView " + args[0] + ":'"+ args[1] + "'";
+		List queryResult = new sh.calaba.instrumentationbackend.query.Query(uiQuery).executeQuery();
+		if (queryResult.isEmpty()) {
+			throw new RuntimeException("No element found");
+		}
+		Map<String, Object> firstElement = QueryHelper.findFirstVisibleElement(queryResult);
+		//TODO: Hack! Should be serialized instead of removed
+		CalabashChromeClient client = CalabashChromeClient.findAndPrepareWebViews().get(0);
+		firstElement.remove("class");
+		firstElement.remove("webView");
+		firstElement.remove("html");
+		String firstElementJson = QueryHelper.toJsonString(firstElement);
+
+		WebFuture result = QueryHelper.executeAsyncJavascriptInWebviews(client.getWebView(),"set_text.js", firstElementJson, args[2]);
+		
+		return new Result(true,result.getAsString());    			    
+    }
+
+    @Override
+    public String key() {
+        return "set_text";
+    }
+    
+    
+
+}

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/query/CompletedFuture.java

@@ -0,0 +1,40 @@
+package sh.calaba.instrumentationbackend.query;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+public class CompletedFuture<T> implements Future<T> {
+    private final T result;
+
+    public CompletedFuture(final T result) {
+        this.result = result;
+    }
+
+    @Override
+    public boolean cancel(final boolean b) {
+        return false;
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return false;
+    }
+
+    @Override
+    public boolean isDone() {
+        return true;
+    }
+
+    @Override
+    public T get() throws InterruptedException, ExecutionException {
+        return this.result;
+    }
+
+	@Override
+	public T get(long timeout, TimeUnit unit) throws InterruptedException,
+			ExecutionException, TimeoutException {
+		return get();
+	}
+}

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/query/InvocationOperation.java

@@ -0,0 +1,222 @@
+package sh.calaba.instrumentationbackend.query;
+
+import java.lang.reflect.Method;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
+
+import sh.calaba.instrumentationbackend.InstrumentationBackend;
+
+public class InvocationOperation implements Operation {
+
+	private final String methodName;
+	@SuppressWarnings("rawtypes")
+	private final List arguments;
+	private final Class<?>[] classes;
+	private final Class<?>[] classesWithCharseq;
+
+	@SuppressWarnings("rawtypes")
+	public InvocationOperation(String methodName, List arguments) {
+		this.methodName = methodName;
+		this.arguments = arguments;
+		this.classes = extractArgumentTypes(false);
+		this.classesWithCharseq = extractArgumentTypes(true);
+	}	
+
+	@SuppressWarnings("rawtypes")
+	@Override
+	public Object apply(final Object o) throws Exception {
+		final AtomicReference ref = new AtomicReference();
+		final AtomicReference<Exception> refEx = new AtomicReference<Exception>();
+		
+		InstrumentationBackend.instrumentation.runOnMainSync(new Runnable() {
+
+			@SuppressWarnings("unchecked")
+			@Override
+			public void run() {
+				try {
+					Method method = o.getClass().getMethod(InvocationOperation.this.methodName, InvocationOperation.this.classes);
+					method.setAccessible(true);
+					try {
+						Object result;
+						if( method.getReturnType().equals(Void.TYPE)){
+							invokeMethod(o, method);
+							result = "<VOID>";
+			            }
+						else {
+							result = invokeMethod(o, method);							
+						}
+						ref.set(result);
+						return;
+					} catch (Exception e) {
+						refEx.set(e);
+						return;
+					}
+				} catch (NoSuchMethodException e) {
+					try {
+						Method method = o.getClass().getMethod(InvocationOperation.this.methodName, InvocationOperation.this.classesWithCharseq);
+						method.setAccessible(true);
+						try {
+							Object result;
+							if( method.getReturnType().equals(Void.TYPE)){
+								invokeMethod(o, method);
+								result = "<VOID>";
+				            }
+							else {
+								result = invokeMethod(o, method);							
+							}
+							ref.set(result);
+							return;						
+						} catch (Exception ee) {
+							refEx.set(e);
+							return;
+						}
+					} catch (NoSuchMethodException ee) {
+						System.out.println("Method not found with correct argument types. Trying to type convert.");
+					}
+				}
+				//Warning: Slow path
+				Method[] methods = o.getClass().getMethods();
+				for (Method m : methods) {
+					if (m.getName().equals(InvocationOperation.this.methodName)) {
+						Class<?>[] parameterTypes = m.getParameterTypes();						
+						if (parameterTypes.length == InvocationOperation.this.classes.length && areArgumentsConvertibleTo(parameterTypes)) {							
+							try {
+								Object result;
+								if( m.getReturnType().equals(Void.TYPE)){
+									invokeMethod(o, m);
+									result = "<VOID>";
+					            }
+								else {
+									result = invokeMethod(o, m);							
+								}
+								ref.set(result);
+								return;
+							} catch (Exception e) {
+								e.printStackTrace();
+								refEx.set(e);
+								return;
+							}
+							
+						}							
+					}
+				}
+		
+			}
+			 
+		 });
+				
+		 if (refEx.get() != null) {
+			 throw refEx.get();
+		 }
+		 return ref.get();				
+	}
+	
+	@SuppressWarnings("rawtypes")
+	private Class[] extractArgumentTypes(boolean convertStringCharSeq) {
+		Class[] types = new Class[arguments.size()];
+		for (int i=0;i<arguments.size(); i++) {
+			Object o = arguments.get(i);
+			if (o != null) {
+				Class<?> c = o.getClass();
+				if (convertStringCharSeq && c.equals(String.class)) {
+					c = CharSequence.class;//Android API specific optimization
+				} 								
+				types[i] = mapToPrimitiveClass(c); 	
+			}
+			else {
+				types[i] = null;
+			}			
+		}
+		return types;
+	}
+	
+	private Class<?> mapToPrimitiveClass(Class<?> c) {
+		if (c.equals(Integer.class)) {
+			return int.class;
+		}
+		else if (c.equals(Float.class)) {
+			return float.class;
+		}
+		else if (c.equals(Double.class)) {
+			return double.class;
+		}
+		else if (c.equals(Boolean.class)) {
+			return boolean.class;
+		}		
+		return c;
+	}
+	
+	
+	//parameterType.length == this.classes.length
+	//Note: right now we don't do any clever mapping, we 
+	//only use Java's sub type relation: isAssigableFrom
+	private boolean areArgumentsConvertibleTo(Class<?>[] parameterTypes) {		
+		for (int i=0; i < parameterTypes.length; i++) {
+			Class<?> typei = parameterTypes[i];			
+			if (this.arguments.get(i) == null) {
+				if (typei.isPrimitive()) {
+					//Can't pass null as primitive
+					return false;
+				}
+				continue; //can always pass null (unless primitive)
+			}
+			if (typei.isPrimitive() && typei.equals(mapToPrimitiveClass(this.classes[i]))) {
+				continue;
+			}
+			if (!typei.isAssignableFrom(this.classes[i])) {
+				return false;
+			}
+		}
+		return true;
+	}
+	
+	private Object invokeMethod(Object o, Method m) throws Exception {
+		List<?> a = this.arguments;
+		int size = a.size();
+		switch(size) {
+			case 0:
+				return m.invoke(o);
+			case 1:
+				return m.invoke(o,a.get(0));
+			case 2:
+				return m.invoke(o,a.get(0),a.get(1));
+			case 3:
+				return m.invoke(o,a.get(0),a.get(1),a.get(2));
+			case 4:
+				return m.invoke(o,a.get(0),a.get(1),a.get(2),a.get(3));
+			case 5:
+				return m.invoke(o,a.get(0),a.get(1),a.get(2),a.get(3),a.get(4));
+			case 6:
+				return m.invoke(o,a.get(0),a.get(1),a.get(2),a.get(3),a.get(4),a.get(5));
+			case 7:
+				return m.invoke(o,a.get(0),a.get(1),a.get(2),a.get(3),a.get(4),a.get(5),a.get(6));
+			case 8:
+				return m.invoke(o,a.get(0),a.get(1),a.get(2),a.get(3),a.get(4),a.get(5),a.get(6),a.get(7));
+			case 9:
+				return m.invoke(o,a.get(0),a.get(1),a.get(2),a.get(3),a.get(4),a.get(5),a.get(6),a.get(7),a.get(8));
+			case 10:
+				return m.invoke(o,a.get(0),a.get(1),a.get(2),a.get(3),a.get(4),a.get(5),a.get(6),a.get(7),a.get(8),a.get(9));
+			case 11:
+				return m.invoke(o,a.get(0),a.get(1),a.get(2),a.get(3),a.get(4),a.get(5),a.get(6),a.get(7),a.get(8),a.get(9),a.get(10));
+			case 12:
+				return m.invoke(o,a.get(0),a.get(1),a.get(2),a.get(3),a.get(4),a.get(5),a.get(6),a.get(7),a.get(8),a.get(9),a.get(10),a.get(11));
+			case 13:
+				return m.invoke(o,a.get(0),a.get(1),a.get(2),a.get(3),a.get(4),a.get(5),a.get(6),a.get(7),a.get(8),a.get(9),a.get(10),a.get(11),a.get(12));
+			case 14:
+				return m.invoke(o,a.get(0),a.get(1),a.get(2),a.get(3),a.get(4),a.get(5),a.get(6),a.get(7),a.get(8),a.get(9),a.get(10),a.get(11),a.get(12),a.get(13));				
+			case 15:
+				return m.invoke(o,a.get(0),a.get(1),a.get(2),a.get(3),a.get(4),a.get(5),a.get(6),a.get(7),a.get(8),a.get(9),a.get(10),a.get(11),a.get(12),a.get(13),a.get(14));				
+			case 16:
+				return m.invoke(o,a.get(0),a.get(1),a.get(2),a.get(3),a.get(4),a.get(5),a.get(6),a.get(7),a.get(8),a.get(9),a.get(10),a.get(11),a.get(12),a.get(13),a.get(14),a.get(15));				
+		}
+		throw new UnsupportedOperationException("Method with more than 16 arguments are not supported");
+		
+	}
+
+
+	@Override
+	public String getName() {
+		return "InvocationOp["+this.methodName+", arguments = " + this.arguments + "]";
+	}
+
+}

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/query/Operation.java

@@ -0,0 +1,7 @@
+package sh.calaba.instrumentationbackend.query;
+
+public interface Operation {
+
+	public Object apply(Object o) throws Exception;
+	public String getName();
+}

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/query/PropertyOperation.java

@@ -0,0 +1,56 @@
+package sh.calaba.instrumentationbackend.query;
+
+import java.lang.reflect.Method;
+import java.util.Map;
+
+import sh.calaba.instrumentationbackend.query.ast.UIQueryUtils;
+import android.view.View;
+
+public class PropertyOperation implements Operation {
+
+	public final String propertyName;	
+	
+	public PropertyOperation(String propertyName) {
+		super();
+		this.propertyName = propertyName;
+	}
+
+
+	@SuppressWarnings({ "rawtypes" })
+	@Override
+	public Object apply(Object o) throws Exception {
+		if (o instanceof Map) {
+			Map objAsMap = (Map) o;
+			if (objAsMap.containsKey(propertyName)) {											
+				return objAsMap.get(propertyName);
+			} else {
+				return UIQueryResultVoid.instance.asMap(
+						propertyName, o, "No key for "
+								+ propertyName + ". Keys: "
+								+ (objAsMap.keySet().toString()));
+			}
+		} else {
+			if (o instanceof View && "id".equals(propertyName)) {
+				return UIQueryUtils.getId((View) o);
+			} else {
+				Method m = UIQueryUtils
+						.hasProperty(o, propertyName);
+				if (m != null) {
+					return m.invoke(o);					
+				} else {
+					return UIQueryResultVoid.instance
+							.asMap(propertyName, o,
+									"NO accessor for "
+											+ propertyName);
+				}
+			}
+		}
+
+	}
+
+	@Override
+	public String getName() {
+		return "Property["+this.propertyName+"]";
+	}
+
+}