testautoa 0.4.0 → 0.4.1

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

@@ -0,0 +1,45 @@
+package sh.calaba.instrumentationbackend.query.ast;
+
+import android.annotation.SuppressLint;
+
+public class BeginsWithRelation implements UIQueryASTPredicateRelation {
+
+	private final boolean caseSensitive;
+		
+	public BeginsWithRelation(boolean isCaseSensitive) {
+		super();
+		this.caseSensitive = isCaseSensitive;
+	}
+
+	
+	public boolean isCaseSensitive() { 
+		return caseSensitive;
+	}
+
+	/**
+	 * Does firstValue BEGIN WITH secondValue?
+	 */
+	@SuppressLint("DefaultLocale")
+	@Override
+	public boolean areRelated(Object firstValue, Object secondValue) {
+		if (firstValue == secondValue) { 
+			return true;
+		}
+		if (firstValue == null || secondValue == null) {
+			return false;
+		}
+		if (firstValue instanceof CharSequence && secondValue instanceof CharSequence) {
+			String firstStr = firstValue.toString();
+			String secondStr = secondValue.toString();
+			if (!isCaseSensitive()) {
+				firstStr = firstStr.toLowerCase();
+				secondStr = secondStr.toLowerCase();
+			}			
+			return firstStr.startsWith(secondStr);			
+		}
+		else {
+			return false;
+		}
+	}
+
+}

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

@@ -0,0 +1,54 @@
+package sh.calaba.instrumentationbackend.query.ast;
+
+public enum ComparisonOperator implements UIQueryASTPredicateRelation {
+
+	LESSTHAN {
+		public boolean areRelated(Object firstValue, Object secondValue) {
+			if (areNumbers(firstValue, secondValue)) {
+				Number firstNum = (Number) firstValue;
+				Number secondNum = (Number) secondValue;
+				return firstNum.doubleValue() < secondNum.doubleValue();
+			} else {
+				return false;
+			}
+		}
+	},
+
+	LESSTHANOREQUAL {
+		public boolean areRelated(Object firstValue, Object secondValue) {
+			return EQUAL.areRelated(firstValue, secondValue) || LESSTHAN.areRelated(firstValue, secondValue);
+		}
+	},
+
+	EQUAL {
+		public boolean areRelated(Object firstValue, Object secondValue) {
+			if (firstValue == secondValue) {
+				return true;
+			}
+			return (firstValue != null) && firstValue.equals(secondValue);					
+		}
+	},
+
+	GREATERTHAN {
+		public boolean areRelated(Object firstValue, Object secondValue) {
+			if (areNumbers(firstValue, secondValue)) {
+				Number firstNum = (Number) firstValue;
+				Number secondNum = (Number) secondValue;
+				return firstNum.doubleValue() > secondNum.doubleValue();
+			} else {
+				return false;
+			}
+		}
+	},
+
+	GREATERTHANOREQUAL {
+		public boolean areRelated(Object firstValue, Object secondValue) {
+			return EQUAL.areRelated(firstValue, secondValue) || GREATERTHAN.areRelated(firstValue, secondValue);
+		}
+	};
+
+	protected boolean areNumbers(Object firstValue, Object secondValue) {
+		return (firstValue instanceof Number && secondValue instanceof Number);
+	}
+
+}

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

@@ -0,0 +1,41 @@
+package sh.calaba.instrumentationbackend.query.ast;
+
+public class ContainsRelation implements UIQueryASTPredicateRelation {
+
+	private final boolean caseSensitive;
+	
+	public ContainsRelation(boolean isCaseSensitive) {
+		super();
+		this.caseSensitive = isCaseSensitive;
+	}
+
+	public boolean isCaseSensitive() { 
+		return caseSensitive;
+	}
+
+	/**
+	 * Does firstValue CONTAIN secondValue?
+	 */
+	@Override
+	public boolean areRelated(Object firstValue, Object secondValue) {
+		if (firstValue == secondValue) { 
+			return true;
+		}
+		if (firstValue == null || secondValue == null) {
+			return false;
+		}
+		if (firstValue instanceof CharSequence && secondValue instanceof CharSequence) {
+			String firstStr = firstValue.toString();
+			String secondStr = secondValue.toString();
+			if (!isCaseSensitive()) {
+				firstStr = firstStr.toLowerCase();
+				secondStr = secondStr.toLowerCase();
+			}						
+			return firstStr.indexOf(secondStr) != -1;	
+		}
+		else {
+			return false;
+		}
+	}
+
+}

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

