testautoa 0.4.0 → 0.4.1

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+"]";
+	}
+
+}

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

@@ -6,64 +6,172 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
+import org.antlr.runtime.ANTLRStringStream;
+import org.antlr.runtime.CommonTokenStream;
+import org.antlr.runtime.RecognitionException;
+import org.antlr.runtime.tree.CommonTree;
+
+import sh.calaba.instrumentationbackend.query.antlr.UIQueryLexer;
+import sh.calaba.instrumentationbackend.query.antlr.UIQueryParser;
+import sh.calaba.instrumentationbackend.query.ast.InvalidUIQueryException;
+import sh.calaba.instrumentationbackend.query.ast.UIQueryAST;
+import sh.calaba.instrumentationbackend.query.ast.UIQueryASTClassName;
+import sh.calaba.instrumentationbackend.query.ast.UIQueryASTPredicate;
+import sh.calaba.instrumentationbackend.query.ast.UIQueryASTWith;
+import sh.calaba.instrumentationbackend.query.ast.UIQueryDirection;
 import sh.calaba.instrumentationbackend.query.ast.UIQueryEvaluator;
-import sh.calaba.instrumentationbackend.query.ast.UIQueryUtils;
+import sh.calaba.instrumentationbackend.query.ast.UIQueryVisibility;
 import android.view.View;
 
 public class Query {
 
-    private String queryString;
+	private String queryString;
 	@SuppressWarnings("rawtypes")
-	private List arguments;
+	private List operations;
 
-    public Query(String queryString) {        
-        this.queryString = queryString;
-        this.arguments = Collections.EMPTY_LIST;
-        if (this.queryString == null || this.queryString.trim().equals("")) 
-        {
-        	throw new IllegalArgumentException("Illegal query: "+this.queryString);
-        }
-    }
+	public Query(String queryString) {
+		this.queryString = queryString;
+		this.operations = Collections.EMPTY_LIST;
+		if (this.queryString == null || this.queryString.trim().equals("")) {
+			throw new IllegalArgumentException("Illegal query: "
+					+ this.queryString);
+		}
+	}
 
-    @SuppressWarnings("rawtypes")
-	public Query(String queryString,List args) {
-        this(queryString);
-        this.arguments = args;
-    }
+	@SuppressWarnings("rawtypes")
+	public Query(String queryString, List args) {
+		this(queryString);
+		this.operations = args;
+	}
 
+	@SuppressWarnings("rawtypes")
+	public List executeQuery() {		
+		return UIQueryEvaluator.evaluateQueryWithOptions(parseQuery(this.queryString), rootViews(), parseOperations(this.operations));		
+	}
 
-    @SuppressWarnings({"unchecked", "rawtypes" })
-	public QueryResult execute() {
-        List result = new ArrayList();
-        List<View> all = rootViews();
-                
-        List queryResults = UIQueryEvaluator.evaluateQueryWithOptions(this.queryString, all, this.arguments);
-                     
-        for (Object v : queryResults) {
-            if (UIQueryUtils.isVisible(v)) {
-            	System.out.println("Query result: "+v);
-            	result.add(ViewMapper.extractDataFromView(v));
-            }
-            
-        }
-        return new QueryResult(result);
-    }
+	@SuppressWarnings("rawtypes")
+	public static List<Operation> parseOperations(List ops) {
+		List<Operation> result = new ArrayList<Operation>(ops.size());
+		for (Object o : ops) {
+			Operation op = null;
+			if (o instanceof Operation) {
+				op = (Operation) o;												
+			}
+			else if (o instanceof String) {
+				op = new PropertyOperation((String) o);	
+			}
+			else if (o instanceof Map) {
+				Map mapOp = (Map) o;				
+				String methodName = (String) mapOp.get("method_name");
+				if (methodName == null) {
+					throw new IllegalArgumentException("Trying to convert a Map without method_name to an operation. " + mapOp.toString());
+				}
+				List arguments = (List) mapOp.get("arguments");
+				if (arguments == null) {
+					throw new IllegalArgumentException("Trying to convert a Map without arguments to an operation. " + mapOp.toString());
+				}
+				op = new InvocationOperation(methodName, arguments);
+			}
+			result.add(op);								
+		}
+		return result;
+	}
 
+	@SuppressWarnings("unchecked")
+	public static List<UIQueryAST> parseQuery(String query) {
+		UIQueryLexer lexer = new UIQueryLexer(new ANTLRStringStream(query));
+		UIQueryParser parser = new UIQueryParser(new CommonTokenStream(lexer));
 
-    public List<View> allVisibleViews() {
-        return viewFetcher.getAllViews(false);
-    }
+		UIQueryParser.query_return q;
+		try {
+			q = parser.query();
+		} catch (RecognitionException e) {
+			throw new InvalidUIQueryException(e.getMessage());
+		}
+		if (q == null) {
+			throw new InvalidUIQueryException(query);
+		}
+		CommonTree rootNode = (CommonTree) q.getTree();
+		List<CommonTree> queryPath = rootNode.getChildren();
+
+		if (queryPath == null || queryPath.isEmpty()) {
+			queryPath = Collections.singletonList(rootNode);
+		}
+
+		return mapUIQueryFromAstNodes(queryPath);
+	}
+
+
+	public static List<UIQueryAST> mapUIQueryFromAstNodes(List<CommonTree> nodes) {
+		List<UIQueryAST> mapped = new ArrayList<UIQueryAST>(nodes.size());
+		for (CommonTree t : nodes) {
+			mapped.add(uiQueryFromAst(t));
+		}
+		return mapped;
+	}
+
+	public static UIQueryAST uiQueryFromAst(CommonTree step) {
+		String stepType = UIQueryParser.tokenNames[step.getType()];
+		switch (step.getType()) {
+		case UIQueryParser.QUALIFIED_NAME:
+			try {
+				return new UIQueryASTClassName(Class.forName(step.getText()));
+			} catch (ClassNotFoundException e) {
+				// TODO Auto-generated catch block
+				throw new InvalidUIQueryException("Qualified class name: "
+						+ step.getText() + " not found. (" + e.getMessage()
+						+ ")");
+			}
+		case UIQueryParser.NAME:
+			return new UIQueryASTClassName(step.getText());
+		
+		case UIQueryParser.WILDCARD:
+			try {
+				return new UIQueryASTClassName(Class.forName("android.view.View"));
+			} catch (ClassNotFoundException e) {
+				//Cannot happen
+				throw new IllegalStateException(e);
+			}
+			
+
+			
+		case UIQueryParser.FILTER_COLON:
+			return UIQueryASTWith.fromAST(step);
+			
+		case UIQueryParser.ALL:
+			return UIQueryVisibility.ALL;	
+			
+		case UIQueryParser.VISIBLE:
+			return UIQueryVisibility.VISIBLE;
+			
+		case UIQueryParser.BEGINPRED:
+			return UIQueryASTPredicate.newPredicateFromAST(step);
+		case UIQueryParser.DIRECTION:
+			return UIQueryDirection.valueOf(step.getText().toUpperCase());			
+			
+		default:
+			throw new InvalidUIQueryException("Unknown query: " + stepType
+					+ " with text: " + step.getText());
+
+		}
+
+	}
 
     public List<View> rootViews() {
-    	Set<View> parents = new HashSet<View>(8);
-    	for (View v : allVisibleViews()) 
-    	{
-    		parents.add(viewFetcher.getTopParent(v));
-    	}
-    	List<View> results = new ArrayList<View>();
-    	results.addAll(parents);
-    	return results;
+        Set<View> parents = new HashSet<View>();
+        for (View v : viewFetcher.getAllViews(false))
+        {
+            View parent = viewFetcher.getTopParent(v);
+            System.out.println(parent);
+            parents.add(parent);
+        }
+        List<View> results = new ArrayList<View>();
+        results.addAll(parents);
+        return results;
     }
+
+
 }

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/query/UIQuery.tokens

