calabash-android 0.0.1

data/test-server/calabash-js/src/set_text.js

@@ -0,0 +1,132 @@
+(function () {
+	function simulateKeyEvent(elem, character) {
+	    var ch = character.charCodeAt(0);
+	            
+	    var evt;
+	    evt = document.createEvent('KeyboardEvent');
+	    evt.initKeyboardEvent('keydown', true, true, window, 0, 0, 0, 0, 0, ch);
+	    elem.dispatchEvent(evt);
+	   
+	    evt = document.createEvent('KeyboardEvent');
+	    evt.initKeyboardEvent('keyup', true, true, window, 0, 0, 0, 0, 0, ch);
+	    elem.dispatchEvent(evt);
+	    evt = document.createEvent('KeyboardEvent');
+	    evt.initKeyboardEvent('keypress', true, true, window, 0, 0, 0, 0, 0, ch);
+	    elem.dispatchEvent(evt);
+	}
+
+	 
+	function enterTextIntoInputField(elem, text) {
+	    for (var i = 0; i < text.length; i++) {
+	        var ch = text.charAt(i);
+	        elem.value += ch;
+	        simulateKeyEvent(elem, ch);
+	    }
+	}
+	                            
+
+	function fireHTMLEvent(elem, eventName) {
+	    var evt = document.createEvent("HTMLEvents");
+	    evt.initEvent(eventName, true, true );
+	    return !elem.dispatchEvent(evt);
+	}
+
+	function selectInputField(elem) {
+	    elem.click();
+	    elem.focus();
+	}
+
+
+	function deselectInputField(elem) {
+	    fireHTMLEvent(elem, 'change');
+	    fireHTMLEvent(elem, 'blur');
+	}
+	
+	
+    /** David Mark's isHostMethod function,
+      * http://peter.michaux.ca/articles/feature-detection-state-of-the-art-browser-scripting
+      * Modified to use strict equality
+      */
+    function isHostMethod (object, property)
+    {
+      var t = typeof object[property];
+      return t==='function' ||
+             (!!(t==='object' && object[property])) ||
+             t==='unknown';
+    }
+    //http://www.w3.org/TR/DOM-Level-2-Core/core.html
+    var NODE_TYPES = {
+        /*ELEMENT_NODE                   : */ 1 : 'ELEMENT_NODE',
+        /*ATTRIBUTE_NODE                 : */ 2: 'ATTRIBUTE_NODE',
+        /*TEXT_NODE                      : */ 3 : 'TEXT_NODE',
+        /*DOCUMENT_NODE                  : */ 9 : 'DOCUMENT_NODE'
+    };
+
+    function toJSON(object)
+    {
+        var res, i, N;
+        if (typeof object==='undefined')
+        {
+            throw {message:'Calling toJSON with undefined'};
+        }
+        else if (object instanceof Node)//TODO: support for frames!
+        {
+            res = {}
+            if (isHostMethod(object,'getBoundingClientRect'))
+            {
+                res['rect'] = object.getBoundingClientRect();
+            }
+            res.nodeType = NODE_TYPES[object.nodeType] || res.nodeType + ' (Unexpected)';
+            res.nodeName = object.nodeName;
+            res.id = object.id || '';
+            res['class'] = object.className || '';
+            res.html = object.outerHTML || '';
+            res.nodeValue = object.nodeValue;
+        }
+        else if (object instanceof NodeList || //TODO: support for frames!
+                 (typeof object=='object' && object &&
+                  typeof object.length === 'number' &&
+                  object.length > 0 //array like
+                  && typeof object[0] !== 'undefined'))
+        {
+            res = [];
+            for (i=0,N=object.length;i<N;i++)
+            {
+                res[i] = toJSON(object[i]);
+            }
+        }
+        else
+        {
+            res = object;
+        }
+        return res;
+    }
+    
+    ///TODO: no support for now frames
+    //idea would be map XPath across window.frames
+    //must take care of visibility questions
+
+    try
+    {   
+    	var exp = JSON.parse('%@')/* dynamic */,
+        	el,
+        	text = '%@',
+        	i,N;
+ 
+        el=document.elementFromPoint(exp.rect.left, exp.rect.top);
+        if (/input/i.test(el.tagName))
+        {
+        	selectInputField(el);
+        	enterTextIntoInputField(el, text);
+        }
+        else
+        {
+
+        }
+    }
+    catch (e)
+    {
+       return JSON.stringify({error:'Exception while running query: '+exp, details:e.toString()})
+    }
+    return JSON.stringify(toJSON(el));
+})();

data/test-server/instrumentation-backend/.classpath

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="src" path="gen"/>
+	<classpathentry kind="src" path="assets"/>
+	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
+	<classpathentry kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
+	<classpathentry kind="lib" path="libs/robotium-solo-2.5.jar"/>
+	<classpathentry kind="output" path="bin/classes"/>
+</classpath>