@@ -0,0 +1,42 @@
+package sh.calaba.instrumentationbackend.query.ast;
+
+public class EndsWithRelation implements UIQueryASTPredicateRelation {
+
+	private final boolean caseSensitive;
+	
+	public EndsWithRelation(boolean isCaseSensitive) {
+		super();
+		this.caseSensitive = isCaseSensitive;
+	}
+
+	public boolean isCaseSensitive() { 
+		return caseSensitive;
+	}
+
+
+	/**
+	 * Does firstValue END WITH secondValue?
+	 */
+	@Override
+	public boolean areRelated(Object firstValue, Object secondValue) {
+		if (firstValue == secondValue) { 
+			return true;
+		}
+		if (firstValue == null || secondValue == null) {
+			return false;
+		}
+		if (firstValue instanceof CharSequence && secondValue instanceof CharSequence) {
+			String firstStr = firstValue.toString();
+			String secondStr = secondValue.toString();
+			if (!isCaseSensitive()) {
+				firstStr = firstStr.toLowerCase();
+				secondStr = secondStr.toLowerCase();
+			}						
+			return firstStr.endsWith(secondStr);		
+		}
+		else {
+			return false;
+		}
+	}
+
+}

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

@@ -0,0 +1,79 @@
+package sh.calaba.instrumentationbackend.query.ast;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class LikeRelation implements UIQueryASTPredicateRelation {
+
+	private final boolean caseSensitive;
+
+	public LikeRelation(boolean isCaseSensitive) {
+		super();
+		this.caseSensitive = isCaseSensitive;
+	}
+
+	public boolean isCaseSensitive() {
+		return caseSensitive;
+	}
+
+	/**
+	 * Is firstValue LIKE secondValue? In this case secondValue is a pattern ala
+	 * 'Cou* Down' which will match a string 'Count Down'.
+	 */
+	@Override
+	public boolean areRelated(Object firstValue, Object secondValue) {
+		if (firstValue == secondValue) {
+			return true;
+		}
+		if (firstValue == null || secondValue == null) {
+			return false;
+		}
+		if (firstValue instanceof CharSequence
+				&& secondValue instanceof CharSequence) {
+			String firstStr = firstValue.toString();
+			String patternStr = secondValue.toString();
+			Matcher matcher = matcherFrom(patternStr, firstStr);
+			return matcher.matches();
+		} else {
+			return false;
+		}
+	}
+
+	private Matcher matcherFrom(String patternStr, String stringToMatch) {
+		Pattern compiledPat;
+		if (isCaseSensitive()) {
+			compiledPat = Pattern.compile(translatePatternString(patternStr));
+		} else {
+			compiledPat = Pattern.compile(translatePatternString(patternStr),
+					Pattern.CASE_INSENSITIVE);
+		}
+		return compiledPat.matcher(stringToMatch);
+	}
+
+	private String translatePatternString(String patternStr) {
+
+		StringBuilder converted = new StringBuilder();
+		int beginAt = 0;
+		for (int i = 0; i < patternStr.length(); i++) {
+			char charAti = patternStr.charAt(i);
+			if (charAti == '*' || charAti == '%') {
+				String subString = patternStr.substring(beginAt, i);
+				beginAt = i + 1;
+				converted.append(Pattern.quote(subString));
+				if (charAti == '*') {
+					converted.append(".*");
+				} else if (charAti == '%') {
+					converted.append(".");
+				}
+			}
+		}
+		if (beginAt < patternStr.length()) {
+			String subString = patternStr.substring(beginAt,
+					patternStr.length());
+			converted.append(Pattern.quote(subString));
+		}
+
+		return "^" + converted.toString() + "$";
+	}
+
+}

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

