calabash-android 0.2.11 → 0.2.12

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/actions/view/AssertViewProperty.java

@@ -0,0 +1,141 @@
+package sh.calaba.instrumentationbackend.actions.view;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import android.graphics.Bitmap;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.DrawableContainer;
+import android.util.Log;
+import android.view.View;
+import android.widget.TextView;
+import sh.calaba.instrumentationbackend.Result;
+import sh.calaba.instrumentationbackend.TestHelpers;
+import sh.calaba.instrumentationbackend.actions.Action;
+
+
+/**
+ * eg: performAction( 'assert_view_property', 'my_view', 'visibility', 'visible' )  // or invisible/gone
+ * eg: performAction( 'assert_view_property', 'my_view', 'drawable', 'expected_id' )
+ * eg: performAction( 'assert_view_property', 'my_view', 'compoundDrawables', 'left', 'expected_id' )
+ * 
+ * @author Nicholas Albion
+ */
+public class AssertViewProperty extends GetViewProperty implements Action {
+	private static final String TAG = "assert_view_property";
+
+	@Override
+	protected Result getPropertyValue( String propertyName, View view, String[] args ) throws NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {
+		if( "compoundDrawables".equals(propertyName) ) {
+			if( view instanceof TextView ) {
+				// performAction( 'get_view_property', 'my_view', 'compoundDrawables', 'left', 'expected_id'
+				String expected_id = args[3];
+				int pos;
+				if( "top".equals(args[2]) ) {
+					pos = 1;
+				} else if( "right".equals(args[2]) ) {
+					pos = 2;
+				} else if( "bottom".equals(args[2]) ) {
+					pos = 3;
+				} else {
+					pos = 0;
+				}
+				Drawable[] drawables = ((TextView)view).getCompoundDrawables();		// [left, top, right, bottom]
+				Drawable actualDrawable = drawables[pos];
+				Drawable expectedDrawable = TestHelpers.getDrawableById(expected_id);
+				return assertSameDrawables( propertyName + ", " + args[2], expectedDrawable, actualDrawable );
+			} else {
+				throw new IllegalArgumentException("compoundDrawables is only supported for subclasses of TextView, not " + view.getClass().getName());
+			}
+		} else {
+			return super.getPropertyValue(propertyName, view, args);
+		}
+	}
+	
+	/**
+	 * @param propertyName
+	 * @param propertyValue
+	 * @param args
+	 * @return successResult if <code>propertyValue</code> is equal to <code>args[2]</code>
+	 * 			otherwise provides a descriptive message and the expected and actual values in the <code>bonusInformation</code> 
+	 */
+	@Override
+	protected Result processProperty( String propertyName, Object propertyValue, String[] args ) {
+		String expected = args[2];
+		String value;
+		if( propertyValue == null ) {
+			if( expected == null || "null".equals(expected) ) {
+				return Result.successResult();
+			}
+			value = "null";
+		} else if( "drawable".equals(propertyName) ) {
+			Drawable actualDrawable = (Drawable)propertyValue; //  ((ImageButton)view).getDrawable();
+			if( actualDrawable instanceof DrawableContainer ) {
+				actualDrawable = ((DrawableContainer)actualDrawable).getCurrent();
+			}
+			Drawable expectedDrawable = TestHelpers.getDrawableById(expected);
+			return assertSameDrawables( propertyName, expectedDrawable, actualDrawable );
+		} else {
+			value = propertyValue.toString();
+			if( value.equals(expected) ) {
+				return Result.successResult();
+			}
+		}
+		Result result = new Result(false, "For " + propertyName + " expected " + expected + " but was actually " + value);
+		result.addBonusInformation( expected );
+		result.addBonusInformation( value );
+		return result;
+	}
+    
+	private Result assertSameDrawables( String propertyName, Drawable expectedDrawable, Drawable actualDrawable ) {
+		if( sameDrawables( expectedDrawable, actualDrawable) ) {
+			return Result.successResult();
+		} else {
+			Result result = new Result(false, "For " + propertyName + " expected " + expectedDrawable + " but was actually " + actualDrawable);
+			result.addBonusInformation( expectedDrawable == null ? "null" : expectedDrawable.toString() );
+			result.addBonusInformation( actualDrawable == null ? "null" : actualDrawable.toString() );
+			return result;
+		}
+	}
+	
+	private boolean sameDrawables( Drawable expected, Drawable actual ) {
+		if( expected.equals(actual) ) {
+			return true;
+		}
+		if( expected instanceof DrawableContainer ) {
+			expected = ((DrawableContainer)expected).getCurrent();
+		}
+		if( actual instanceof DrawableContainer ) {
+			actual = ((DrawableContainer)actual).getCurrent();
+		}
+		if( (expected instanceof BitmapDrawable) && (actual instanceof BitmapDrawable) ) {
+			Bitmap expectedBitmap = ((BitmapDrawable)expected).getBitmap();
+			Bitmap actualBitmap = ((BitmapDrawable)actual).getBitmap();
+			try {
+				// As pointed out by kbielenberg, Bitmap.sameAs() was only added in level 12/Android 3.1/Honeycomb MR1
+				Method sameAs = Bitmap.class.getMethod("sameAs", Bitmap.class);
+				return (Boolean)sameAs.invoke( expectedBitmap, actualBitmap );
+			} catch (Exception e) {
+				if( expectedBitmap.getWidth() != actualBitmap.getWidth() ) { return false; }
+				if( expectedBitmap.getHeight() != actualBitmap.getHeight() ) { return false; }
+				if( expectedBitmap.getConfig() != actualBitmap.getConfig() ) { return false; }
+				boolean bitmapsEqual = expectedBitmap.equals(actualBitmap);
+				if( !bitmapsEqual ) {
+					Log.i(TAG, "Bitmaps are not equal");
+				}
+				boolean drawablesEqual = expected.equals(actual);
+				if( !drawablesEqual ) {
+					Log.i(TAG, "Drawables are not equal");
+				}
+				return bitmapsEqual && drawablesEqual;
+			}
+		}
+		return false;
+	}
+
+	@Override
+	public String key() {
+		return "assert_view_property";
+	}
+}

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/actions/view/ClickOnViewById.java

