testautoa 0.4.0.pre16

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

@@ -0,0 +1,202 @@
+package sh.calaba.instrumentationbackend.query.ast;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
+
+import org.antlr.runtime.tree.CommonTree;
+
+import sh.calaba.instrumentationbackend.actions.webview.QueryHelper;
+import android.view.View;
+import android.webkit.WebView;
+
+public class UIQueryASTWith implements UIQueryAST {
+	public final String propertyName;
+	public final Object value;
+
+	public UIQueryASTWith(String property, Object value) {
+		if (property == null) {
+			throw new IllegalArgumentException(
+					"Cannot instantiate Filter with null property name");
+		}
+		this.propertyName = property;
+		this.value = value;
+	}
+
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	@Override
+	public List evaluateWithViews(final List inputViews, final UIQueryDirection direction,
+			final UIQueryVisibility visibility) {
+		
+		List queryResult = (List) UIQueryUtils.evaluateSyncInMainThread(new Callable() {
+			
+			@Override
+			public Object call() throws Exception {
+				List futureResult = new ArrayList(8);
+
+				for (int i = 0; i < inputViews.size(); i++) {
+					Object o = inputViews.get(i);
+
+					if (o instanceof WebView) {
+						Future webResult = evaluateForWebView((WebView) o);
+						if (webResult != null) {
+							futureResult.add(webResult);
+						}
+					}
+					else if (o instanceof Map) {
+						Map result = evaluateForMap((Map) o);
+						if (result != null) {
+							futureResult.add(result);
+						}
+						
+					}
+					else {
+						Object result = evaluateForObject(o, i);
+						if (result != null) {
+							futureResult.add(result);
+						}
+					}
+
+				}
+				List visibilityFilteredResults = visibility.evaluateWithViews(futureResult, direction,
+						visibility);
+				return new PartialFutureList(visibilityFilteredResults);
+			}
+		});
+		
+		List processedResult = new ArrayList(queryResult.size());
+		for (Object o : queryResult) {
+			if (o instanceof Map) {
+				Map m = (Map) o;
+				if (m.containsKey("result")) {
+					processedResult.addAll(UIQueryUtils.mapWebViewJsonResponse((String) m.get("result"),(WebView) m.get("webView")));	
+				}
+				else {
+					processedResult.add(m);
+				}
+				
+			}
+			else {
+				processedResult.add(o);
+			}
+		}
+		return processedResult;
+		
+
+	}
+
+	
+	@SuppressWarnings("rawtypes")
+	private Map evaluateForMap(Map map) {		
+		if (map.containsKey(this.propertyName)) {											
+			Object value = map.get(this.propertyName);
+			if (value == this.value || (value != null && value.equals(this.value))) {
+				return map;
+			}			
+		} 
+		return null;
+	}
+
+	private Object evaluateForObject(Object o, int index) {
+		if (this.propertyName.equals("id") && hasId(o, this.value)) {
+			return o;
+		} else if (this.propertyName.equals("marked")
+				&& isMarked(o, this.value)) {
+			return o;
+		} else if (this.propertyName.equals("index")
+				&& this.value.equals(index)) {
+			return o;
+		} else {
+
+			Method propertyAccessor = UIQueryUtils.hasProperty(o,
+					this.propertyName);
+			if (propertyAccessor != null) {
+				Object value = UIQueryUtils.getProperty(o, propertyAccessor);
+
+				if (value == this.value
+						|| (value != null && value.equals(this.value))) {
+					return o;
+				} else if (this.value instanceof String
+						&& this.value.equals(value.toString())) {
+					return o;
+				}
+			}
+		}
+		return null;
+
+	}
+
+	@SuppressWarnings({ "rawtypes" })
+	private Future evaluateForWebView(WebView o) {
+		if (!(this.value instanceof String)) {
+			return null;
+		}
+		return QueryHelper.executeAsyncJavascriptInWebviews(o,
+				"calabash.js", (String) this.value,this.propertyName);
+				
+	}
+
+	private boolean hasId(Object o, Object expectedValue) {
+		if (!(o instanceof View)) {
+			return false;
+		}
+		if (!(expectedValue instanceof String)) {
+			return false;
+		}
+		View view = (View) o;
+		String expected = (String) expectedValue;
+		String id = UIQueryUtils.getId(view);
+		return (id != null && id.equals(expected));
+	}
+
+	private boolean isMarked(Object o, Object expectedValue) {
+		if (!(o instanceof View)) {
+			return false;
+		}
+		if (!(expectedValue instanceof String)) {
+			return false;
+		}
+		View view = (View) o;
+		String expected = (String) expectedValue;
+
+		if (hasId(o, expectedValue)) {
+			return true;
+		}
+
+		CharSequence contentDescription = view.getContentDescription();
+		if (contentDescription != null
+				&& contentDescription.toString().equals(expected)) {
+			return true;
+		}
+
+		try {
+			Method getTextM = view.getClass().getMethod("getText");
+			Object text = getTextM.invoke(view);
+			if (text != null && text.toString().equals(expected)) {
+				return true;
+			}
+
+		} catch (Exception e) {
+		}
+
+		return false;
+
+	}
+
+	public static UIQueryASTWith fromAST(CommonTree step) {
+		CommonTree prop = (CommonTree) step.getChild(0);
+		CommonTree val = (CommonTree) step.getChild(1);
+		
+		Object parsedVal = UIQueryUtils.parseValue(val);
+		return new UIQueryASTWith(prop.getText(), parsedVal);
+	}
+
+	@Override
+	public String toString() {
+		return "With[" + this.propertyName + ":" + this.value + "]";
+	}
+
+}

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