@@ -0,0 +1,100 @@
+package sh.calaba.instrumentationbackend.query.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+/**
+ * Represents a List where at most one result is a Future.
+ * This class is itself a Future which is realized if the list contains no future,
+ * and if the list does contain a Future, this object is realized once that Future is.
+ * 
+ * We can think of it as a way to "lift" a list containing a Future into the set of Futures.
+ * @author krukow
+ *
+ */
+@SuppressWarnings("rawtypes")
+public class PartialFutureList implements Future {
+	
+	
+	private final Future theFutureResult;	
+	private final List originalList;	
+	
+	public PartialFutureList(List listWithOneFuture) {
+		this.theFutureResult = extractFuture(listWithOneFuture);
+		this.originalList = listWithOneFuture;
+	}
+
+	
+	@Override
+	public boolean cancel(boolean mayInterruptIfRunning) {
+		if (theFutureResult == null) {
+			return false;
+		}
+		else {
+			return theFutureResult.cancel(mayInterruptIfRunning);
+		}
+	}
+	
+	@Override
+	public Object get() throws InterruptedException, ExecutionException {
+		if (theFutureResult == null) {
+			return originalList;
+		}		
+		return fillListWithResult(theFutureResult.get());
+	}
+
+	
+	@Override
+	public Object get(long timeout, TimeUnit unit) throws InterruptedException,
+			ExecutionException, TimeoutException {
+		if (theFutureResult == null) {
+			return originalList;
+		}		
+		return fillListWithResult(theFutureResult.get(timeout,unit));
+	}
+
+	@Override
+	public boolean isCancelled() {
+		if (theFutureResult == null) {
+			return false;
+		}		
+		return theFutureResult.isCancelled();
+	}
+
+	@Override
+	public boolean isDone() {
+		if (theFutureResult == null) {
+			return false;
+		}		
+		return theFutureResult.isDone();
+	}
+	
+	@SuppressWarnings({ "unchecked" })
+	private Object fillListWithResult(Object futureResultObject) {
+		List result = new ArrayList(this.originalList.size());
+		for (Object o : this.originalList) {
+			if (o instanceof Future) {//Assume only one future
+				result.add(futureResultObject);
+			} else {
+				result.add(o);
+			}
+		}
+		return result;
+	}
+	
+	private Future extractFuture(List evaluateWithViews) {
+		for (Object o : evaluateWithViews) {
+			if (o instanceof Future) {
+				return (Future) o;
+			}
+		}
+		return null;
+	}
+
+
+
+}

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

@@ -4,5 +4,5 @@ import java.util.List;
 
 public interface UIQueryAST {
 	@SuppressWarnings("rawtypes")
-	public List evaluateWithViewsAndDirection(List inputViews, UIQueryDirection direction);
+	public List evaluateWithViews(List inputViews, UIQueryDirection direction, UIQueryVisibility visibility);
 }

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

@@ -2,6 +2,9 @@ package sh.calaba.instrumentationbackend.query.ast;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.Callable;
+
+import android.view.View;
 
 public class UIQueryASTClassName implements UIQueryAST {
 	public final String simpleClassName;	
@@ -20,42 +23,68 @@ public class UIQueryASTClassName implements UIQueryAST {
 	{
 		if (qualifiedClassName == null) {throw new IllegalArgumentException("Cannot instantiate with null class");}
 		this.qualifiedClassName = qualifiedClassName;
-		this.simpleClassName = null;
-		
+		this.simpleClassName = null;		
 	}
 
 	@SuppressWarnings({ "rawtypes"})
 	@Override
-	public List evaluateWithViewsAndDirection(List inputViews,
-			UIQueryDirection direction) {
-		// TODO Auto-generated method stub
+	public List evaluateWithViews(final List inputViews,
+			final UIQueryDirection direction, final UIQueryVisibility visibility) {
 		
-		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 (List) UIQueryUtils.evaluateSyncInMainThread(new Callable() {		
 			
-		}
+			public Object call() throws Exception {
+				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;
+						case SIBLING:
+							addSiblingMatchesToResult(o,result);
+							break;
+					}
+					
+					
+				}
+
+                List filteredResult = visibility.evaluateWithViews(result, direction, visibility);
+				return filteredResult;
+			}
+		});
 		
 		
-		return result;
 	}
 
-	@SuppressWarnings("rawtypes")
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	protected void addSiblingMatchesToResult(Object o, List result) {
+		List parents = UIQueryUtils.parents(o);
+		if (parents != null && !parents.isEmpty()) {
+			Object immediateParent = parents.get(0);
+			for (Object v : UIQueryUtils.subviews(immediateParent)) {
+				if (v != o && match(v)) {
+					result.add(v);
+				}
+			}									
+		}		
+	}
+
+	@SuppressWarnings({ "rawtypes", "unchecked" })
 	private void addParentMatchesToResult(Object o, List result) {
-		// TODO Auto-generated method stub
-		throw new UnsupportedOperationException();
+		for (Object parent : UIQueryUtils.parents(o))
+		{
+			if (match(parent))
+			{
+				result.add(parent);
+			}
+		}		
 	}
 
 	@SuppressWarnings({ "rawtypes", "unchecked" })

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