data/test-server/instrumentation-backend/.project

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>instrumentation_backend</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

data/test-server/instrumentation-backend/.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,12 @@
+#Mon Mar 19 14:45:07 BRT 2012
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.6

data/test-server/instrumentation-backend/AndroidManifest.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+      package="com.lesspainful.simpleui.test"
+      android:versionCode="1"
+      android:versionName="1.0">
+    <application android:label="lesspainfultest">
+
+    <uses-library android:name="android.test.runner" />
+    </application>
+    
+    <instrumentation android:targetPackage="com.lesspainful.simpleui" android:name="android.test.InstrumentationTestRunner" />
+   <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+   <uses-permission android:name="android.permission.INTERNET" />
+   
+</manifest> 

data/test-server/instrumentation-backend/gen/com/lesspainful/simpleui/test/R.java

@@ -0,0 +1,23 @@
+/* AUTO-GENERATED FILE.  DO NOT MODIFY.
+ *
+ * This class was automatically generated by the
+ * aapt tool from the resource data it found.  It
+ * should not be modified by hand.
+ */
+
+package com.lesspainful.simpleui.test;
+
+public final class R {
+    public static final class attr {
+    }
+    public static final class drawable {
+        public static final int ic_launcher=0x7f020000;
+    }
+    public static final class layout {
+        public static final int main=0x7f030000;
+    }
+    public static final class string {
+        public static final int app_name=0x7f040001;
+        public static final int hello=0x7f040000;
+    }
+}

data/test-server/instrumentation-backend/project.properties

@@ -0,0 +1,11 @@
+# This file is automatically generated by Android Tools.
+# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
+#
+# This file must be checked in Version Control Systems.
+#
+# To customize properties used by the Ant build system use,
+# "ant.properties", and override values to adapt the script to your
+# project structure.
+
+# Project target.
+target=android-15

data/test-server/instrumentation-backend/res/layout/main.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent"
+    android:orientation="vertical" >
+
+    <TextView
+        android:layout_width="fill_parent"
+        android:layout_height="wrap_content"
+        android:text="@string/hello" />
+
+</LinearLayout>

data/test-server/instrumentation-backend/res/values/strings.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+
+    <string name="hello">Hello World!</string>
+    <string name="app_name">Android-cucumber-instrumentationbackendTest</string>
+
+</resources>

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

@@ -0,0 +1,48 @@
+package sh.calaba.instrumentationbackend;
+
+import java.util.Arrays;
+
+import sh.calaba.instrumentationbackend.actions.Action;
+
+
+
+
+public class Command {
+    private String line;
+    private String command;
+    private String[] arguments;
+    
+    public void setCommand(String command) {
+    	this.command =  command;
+    }
+    
+    public void setArguments(String[] arguments) {
+    	this.arguments = arguments;
+    }
+    
+    public String getCommand() {
+    	return command;
+    }
+    
+    public String[] getArguments() {
+    	return arguments;
+    }
+    
+    public void setLine(String line) {
+		this.line = line;
+	}
+
+	public String getLine() {
+		return line;
+	}
+
+	public String toString() {
+		return "Command:'Line:" + getLine() + "," + getCommand() + "', arguments:'" + Arrays.toString(getArguments()) + "'";
+	}
+
+    public Result execute() {
+        Action action = InstrumentationBackend.actions.lookup(getCommand());
+        return action.execute(getArguments());
+    }
+
+}

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

