calabash-android 0.4.0.pre1 → 0.4.0.pre2

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

@@ -0,0 +1,10 @@
+package sh.calaba.instrumentationbackend.query.ast;
+
+@SuppressWarnings("serial")
+public class InvalidUIQueryException extends RuntimeException {
+
+	public InvalidUIQueryException(String query) {
+		super(query);
+	}
+
+}

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

@@ -0,0 +1,8 @@
+package sh.calaba.instrumentationbackend.query.ast;
+
+import java.util.List;
+
+public interface UIQueryAST {
+	@SuppressWarnings("rawtypes")
+	public List evaluateWithViewsAndDirection(List inputViews, UIQueryDirection direction);
+}

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

@@ -0,0 +1,115 @@
+package sh.calaba.instrumentationbackend.query.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class UIQueryASTClassName implements UIQueryAST {
+	public final String simpleClassName;	
+	@SuppressWarnings("rawtypes")
+	public final Class qualifiedClassName;
+	
+	public UIQueryASTClassName(String simpleClassName) 
+	{
+		if (simpleClassName == null) {throw new IllegalArgumentException("Cannot instantiate with null class");}
+		this.simpleClassName = simpleClassName;
+		this.qualifiedClassName = null;
+	}
+	
+	@SuppressWarnings("rawtypes")
+	public UIQueryASTClassName(Class qualifiedClassName)
+	{
+		if (qualifiedClassName == null) {throw new IllegalArgumentException("Cannot instantiate with null class");}
+		this.qualifiedClassName = qualifiedClassName;
+		this.simpleClassName = null;
+		
+	}
+
+	@SuppressWarnings({ "rawtypes"})
+	@Override
+	public List evaluateWithViewsAndDirection(List inputViews,
+			UIQueryDirection direction) {
+		// TODO Auto-generated method stub
+		
+		List result = new ArrayList(8);
+		for (Object o : inputViews) 
+		{			
+			switch(direction) {
+				case DESCENDANT:
+					addDecendantMatchesToResult(o,result);
+					break;
+				case CHILD:
+					addChildMatchesToResult(o,result);
+					break;
+				case PARENT:
+					addParentMatchesToResult(o,result);
+					break;
+			}
+			
+			
+		}
+		
+		
+		return result;
+	}
+
+	@SuppressWarnings("rawtypes")
+	private void addParentMatchesToResult(Object o, List result) {
+		// TODO Auto-generated method stub
+		throw new UnsupportedOperationException();
+	}
+
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	private void addChildMatchesToResult(Object o, List result) {
+		for (Object child : UIQueryUtils.subviews(o))
+		{
+			if (match(child))
+			{
+				result.add(child);
+			}
+		}
+	}
+
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	private void addDecendantMatchesToResult(Object o, List result) {
+		if (match(o)) 
+		{
+			result.add(o);
+		}
+				
+		for (Object child : UIQueryUtils.subviews(o))
+		{		
+			addDecendantMatchesToResult(child, result);
+		}
+		
+	}
+	
+	private boolean match(Object o)
+	{
+		return matchSimpleClassName(o,this.simpleClassName) ||
+				matchQualifiedClassName(o,this.qualifiedClassName);
+	}
+
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	public static boolean matchQualifiedClassName(Object o, Class qualifiedClassName) {
+		return qualifiedClassName != null && qualifiedClassName.isAssignableFrom(o.getClass());
+	}
+
+	public static boolean matchSimpleClassName(Object o, String simpleClassName) {
+		// TODO Auto-generated method stub
+		return simpleClassName != null && simpleClassName.equalsIgnoreCase(o.getClass().getSimpleName());
+	}
+	
+	public String toString() {
+		if (this.simpleClassName != null) 
+		{
+			return "Class["+this.simpleClassName+"]";	
+		}
+		else 
+		{
+			return "Class["+this.qualifiedClassName+"]";
+		}
+		
+	}
+	
+	
+}

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

@@ -0,0 +1,157 @@
+package sh.calaba.instrumentationbackend.query.ast;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.antlr.runtime.tree.CommonTree;
+
+import sh.calaba.instrumentationbackend.InstrumentationBackend;
+import sh.calaba.instrumentationbackend.query.antlr.UIQueryParser;
+import android.content.res.Resources.NotFoundException;
+import android.view.View;
+
+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 evaluateWithViewsAndDirection(List inputViews,
+			UIQueryDirection direction) {
+		List result = new ArrayList(8);
+					
+		for (int i=0;i<inputViews.size();i++)
+		{
+			Object o = inputViews.get(i);
+			if (this.propertyName.equals("id") && hasId(o,this.value))
+			{
+				result.add(o);
+			}
+			else if (this.propertyName.equals("marked") && isMarked(o,this.value))
+			{
+				result.add(o);
+			}
+			else if (this.propertyName.equals("index") && this.value.equals(i))
+			{
+				result.add(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))) 
+					{
+						result.add(o);
+					} 
+					else if (this.value instanceof String && this.value.equals(value.toString())) 
+					{
+						result.add(o);
+					}
+					
+					
+				}
+				
+			}
+	
+		}
+		
+		
+		return result;
+	}
+
+	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;
+		
+		try {
+			String id = InstrumentationBackend.solo.getCurrentActivity()
+					.getResources().getResourceEntryName(view.getId());
+			
+			if (id != null && id.equals(expected))  {
+				return true;
+			}
+		}
+		catch (NotFoundException e) {}
+		return false;
+	}
+
+	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);
+		
+		switch(val.getType())
+		{
+			case UIQueryParser.STRING: {
+				String textWithPings = val.getText();
+				String text = textWithPings.substring(1, textWithPings.length()-1);				
+				return new UIQueryASTWith(prop.getText(), text);
+			}								
+			case UIQueryParser.INT:
+				return new UIQueryASTWith(prop.getText(), Integer.parseInt(val.getText(), 10));
+			case UIQueryParser.BOOL:{
+				String text = val.getText();				
+				return new UIQueryASTWith(prop.getText(), Boolean.parseBoolean(text));
+			}
+			case UIQueryParser.NIL:
+				return new UIQueryASTWith(prop.getText(), null);
+				
+			default:
+				throw new IllegalArgumentException("Unable to parse value type:" + val.getType()+ " text "+val.getText());
+				
+		}
+		
+	}
+	
+	
+	@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,5 @@
+package sh.calaba.instrumentationbackend.query.ast;
+
+public enum UIQueryDirection {
+	DESCENDANT, CHILD, PARENT, ANCESTOR, SIBLING;
+}

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