@@ -0,0 +1,147 @@
+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 org.antlr.runtime.tree.CommonTree;
+
+import android.view.View;
+
+public class UIQueryASTPredicate implements UIQueryAST {
+
+	private final String propertyName;
+	private final UIQueryASTPredicateRelation relation;
+	private final Object valueToMatch;
+
+	public UIQueryASTPredicate(String text,
+			UIQueryASTPredicateRelation parsedRelation, Object parsedValue) {
+		this.propertyName = text;
+		this.relation = parsedRelation;
+		this.valueToMatch = parsedValue;
+	}
+
+	@SuppressWarnings("rawtypes")
+	@Override
+	public List evaluateWithViews(final List inputViews,
+			final UIQueryDirection direction, final UIQueryVisibility visibility) {
+		return (List) UIQueryUtils.evaluateSyncInMainThread(new Callable() {
+
+			@SuppressWarnings("unchecked")
+			@Override
+			public Object call() throws Exception {
+				List filteredResult = new ArrayList(16);
+				for (int i = 0; i < inputViews.size(); i++) {
+					Object o = inputViews.get(i);
+
+					if (o instanceof Map) {
+						Map result = evaluateForMap((Map) o);
+						if (result != null) {
+							filteredResult.add(result);
+						}
+
+					} else {
+						Object result = evaluateForObject(o, i);
+						if (result != null) {
+							filteredResult.add(result);
+						}
+					}
+
+				}
+
+				return visibility.evaluateWithViews(filteredResult, direction, visibility);
+			}
+		});
+	}
+
+	@SuppressWarnings("rawtypes")
+	private Map evaluateForMap(Map map) {
+		if (map.containsKey(this.propertyName)) {
+			Object value = map.get(this.propertyName);
+			if (this.relation.areRelated(value, this.valueToMatch)) {
+				return map;
+			}
+		}
+		return null;
+	}
+
+	private Object evaluateForObject(Object o, int index) {
+		if (o instanceof View && this.propertyName.equals("id")) {
+			View view = (View) o;
+			String id = UIQueryUtils.getId(view);
+			if (this.relation.areRelated(id, this.valueToMatch)) {
+				return o;
+			} else {
+				// let it fall through and check via general property access
+				// in case the user actually wants to compre the real value of
+				// getId()
+			}
+		}
+
+		Method propertyAccessor = UIQueryUtils
+				.hasProperty(o, this.propertyName);
+		if (propertyAccessor == null) {
+			return null;
+		}
+		Object value = UIQueryUtils.getProperty(o, propertyAccessor);
+
+		if (this.relation.areRelated(value, this.valueToMatch)) {
+			return o;
+		} else if (this.valueToMatch instanceof String
+				&& this.relation
+						.areRelated(value.toString(), this.valueToMatch)) {
+			return o;
+		} else {
+			return null;
+		}
+	}
+
+	public static UIQueryASTPredicate newPredicateFromAST(CommonTree step) {
+		// TODO Auto-generated method stub
+		if (step.getChildCount() != 3) {
+			throw new IllegalStateException("Bad Predicate query: "+step+". Expected form {getter RELATION value}.");
+		}
+		CommonTree prop = (CommonTree) step.getChild(0);
+		CommonTree rel = (CommonTree) step.getChild(1);
+		CommonTree val = (CommonTree) step.getChild(2);
+		return new UIQueryASTPredicate(prop.getText(),
+				UIQueryASTPredicate.parseRelation(rel),
+				UIQueryUtils.parseValue(val));
+			
+	}
+
+	private static UIQueryASTPredicateRelation parseRelation(CommonTree rel) {
+		String relText = rel.getText().toUpperCase();
+		boolean caseSensitive = true;
+		final String CASE_INSENSITIVE_SPEC = "[C]";
+		if (relText.endsWith(CASE_INSENSITIVE_SPEC)) {
+			caseSensitive = false;
+			relText = relText.substring(0,relText.length() - CASE_INSENSITIVE_SPEC.length());
+		}
+		
+		if ("BEGINSWITH".equals(relText)) {
+			return new BeginsWithRelation(caseSensitive);
+		} else if ("ENDSWITH".equals(relText)) {
+			return new EndsWithRelation(caseSensitive);
+		} else if ("CONTAINS".equals(relText)) {
+			return new ContainsRelation(caseSensitive);
+		} else if ("LIKE".equals(relText)) {
+			return new LikeRelation(caseSensitive);
+		} else if ("<".equals(relText)) {
+			return ComparisonOperator.LESSTHAN;
+		} else if ("<=".equals(relText)) {
+			return ComparisonOperator.LESSTHANOREQUAL;
+		} else if ("=".equals(relText)) {
+			return ComparisonOperator.EQUAL;
+		} else if (">".equals(relText)) {
+			return ComparisonOperator.GREATERTHAN;
+		} else if (">=".equals(relText)) {
+			return ComparisonOperator.GREATERTHANOREQUAL;
+		} else {
+			throw new IllegalStateException("Unsupported Relation: " + relText);
+		}
+	}
+
+}

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

@@ -0,0 +1,5 @@
+package sh.calaba.instrumentationbackend.query.ast;
+
+public interface UIQueryASTPredicateRelation {				
+	public boolean areRelated(Object firstValue, Object secondValue);
+}