@@ -0,0 +1,15 @@
+package sh.calaba.instrumentationbackend.query.ast;
+
+import java.util.List;
+
+public enum UIQueryDirection implements UIQueryAST {
+	DESCENDANT, CHILD, PARENT, SIBLING;
+
+	@SuppressWarnings("rawtypes")
+	@Override
+	public List evaluateWithViews(List inputViews, UIQueryDirection direction,
+			UIQueryVisibility visibility) {
+		//Never called. Not so pretty, I know.
+		throw new UnsupportedOperationException("This method should never be called");
+	}
+}

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

@@ -0,0 +1,99 @@
+package sh.calaba.instrumentationbackend.query.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import sh.calaba.instrumentationbackend.query.Operation;
+import sh.calaba.instrumentationbackend.query.UIQueryResultVoid;
+import sh.calaba.instrumentationbackend.query.ViewMapper;
+
+public class UIQueryEvaluator {
+	
+	@SuppressWarnings({ "rawtypes" })
+	public static List evaluateQueryWithOptions(List<UIQueryAST> query, List inputViews,
+			List<Operation> operations) {
+		
+        long before = System.currentTimeMillis();
+        
+        List views = evaluateQueryForPath(query, inputViews);
+        
+        long after = System.currentTimeMillis();              
+        String action = "EvaluateQuery";                               
+        System.out.println(action+ " took: "+ (after-before) + "ms");
+        
+        before = System.currentTimeMillis();
+        
+        List result = applyOperations(views, operations);
+        
+        after = System.currentTimeMillis();              
+        action = "ApplyOperations";                               
+        System.out.println(action+ " took: "+ (after-before) + "ms");
+
+        before = System.currentTimeMillis();
+        
+		List finalResult = mapViews(result);
+        
+		after = System.currentTimeMillis();              
+        action = "MapViews";                               
+        return finalResult;         	
+	}
+
+
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	public static List mapViews(List result) {		
+		List finalResult = new ArrayList(result.size());
+		for (Object o : result) {
+			finalResult.add(ViewMapper.mapView(o));
+		}
+		return finalResult;
+	}
+
+
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	public static List applyOperations(List views, List<Operation> operations) {
+		List result = views;
+		for(Operation op : operations) {
+			List nextResult = new ArrayList(result.size());
+			for (Object obj : result) {
+				try {
+					nextResult.add(op.apply(obj));	
+				} catch (Exception e) {
+					e.printStackTrace();
+					nextResult.add(UIQueryResultVoid.instance.asMap(op.getName(), obj, e.getMessage()));
+				}				
+			}
+			result = nextResult;
+		}
+		return result;
+	}
+
+
+	@SuppressWarnings("rawtypes")
+	private static List evaluateQueryForPath(List<UIQueryAST> queryPath,
+			List inputViews) {
+
+		List currentResult = inputViews;
+		UIQueryDirection currentDirection = UIQueryDirection.DESCENDANT;
+		UIQueryVisibility currentVisibility = UIQueryVisibility.VISIBLE;
+		
+		for (UIQueryAST step : queryPath) {			
+			if (step instanceof UIQueryDirection) {
+				currentDirection = (UIQueryDirection) step;
+			}
+			else if (step instanceof UIQueryVisibility) {
+				currentVisibility = (UIQueryVisibility) step;
+			}
+			else {
+				currentResult = step.evaluateWithViews(currentResult, currentDirection,currentVisibility);
+			}
+
+		}
+		return currentResult;
+	}
+		
+
+	public static boolean isDirection(UIQueryAST step) {
+		return step instanceof UIQueryDirection;
+	}
+			
+}

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