@@ -0,0 +1,205 @@
+package sh.calaba.instrumentationbackend.query.ast;
+
+import java.io.IOException;
+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 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.org.codehaus.jackson.map.ObjectMapper;
+
+public class UIQueryEvaluator {
+
+	private static class UIQueryResultVoid {
+		public static final UIQueryResultVoid instance = new UIQueryResultVoid();
+		
+		private UIQueryResultVoid() {}
+
+		@SuppressWarnings({ "rawtypes", "unchecked" })
+		public String asJSON(String methodName, Object receiver) {
+			ObjectMapper mapper = new ObjectMapper();
+
+			try {
+				Map map = new HashMap();
+				map.put("error","Unable to invoke method");
+				map.put("methodName",methodName);
+				map.put("receiverClass", receiver.getClass().getName());
+				map.put("receiverString",receiver.toString());
+				return mapper.writeValueAsString(map);
+			} catch (IOException e) {
+				throw new RuntimeException("Could not convert result to json",e);
+			}
+		}
+
+		@SuppressWarnings({ "rawtypes", "unchecked" })
+		public Object asJSON(String methodName, Object receiver,String errorMessage) {
+			ObjectMapper mapper = new ObjectMapper();
+
+			try {
+				Map map = new HashMap();
+				map.put("error",errorMessage);
+				map.put("methodName",methodName);
+				map.put("receiverClass", receiver.getClass().getName());
+				map.put("receiverString",receiver.toString());
+				return mapper.writeValueAsString(map);
+			} catch (IOException e) {
+				throw new RuntimeException("Could not convert result to json",e);
+			}
+		}
+	}
+
+	@SuppressWarnings({ "rawtypes" })
+	public static List evaluateQuery(String query, List inputViews) {
+		return evaluateQueryForPath(parseQuery(query), inputViews);
+	}
+
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	public static List evaluateQueryWithOptions(String query, List inputViews,
+			List options) {
+		
+        long before = System.currentTimeMillis();
+        List views = evaluateQueryForPath(parseQuery(query), inputViews);
+        long after = System.currentTimeMillis();
+        String action = "EvaluateQueryNoOptions";
+        System.out.println(action+ " took: "+ (after-before) + "ms");
+
+		
+
+		List result = views;
+		for (Object methodNameObj : options) {
+			String propertyName = (String) methodNameObj;
+			List nextResult = new ArrayList(views.size());
+			for (Object o : result) {
+				try {
+					
+					before = System.currentTimeMillis();
+					
+					Method m = UIQueryUtils.hasProperty(o, propertyName);
+					after = System.currentTimeMillis();
+			        action = "HasProperty";
+			        System.out.println(action+ " took: "+ (after-before) + "ms");
+
+
+					if (m != null) {
+						nextResult.add(m.invoke(o));	
+					}
+					else 
+					{
+						nextResult.add(UIQueryResultVoid.instance.asJSON(propertyName,o,"NO accessor for "+propertyName));
+					}
+					
+				} catch (Exception e) {
+					System.out.println(e.getMessage());
+					nextResult.add(UIQueryResultVoid.instance.asJSON(propertyName,o));
+				}
+			}
+			result = nextResult;
+		}
+		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));
+
+		UIQueryParser.query_return q;
+		try {
+			q = parser.query();
+		} catch (RecognitionException e) {
+			// TODO Auto-generated catch block
+			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);
+	}
+
+	@SuppressWarnings("rawtypes")
+	private static List evaluateQueryForPath(List<UIQueryAST> queryPath,
+			List inputViews) {
+
+		List currentResult = inputViews;
+		UIQueryDirection currentDirection = UIQueryDirection.DESCENDANT;
+		for (UIQueryAST step : queryPath) {			
+			if (isDirection(step)) {
+				currentDirection = directionFromAst(step);
+			} else {
+				System.out.println(step);
+		        long before = System.currentTimeMillis();
+		        		        
+
+				currentResult = step.evaluateWithViewsAndDirection(
+						currentResult, currentDirection);
+				long after = System.currentTimeMillis();
+		        String action = "EvaluateQueryNoOptions" + step.toString();
+		        System.out.println(action+ " took: "+ (after-before) + "ms");
+
+			}
+
+		}
+		return currentResult;
+	}
+
+	public static UIQueryDirection directionFromAst(UIQueryAST step) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	public static boolean isDirection(UIQueryAST step) {
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	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.FILTER_COLON:
+			return UIQueryASTWith.fromAST(step);
+		default:
+			throw new InvalidUIQueryException("Unknown query: " + stepType
+					+ " with text: " + step.getText());
+
+		}
+
+	}
+
+}