@@ -1,12 +1,19 @@
-BOOL=4
-ESC_SEQ=5
-FILTER_COLON=6
-HEX_DIGIT=7
-INT=8
-NAME=9
-NIL=10
-OCTAL_ESC=11
-QUALIFIED_NAME=12
-STRING=13
-UNICODE_ESC=14
-WHITE=15
+ALL=4
+BEGINPRED=5
+BOOL=6
+DIRECTION=7
+ENDPRED=8
+ESC_SEQ=9
+FILTER_COLON=10
+HEX_DIGIT=11
+INT=12
+NAME=13
+NIL=14
+OCTAL_ESC=15
+QUALIFIED_NAME=16
+RELATION=17
+STRING=18
+UNICODE_ESC=19
+VISIBLE=20
+WHITE=21
+WILDCARD=22

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

@@ -0,0 +1,22 @@
+package sh.calaba.instrumentationbackend.query;
+
+import java.util.HashMap;
+import java.util.Map;
+
+
+public class UIQueryResultVoid {
+	public static final UIQueryResultVoid instance = new UIQueryResultVoid();
+
+	private UIQueryResultVoid() {}
+
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	public Object asMap(String methodName, Object receiver,
+			String errorMessage) {
+		Map map = new HashMap();
+		map.put("error", errorMessage);
+		map.put("methodName", methodName);
+		map.put("receiverClass", receiver.getClass().getName());
+		map.put("receiverString", receiver.toString());
+		return map;
+	}
+}

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