@@ -0,0 +1,196 @@
+package sh.calaba.instrumentationbackend;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.SocketException;
+
+
+import sh.calaba.instrumentationbackend.actions.Actions;
+import sh.calaba.org.codehaus.jackson.JsonGenerationException;
+import sh.calaba.org.codehaus.jackson.map.JsonMappingException;
+import sh.calaba.org.codehaus.jackson.map.ObjectMapper;
+import sh.calaba.org.codehaus.jackson.map.DeserializationConfig.Feature;
+import android.app.Instrumentation;
+import android.test.ActivityInstrumentationTestCase2;
+import android.util.Log;
+
+import com.jayway.android.robotium.solo.Solo;
+
+public class InstrumentationBackend extends ActivityInstrumentationTestCase2 {
+    public static final String TARGET_PACKAGE = "#ACTIVITY_PACKAGE#"; //Set from Ant at compile time
+    private static final String LAUNCHER_ACTIVITY_FULL_CLASSNAME = "#ACTIVITY_QUALIFIED_NAME#"; //Set from Ant at compile time
+    
+    private static final String TAG = "IntrumentationBackend";
+    
+    private ServerSocket myService;
+    private Socket serviceSocket = null;
+    private PrintStream resultStream;
+    private BufferedReader commandStream;
+    
+    private ObjectMapper mapper;
+    public static Instrumentation instrumentation;
+    public static Solo solo;
+    public static Actions actions;
+    
+    private static Class getActivityClass() {
+    	try {
+			return Class.forName(LAUNCHER_ACTIVITY_FULL_CLASSNAME);
+		} catch (ClassNotFoundException e) {
+			throw new RuntimeException(e);
+		}
+    }
+    
+    public InstrumentationBackend() {
+        super(TARGET_PACKAGE, getActivityClass());
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        
+        mapper = createJsonMapper();
+        createSockets();
+        solo = new Solo(getInstrumentation(), this.getActivity());
+        actions = new Actions(getInstrumentation(), this);
+        instrumentation = getInstrumentation();
+        TestHelpers.loadIds(instrumentation.getContext());
+    }
+
+
+    /**
+     * Here to have JUnit3 start the instrumentationBackend
+     */
+    public void testHook() throws Exception {
+        startInstrumentationBackend();
+        
+    }
+
+    @Override
+    public void tearDown() throws Exception {
+        System.out.println("Finishing");
+        try {
+            solo.finalize();
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+
+        this.getActivity().finish();
+        super.tearDown();
+
+    }
+
+    // TODO: create tearDown method. Should close sockets and streams
+    // TODO: create setupUp method. create sockets, streams and jsonMapper,
+    // build Action set.
+    // TODO: Clean up waitForCucumberConnect
+    // TODO: load actions
+
+    public void startInstrumentationBackend() throws Exception {
+        
+        acceptConnectionFromCucumber();
+
+        // listen for commands
+        String commandString;
+        while ((commandString = commandStream.readLine()) != null) {
+            returnResult(runCommand(commandString));
+        }
+
+        // TODO: Move to teardown
+        log("Cucumber disconnected");
+        try {
+            commandStream.close();
+            resultStream.close();
+            serviceSocket.close();
+            myService.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void returnResult(Result result) throws JsonGenerationException, JsonMappingException, IOException {
+        log("Result:" + result);
+        resultStream.println(mapper.writeValueAsString(result));
+        resultStream.flush();
+    }
+
+    private Result runCommand(String commandString) {
+        try {
+            System.out.println("CommandString:" + commandString);
+            Command command = mapper.readValue(commandString, Command.class);
+            log("Got command:'" + command);
+            return command.execute();
+//           String result = mapper.writeValueAsString(actions.lookup(command.getCommand()).execute(command.getArguments()));
+        } catch (Throwable t) { // Robotium throws AssertionErrors on occations,
+                                // we need to catch these and map them to json
+                                // results
+            // TODO: Create result from Throwable
+             t.printStackTrace();
+            // String jsonResult =
+            // mapper.writeValueAsString(Result.fromThrowable(t));
+            // logError("Returning error:" + jsonResult);
+            // output.println(jsonResult);
+            // output.flush();
+            return Result.fromThrowable(t);
+        }
+    }
+
+    private void createResultStream() throws IOException {
+        resultStream = new PrintStream(serviceSocket.getOutputStream());
+    }
+
+    private void createCommandStream() throws UnsupportedEncodingException, IOException {
+        commandStream = new BufferedReader(new InputStreamReader(serviceSocket.getInputStream(), "UTF8"));
+    }
+
+    private ObjectMapper createJsonMapper() {
+        ObjectMapper mapper = new ObjectMapper();
+        mapper.configure(Feature.FAIL_ON_UNKNOWN_PROPERTIES, true);
+        return mapper;
+    }
+
+    private void acceptConnectionFromCucumber() throws Exception {
+        log("Waiting for connection from Cucumber");
+
+        try {
+            serviceSocket = myService.accept();
+        } catch (Exception e) {
+            log("Timeout waiting for connection");
+            e.printStackTrace();
+            throw new RuntimeException(e);
+        }
+
+        createCommandStream();
+        createResultStream();
+
+        String s;
+        while ((s = commandStream.readLine()) != null) {
+            if (s.equals("Ping!")) { // Cucumber connected
+                resultStream.println("Pong!"); // Reply with acknowledgement
+                resultStream.flush();
+                break;
+            }
+        }
+    }
+    
+    private void createSockets() throws IOException {
+    	try {
+    	    myService = new ServerSocket(7101);
+    	    myService.setSoTimeout(120000);
+    	} catch (SocketException e) {
+    	    throw new RuntimeException("Could not create socket. Did you set the android.permission.INTERNET permission in your AndroidManifest.xml", e);
+    	}
+    }
+    
+    public static void log(String message) {
+        Log.i(TAG, message);
+    }
+
+    public static void logError(String message) {
+        Log.e(TAG, message);
+    }
+}