@@ -0,0 +1,271 @@
+package sh.calaba.instrumentationbackend.query.ast;
+
+import static sh.calaba.instrumentationbackend.InstrumentationBackend.viewFetcher;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.antlr.runtime.tree.CommonTree;
+
+import sh.calaba.instrumentationbackend.InstrumentationBackend;
+import sh.calaba.instrumentationbackend.actions.webview.QueryHelper;
+import sh.calaba.instrumentationbackend.query.CompletedFuture;
+import sh.calaba.instrumentationbackend.query.antlr.UIQueryParser;
+import sh.calaba.org.codehaus.jackson.map.ObjectMapper;
+import sh.calaba.org.codehaus.jackson.type.TypeReference;
+import android.content.res.Resources.NotFoundException;
+import android.view.View;
+import android.webkit.WebView;
+
+public class UIQueryUtils {	
+	
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	public static List subviews(Object o)
+	{
+		try {
+			Method getChild = o.getClass().getMethod("getChildAt", int.class);
+			getChild.setAccessible(true);
+			Method getChildCount = o.getClass().getMethod("getChildCount");
+			getChildCount.setAccessible(true);
+			List result = new ArrayList(8);
+			int childCount = (Integer) getChildCount.invoke(o);
+			for (int i=0;i<childCount;i++)
+			{
+				result.add(getChild.invoke(o, i));
+			}
+			return result;
+			
+		} catch (NoSuchMethodException e) {			
+			return Collections.EMPTY_LIST;
+		} catch (IllegalArgumentException e) {			
+			return Collections.EMPTY_LIST;
+		} catch (IllegalAccessException e) {			
+			return Collections.EMPTY_LIST;
+		} catch (InvocationTargetException e) {
+			return Collections.EMPTY_LIST;
+		}
+		
+	}
+	
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	public static List parents(Object o)
+	{
+		try {
+			
+			Method getParent = o.getClass().getMethod("getParent");
+			getParent.setAccessible(true);
+			
+			List result = new ArrayList(8);
+			try {
+				while (true)
+				{
+					Object parent = getParent.invoke(o);
+					if (parent == null)
+					{
+						return result;
+					}
+					else 
+					{
+						result.add(parent);
+					}
+					o = parent;	
+				}											
+			} catch (IllegalArgumentException e) {
+				return result;
+			} catch (IllegalAccessException e) {
+				return result;
+			} catch (InvocationTargetException e) {
+				return result;
+			} 
+			
+			
+		} catch (NoSuchMethodException e) {
+			return Collections.EMPTY_LIST;
+		} 
+		
+	}
+
+	@SuppressWarnings({ "rawtypes" })
+	public static Method hasProperty(Object o, String propertyName) {
+		
+		Class c = o.getClass();		
+		Method method = methodOrNull(c,propertyName);
+		if (method != null) { return method;}
+		method = methodOrNull(c,"get"+captitalize(propertyName));
+		if (method != null) { return method;}
+		method = methodOrNull(c,"is"+captitalize(propertyName));
+		return method;
+				
+/*		
+		for (Method m : methods)
+		{
+			String methodName = m.getName();
+			if (methodName.equals(propertyName) || 
+				methodName.equals("is"+captitalize(propertyName)) ||
+				methodName.equals("get"+captitalize(propertyName)))
+			{
+				return m;
+			}
+		}
+*/
+		
+		
+	}
+
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	private static Method methodOrNull(Class c, String methodName) {
+		try {
+			return c.getMethod(methodName);
+		} catch (NoSuchMethodException e) {
+			return null;
+		}
+	}
+
+	private static String captitalize(String propertyName) {
+		return propertyName.substring(0,1).toUpperCase() + propertyName.substring(1);
+	}
+
+	public static Object getProperty(Object receiver, Method m) {		
+		try {
+			return m.invoke(receiver);
+		} catch (IllegalArgumentException e) {
+			throw new RuntimeException(e);
+		} catch (IllegalAccessException e) {
+			throw new RuntimeException(e);
+		} catch (InvocationTargetException e) { 
+			throw new RuntimeException(e);
+		}
+	}
+
+	public static boolean isVisible(Object v) {
+		if (!(v instanceof View)) { return true; }		
+		View view = (View) v;
+		return view.isShown() && viewFetcher.isViewSufficientlyShown(view);
+	}
+
+	public static String getId(View view) {
+		try {
+			return InstrumentationBackend.solo.getCurrentActivity()
+					.getResources().getResourceEntryName(view.getId());			
+	
+		}
+		catch (NotFoundException e) {}
+		return null;
+	}
+
+	@SuppressWarnings("rawtypes")
+	public static Future evaluateAsyncInMainThread(final Callable callable) throws Exception {
+		final AtomicReference<Future> result = new AtomicReference<Future>();
+		final AtomicReference<Exception> errorResult = new AtomicReference<Exception>();
+		
+		InstrumentationBackend.instrumentation.runOnMainSync(new Runnable() {			
+			@SuppressWarnings("unchecked")
+			public void run() {
+				try {
+					Object res = callable.call();
+					if (res instanceof Future) {
+						result.set((Future) res);
+					}
+					else {
+						result.set(new CompletedFuture(res));
+					}
+				} catch (Exception e) {
+					errorResult.set(e);
+				}			
+			}			
+		});
+		if (result.get() == null) {
+			throw errorResult.get();
+		}
+		return result.get();
+	}
+
+	@SuppressWarnings("rawtypes")
+	public static Object evaluateSyncInMainThread(Callable callable) {
+		try {
+			return evaluateAsyncInMainThread(callable).get(10, TimeUnit.SECONDS);
+		} catch (RuntimeException e) {
+			throw e;
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+			throw new RuntimeException(e);
+		} 
+	}
+	
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	public static List<Map<String, Object>> mapWebViewJsonResponse(final String jsonResponse, final WebView webView) {
+		return (List<Map<String, Object>>) evaluateSyncInMainThread(new Callable() {
+
+			@Override
+			public Object call() throws Exception {
+				List<Map<String, Object>> parsedResult;
+				try {
+					parsedResult = new ObjectMapper().readValue(
+									jsonResponse,
+									new TypeReference<List<HashMap<String, Object>>>() {});
+					for (Map<String,Object> data : parsedResult) {
+						Map<String,Object> rect = (Map<String, Object>) data.get("rect");
+						Map <String,Object> updatedRect = QueryHelper.translateRectToScreenCoordinates(webView, rect);
+						data.put("rect", updatedRect);
+						data.put("webView", webView);
+					}
+					return parsedResult;
+				} catch (Exception igored) {
+					try {
+						Map resultAsMap = new ObjectMapper().readValue(
+											jsonResponse,
+											new TypeReference<HashMap>() {});
+						//This usually happens in case of error
+						//check this case
+						System.out.println(resultAsMap);
+						String errorMsg = (String) resultAsMap.get("error");
+						System.out.println(errorMsg);
+						return Collections.singletonList(resultAsMap);
+					} catch (Exception e) {
+						e.printStackTrace();
+						throw new RuntimeException(e);		
+					}
+					
+					
+				}		
+			}
+		});
+		
+	}
+
+	public static Object parseValue(CommonTree val) {
+		switch (val.getType()) {
+		case UIQueryParser.STRING: {
+			String textWithPings = val.getText();
+			String text = textWithPings
+					.substring(1, textWithPings.length() - 1);
+			return text;
+		}
+		case UIQueryParser.INT:
+			return Integer.parseInt(val.getText(), 10);
+		case UIQueryParser.BOOL: {
+			String text = val.getText();
+			return Boolean.parseBoolean(text);
+		}
+		case UIQueryParser.NIL:
+			return null;
+
+		default:
+			throw new IllegalArgumentException("Unable to parse value type:"
+					+ val.getType() + " text " + val.getText());
+
+		}
+
+	}
+
+}

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

@@ -0,0 +1,32 @@
+package sh.calaba.instrumentationbackend.query.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public enum UIQueryVisibility implements UIQueryAST {
+	ALL {		
+		@Override
+		@SuppressWarnings("rawtypes")
+		public List evaluateWithViews(List inputViews,
+				UIQueryDirection direction, UIQueryVisibility self) {			
+			return inputViews;
+		} 
+	},
+	
+	
+	VISIBLE {
+		@Override
+		@SuppressWarnings({ "rawtypes", "unchecked" })
+		public List evaluateWithViews(List inputViews,
+				UIQueryDirection direction, UIQueryVisibility self) {
+			List filtered = new ArrayList(inputViews.size());
+			for (Object o : inputViews) {
+				if (UIQueryUtils.isVisible(o)) {
+				    filtered.add(o);					
+				}				
+			}			
+			return filtered;
+		} 
+	};
+	
+}