@@ -2,8 +2,10 @@ package sh.calaba.instrumentationbackend.query;
 
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Map.Entry;
 
 import sh.calaba.instrumentationbackend.InstrumentationBackend;
+import sh.calaba.instrumentationbackend.query.ast.UIQueryUtils;
 import android.content.res.Resources;
 import android.view.View;
 import android.widget.Button;
@@ -13,12 +15,10 @@ import android.widget.TextView;
 public class ViewMapper {
 
 	@SuppressWarnings({ "rawtypes", "unchecked" })
-	public static Object extractDataFromView(Object obj) {
-		if (!(obj instanceof View)) {return obj;}
-		View v = (View) obj;
+	public static Object extractDataFromView(View v) {		
+		
 		Map data = new HashMap();
-		data.put("class", v.getClass().getSimpleName());
-		data.put("qualified_class", v.getClass().getName());
+		data.put("class", v.getClass().getName());		
 		data.put("description", v.toString());
 		CharSequence description = v.getContentDescription();
 		data.put("contentDescription", description != null ? description.toString() : null);
@@ -33,16 +33,20 @@ public class ViewMapper {
 		}
 		data.put("id", id);
 
-		Map frame = new HashMap();
+		Map rect = new HashMap();
 		int[] location = new int[2];
 		v.getLocationOnScreen(location);
 
-		frame.put("x", location[0]);
-		frame.put("y", location[1]);
-		frame.put("width", v.getWidth());
-		frame.put("height", v.getHeight());
+		rect.put("x", location[0]);
+		rect.put("y", location[1]);
+		
+		rect.put("center_x", location[0] + v.getWidth()/2.0);
+		rect.put("center_y", location[1] + v.getHeight()/2.0);
+		
+		rect.put("width", v.getWidth());
+		rect.put("height", v.getHeight());
 
-		data.put("frame", frame);
+		data.put("rect", rect);
 
 		if (v instanceof Button) {
 			Button b = (Button) v;
@@ -60,4 +64,30 @@ public class ViewMapper {
 
 	}
 
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	public static Object mapView(Object o) {
+		if (o instanceof View) {
+			return extractDataFromView((View) o);
+		} 
+		else if (o instanceof Map) {			
+			Map copy = new HashMap();			
+			for (Object e : ((Map) o).entrySet()) {
+				Map.Entry entry = (Entry) e;
+				Object value = entry.getValue();
+				if (value instanceof View) {
+					copy.put(entry.getKey(), UIQueryUtils.getId((View) value));
+				}				
+				else {
+					copy.put(entry.getKey(),entry.getValue());
+				}			
+			}
+			
+			return copy;
+		} 
+		else if (o instanceof CharSequence) {
+			return o.toString();
+		}
+		return o;
+	}
+
 }