@@ -32,14 +32,7 @@ public class ClickOnViewById implements Action {
 			System.out.println(xy[0]);
 			System.out.println(xy[1]);
 			
-			//InstrumentationBackend.solo.clickOnView(view);		
-			if (view.isClickable()) {
-				InstrumentationBackend.solo.getCurrentActivity().runOnUiThread(new Runnable() {
-					public void run() {
-						view.performClick();
-					}	
-				});
-			}
+			InstrumentationBackend.solo.clickOnView(view);		
 		} catch(junit.framework.AssertionFailedError e) {
 			System.out.println("solo.clickOnView failed - using fallback");
 			if (view.isClickable()) {

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/actions/view/GetActivityName.java

@@ -0,0 +1,32 @@
+package sh.calaba.instrumentationbackend.actions.view;
+
+import sh.calaba.instrumentationbackend.InstrumentationBackend;
+import sh.calaba.instrumentationbackend.Result;
+import sh.calaba.instrumentationbackend.actions.Action;
+import android.app.Activity;
+import android.app.TabActivity;
+
+/**
+ * @author Nicholas Albion
+ */
+@SuppressWarnings("deprecation")
+public class GetActivityName implements Action {
+
+	@Override
+	public Result execute(String... args) {
+		Activity currentActivity = InstrumentationBackend.solo.getCurrentActivity();
+		
+		Result result = new Result(true, currentActivity.getClass().getSimpleName());
+		
+		if( currentActivity instanceof TabActivity ) {
+			result.addBonusInformation( ((TabActivity)currentActivity).getTabHost().getCurrentTabTag() );
+		}
+		
+		return result;
+	}
+
+	@Override
+	public String key() {
+		return "get_activity_name";
+	}
+}

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/actions/view/GetViewProperty.java

@@ -0,0 +1,107 @@
+package sh.calaba.instrumentationbackend.actions.view;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import sh.calaba.instrumentationbackend.Result;
+import sh.calaba.instrumentationbackend.actions.Action;
+import sh.calaba.instrumentationbackend.actions.wait.WaitForViewById;
+import android.view.View;
+
+/**
+ * eg: performAction( 'get_view_property', 'my_view', 'visibility')  => visible, invisible or gone
+ * 
+ * @see AssertViewProperty
+ * @author Nicholas Albion
+ */
+public class GetViewProperty extends WaitForViewById implements Action {
+
+	@Override
+	public Result execute(String... args) {
+		String viewId = args[0];
+        
+        try {
+        	View view = getViewById(viewId, 60000);
+        	if( view != null ) {
+//        		Result result = new Result(true);
+//        		
+//        		String propertyName = args[1].toLowerCase();
+//        		String value = getPropertyValue(propertyName, view, args);
+//        		result.setMessage( value );
+        		
+        		String propertyName = args[1].toLowerCase();
+        		return getPropertyValue(propertyName, view, args);
+        	} else {
+        		return new Result(false, "Timed out while waiting for view with id:'" + viewId + "'");
+        	}
+        } catch( Exception e ) {
+    		return Result.fromThrowable(e);
+        }
+	}
+	
+	/**
+	 * @param propertyName
+	 * @param view
+	 * @param args - used by {@link AssertViewProperty#getPropertyValue}
+	 * @return
+	 * @throws NoSuchMethodException
+	 * @throws IllegalArgumentException
+	 * @throws IllegalAccessException
+	 * @throws InvocationTargetException
+	 */
+	protected Result getPropertyValue( String propertyName, View view, String[] args ) throws NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {
+		if( "visibility".equals(propertyName) ) {
+			String value;
+			
+			switch( view.getVisibility() ) {
+			case View.VISIBLE:
+				value = "visible";
+				break;
+			case View.INVISIBLE:
+				value = "invisible";
+				break;
+			case View.GONE:
+				value = "gone";
+				break;
+			default:
+				value = Integer.toString(view.getVisibility());
+			}
+			
+			return new Result( true, value );
+		} else {
+			// resort to reflection
+			Class<? extends View> clazz = view.getClass();
+			Method method = null;
+			try {
+				String methodName = propertyName;
+				method = clazz.getMethod( methodName );
+			} catch( NoSuchMethodException e ) {
+				try {
+					String methodName = "get" + Character.toUpperCase(propertyName.charAt(0)) + propertyName.substring(1);
+					method = clazz.getMethod( methodName );
+				} catch( NoSuchMethodException e2 ) {
+					String methodName = "is" + Character.toUpperCase(propertyName.charAt(0)) + propertyName.substring(1);
+					method = clazz.getMethod( methodName );
+				}
+			}
+			Object valueObj = method.invoke(view);
+			return processProperty( propertyName, valueObj, args );
+		}
+	}
+	
+	/**
+	 * @param propertyName
+	 * @param propertyValue
+	 * @param args - used by {@link AssertViewProperty#getPropertyValue}
+	 * @return a successful result with the requested property as the <code>message</code> field
+	 */
+	protected Result processProperty( String propertyName, Object propertyValue, String[] args ) {
+		String message = (propertyValue == null) ? "null" : propertyValue.toString();
+		return new Result( true, message );
+	}
+
+	@Override
+	public String key() {
+		return "get_view_property";
+	}
+}

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/actions/view/HasView.java

@@ -0,0 +1,31 @@
+package sh.calaba.instrumentationbackend.actions.view;
+
+import sh.calaba.instrumentationbackend.Result;
+import sh.calaba.instrumentationbackend.TestHelpers;
+import sh.calaba.instrumentationbackend.actions.Action;
+import android.view.View;
+
+public class HasView implements Action {
+
+    @Override
+    public Result execute(String... args) {
+        final String idArgument = args[0];
+        final View foundView = TestHelpers.getViewById(idArgument);
+        
+        if( null == foundView ) {
+            return notFoundResult(idArgument);
+        }
+        
+        return Result.successResult();
+    }
+
+    @Override
+    public String key() {
+        return "has_view";
+    }
+
+    private Result notFoundResult(final String firstArgument) {
+        return Result.failedResult(String.format("View with id %s was not found", firstArgument));
+    }
+}
+

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/actions/view/Press.java

@@ -29,7 +29,7 @@ public class Press implements Action {
             }
         }
 
-        // Try to pres view with content description
+        // Try to press view with content description
         if (viewToPress == null) {
             helpText += "Content descriptions:\n";
             for (View view : InstrumentationBackend.solo.getCurrentViews()) {

data/test-server/instrumentation-backend/src/sh/calaba/instrumentationbackend/actions/view/SelectTab.java

@@ -0,0 +1,110 @@
+package sh.calaba.instrumentationbackend.actions.view;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import android.app.Activity;
+import android.app.TabActivity;
+import android.util.Log;
+import android.view.View;
+import android.widget.TabHost;
+import android.widget.TextView;
+import sh.calaba.instrumentationbackend.InstrumentationBackend;
+import sh.calaba.instrumentationbackend.Result;
+import sh.calaba.instrumentationbackend.actions.Action;
+
+/**
+ * Select the tab by 1-based index or by name
+ * 
+ * @author Nicholas Albion
+ */
+@SuppressWarnings("deprecation")
+public class SelectTab implements Action {
+	@Override
+	public Result execute(String... args) {
+		
+		Activity currentActivity = InstrumentationBackend.solo.getCurrentActivity();
+		
+		if( currentActivity instanceof TabActivity == false ) {
+			Activity parent = currentActivity.getParent();
+			if( parent != null ) {
+				currentActivity = parent;
+			}
+		}
+		
+		if( currentActivity instanceof TabActivity ) {
+			final TabHost tabHost = ((TabActivity)currentActivity).getTabHost();
+			
+			String tabName = args[0];
+			if( tabName.length() == 1 ) {
+				char c = tabName.charAt(0);
+				if( c >= '0' && c <= '9' ) {
+					int index = (c - '0') - 1;
+					tabHost.setCurrentTab( index );
+					return Result.successResult();
+				}
+			}
+
+			List<String> foundTabs = new LinkedList<String>();
+			int numberOfTabs = ((TabActivity)currentActivity).getTabWidget().getTabCount();
+			Log.i("SelectTab", "numberOfTabs: " + numberOfTabs);
+			
+			String resultMessage = null;
+			int tabIndex;
+FIND_TAB:			
+			for( tabIndex = 0; tabIndex < numberOfTabs; tabIndex++ ) {
+				if( tabName.equals( tabHost.getTag(tabIndex) ) ) {
+					resultMessage = "Selected the tab by tag";
+					break;
+				}
+				
+				String currentTab;
+				View view = tabHost.getTabWidget().getChildTabViewAt(tabIndex);
+        		if( view instanceof TextView ) {
+        			currentTab = ((TextView)view).getText().toString();	
+        			if( tabName.equals(currentTab) ) {
+        				resultMessage = "Selected the tab by text view";
+        				break;
+            		}
+        			foundTabs.add(currentTab);
+        		} else {
+        			Log.i("SelectTab", "current tab view: " + view.getId() + ", " + view.getClass().getSimpleName());
+        			List<TextView> textViews = InstrumentationBackend.solo.getCurrentTextViews(view);
+        			for( TextView textView : textViews ) {
+        				currentTab = textView.getText().toString();
+        				Log.i("SelectTab", " child text view: " + currentTab);
+            			if( tabName.equals(currentTab) ) {
+            				resultMessage = "Selected the tab by child text view";
+            				break FIND_TAB;
+                		}
+            			foundTabs.add(currentTab);
+					}
+        		}
+			}
+			
+			if( resultMessage != null ) {
+				final int matchingTabIndex = tabIndex;
+				
+				currentActivity.runOnUiThread( new Runnable() {
+					@Override
+					public void run() {
+						tabHost.setCurrentTab( matchingTabIndex );
+					}
+				});
+				
+				return new Result(true, resultMessage);
+			}
+			
+			Result result = new Result(false, "Was unable to find a matching tab");
+			result.setExtras( foundTabs );
+			return result;
+		} else {
+			return new Result(false, "The current activity is not a TabActivity: " + currentActivity.getLocalClassName() );
+		}
+	}
+
+	@Override
+	public String key() {
+		return "select_tab";
+	}
+}