appium-espresso-driver 1.46.0

package/espresso-server/app/src/test/java/io/appium/espressoserver/test/helpers/IntentCreationTests.kt

@@ -0,0 +1,115 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * See the NOTICE file distributed with this work for additional
+ * information regarding copyright ownership.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.appium.espressoserver.test.helpers
+
+import android.content.Intent
+import io.appium.espressoserver.lib.helpers.makeIntent
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import java.lang.Exception
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+@RunWith(RobolectricTestRunner::class)
+class `Intent Creation Tests` {
+
+    @Test(expected = Exception::class)
+    fun `should throw if none of the required options have been provided`(){
+        makeIntent(null, mapOf())
+    }
+
+    @Test(expected = Exception::class)
+    fun `should throw if an invalid option name as been provided`(){
+        makeIntent(null, mapOf(
+                "foo" to "bar"
+        ))
+    }
+
+    @Test
+    fun `should create intent if options were set properly`(){
+        assertEquals(makeIntent(null, mapOf(
+                "action" to "io.appium.espresso"
+        )).action, "io.appium.espresso")
+
+        assertEquals(makeIntent(null, mapOf(
+                "data" to "content://contacts/people/1"
+        )).data!!.toString(), "content://contacts/people/1")
+
+        assertEquals(makeIntent(null, mapOf(
+                "type" to "image/png"
+        )).type!!.toString(), "image/png")
+
+        assertEquals(makeIntent(null, mapOf(
+                "categories" to "android.intent.category.APP_CONTACTS, android.intent.category.DEFAULT"
+        )).categories.size, 2)
+    }
+
+    @Test
+    fun `should create intent with valid intFlags`(){
+        assertEquals(makeIntent(null, mapOf(
+                "action" to "io.appium.espresso",
+                "intFlags" to "0x0F"
+        )).flags, 0x0F)
+    }
+
+    @Test
+    fun `should create intent with valid flags`(){
+        assertEquals(makeIntent(null, mapOf(
+                "action" to "io.appium.espresso",
+                "flags" to "GRANT_READ_URI_PERMISSION, FLAG_EXCLUDE_STOPPED_PACKAGES"
+        )).flags, Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_EXCLUDE_STOPPED_PACKAGES)
+    }
+
+    @Test
+    fun `should create intent with valid single extra args`(){
+        val intent = makeIntent(null, mapOf(
+                "action" to "io.appium.espresso",
+                "e" to mapOf(
+                        "bar" to "baz",
+                        "bar5" to "baz5"
+                ),
+                "es" to mapOf("bar2" to "baz2"),
+                "ei" to mapOf("int1" to 2L),
+                "ez" to mapOf("bool1" to true),
+                "el" to mapOf("long1" to 1L),
+                "ef" to mapOf("float1" to 1.1)
+        ))
+        val extras = intent.extras!!
+        assertEquals(extras.get("bar"), "baz")
+        assertEquals(extras.get("bar5"), "baz5")
+        assertEquals(extras.get("bar2"), "baz2")
+        assertEquals(extras.getInt("int1"), 2)
+        assertEquals(extras.getBoolean("bool1"), true)
+        assertEquals(extras.getLong("long1"), 1L)
+        assertTrue(extras.getFloat("float1") > 1.0)
+    }
+
+    @Test
+    fun `should create intent with valid array extra args`(){
+        val intent = makeIntent(null, mapOf<String, Any>(
+                "action" to "io.appium.espresso",
+                "eia" to mapOf("intarr" to "1,2, 3"),
+                "ela" to mapOf("longarr" to "4, 5, 6"),
+                "efa" to mapOf("floatarr" to "1.1, 2.2")
+        ))
+        val extras = intent.extras!!
+        assertTrue(extras.getIntArray("intarr")!!.size == 3)
+        assertTrue(extras.getLongArray("longarr")!!.size == 3)
+        assertTrue(extras.getFloatArray("floatarr")!!.size == 2)
+    }
+}

package/espresso-server/app/src/test/java/io/appium/espressoserver/test/helpers/InvocationOperationTest.java

@@ -0,0 +1,97 @@
+package io.appium.espressoserver.test.helpers;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.concurrent.Executor;
+
+import androidx.annotation.NonNull;
+
+import io.appium.espressoserver.lib.handlers.exceptions.AppiumException;
+import io.appium.espressoserver.lib.helpers.InvocationOperation;
+
+import static org.junit.Assert.assertEquals;
+
+public class InvocationOperationTest {
+
+    private Executor mainThreadExecutor;
+    private DummyBackdoorSubject invokeOn;
+
+    @Before
+    public void setUp() {
+        mainThreadExecutor = new Executor() {
+            @Override
+            public void execute(@NonNull Runnable runnable) {
+                runnable.run();
+            }
+        };
+        invokeOn = new DummyBackdoorSubject();
+    }
+
+    @Test
+    public void shouldReturnValidResults() throws Exception {
+        InvocationOperation operation = new InvocationOperation("validMethod",
+                new Object[]{}, new Class[0], mainThreadExecutor);
+        Object result = operation.apply(invokeOn);
+        assertEquals(DummyBackdoorSubject.RETURN_VALUE, result);
+    }
+
+    @Test
+    public void shouldReturnVoidIfReturnTypeIsVoid() throws Exception {
+        InvocationOperation operation = new InvocationOperation("voidReturn",
+                new Object[0], new Class[0], mainThreadExecutor);
+        Object result = operation.apply(invokeOn);
+        assertEquals(InvocationOperation.VOID, result);
+    }
+
+    @Test(expected = AppiumException.class)
+    public void shouldThrowExceptionIfMethodNotFound() throws Exception {
+        String nonExistent = "nonExistent";
+        InvocationOperation operation = new InvocationOperation(nonExistent,
+                new Object[0], new Class[0], mainThreadExecutor);
+        operation.apply(invokeOn);
+    }
+
+    @Test
+    public void shouldBeAbleToChainMethods() throws Exception {
+        InvocationOperation operation1 = new InvocationOperation("geObjectWithValue",
+                new Object[]{45}, new Class[]{int.class}, mainThreadExecutor);
+
+        InvocationOperation operation2 = new InvocationOperation("getTestValue",
+                new Object[0], new Class[0], mainThreadExecutor);
+
+        Object result = operation2.apply(operation1.apply(invokeOn));
+
+        assertEquals(45, result);
+    }
+
+
+    public static class DummyBackdoorSubject {
+        public static final String RETURN_VALUE = "LOL";
+
+        private int testValue;
+
+        @SuppressWarnings("unused")
+        public void voidReturn() {
+            // to test void return type
+        }
+
+        @SuppressWarnings("unused")
+        public Object validMethod() {
+            return RETURN_VALUE;
+        }
+
+
+        @SuppressWarnings("unused")
+        public Object geObjectWithValue(int testValue) {
+            this.testValue = testValue;
+            return this;
+        }
+
+        @SuppressWarnings("unused")
+        public int getTestValue() {
+            return testValue;
+        }
+
+    }
+}

package/espresso-server/app/src/test/java/io/appium/espressoserver/test/helpers/KReflectionUtilsTest.kt

@@ -0,0 +1,108 @@
+package io.appium.espressoserver.test.helpers
+
+import androidx.test.espresso.web.model.Atom
+import androidx.test.espresso.web.webdriver.DriverAtoms
+import androidx.test.espresso.web.webdriver.Locator
+import io.appium.espressoserver.lib.helpers.ReflectionUtils
+import io.appium.espressoserver.lib.helpers.ReflectionUtils.invokeStaticMethod
+import org.hamcrest.Matcher
+import org.hamcrest.Matchers
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNotNull
+import kotlin.test.assertTrue
+
+@RunWith(RobolectricTestRunner::class)
+class `KReflectionUtils Test` {
+
+    @Test
+    fun `"invokeMethod" should find methods specific to parameters provided and call it`(){
+        val obj = TestClass()
+
+        var methodResult = ReflectionUtils.invokeInstanceMethod(obj, "plus", null, 1)
+        assertTrue(methodResult is String)
+        assertEquals(methodResult, "1")
+
+        methodResult = ReflectionUtils.invokeInstanceMethod(obj, "plus", DumbEnum.A, 1)
+        assertTrue(methodResult is String)
+        assertEquals(methodResult, "A1")
+
+        methodResult = ReflectionUtils.invokeInstanceMethod(obj, "plus", 1, 2)
+        assertTrue(methodResult is Number)
+        assertEquals(methodResult, 3)
+    }
+
+    @Test
+    fun `"invokeInstanceMethod" should extract method of an object`() {
+        val methodResult = ReflectionUtils.extractMethod(TestClass::class.java, "plus", Int::class.java, Int::class.java)
+        assertNotNull(methodResult)
+    }
+
+    @Test
+    fun `"invokeInstanceMethod" should invoke method on instance of an object`() {
+        val obj = TestClass()
+        val methodResult = ReflectionUtils.invokeInstanceMethod(obj, "plus", 2, 2)
+        assertTrue(methodResult is Number)
+        assertEquals(methodResult, 4)
+    }
+
+    @Test(expected = Exception::class)
+    fun `should fail with AppiumException if wrong invocation`() {
+        val obj = TestClass()
+        invokeStaticMethod(TestClass::class.java, "plus", obj, "A", "B")
+    }
+
+    @Test
+    fun `should parse Driver Atoms "findElement"`() {
+        val findElementAtom = invokeStaticMethod(DriverAtoms::class.java,
+                "findElement", Locator.ID, "some Identifier")
+        assertTrue(findElementAtom is Atom<*>)
+    }
+
+    @Test
+    fun `should parse Hamcrest 'instanceOf' matcher with className`() {
+        arrayOf("java.lang.String")
+            .forEach {className ->
+                val hamcrestMatcher = invokeStaticMethod(Matchers::class.java,
+                        "instanceOf", Class.forName(className))
+                assertTrue(hamcrestMatcher is Matcher<*>)
+                assertTrue(hamcrestMatcher.matches("Hello World"))
+                assertFalse(hamcrestMatcher.matches(123))
+            }
+    }
+
+    @Test
+    fun `should extract declared properties from an instance`() {
+        data class TestData(val appPackage:String, val appActivity:String)
+        val sessionParams = TestData("appPackage", "appActivity")
+        val extractedProps = ReflectionUtils.extractDeclaredProperties(sessionParams)
+        assertEquals(extractedProps["appPackage"], "appPackage")
+        assertEquals(extractedProps["appActivity"], "appActivity")
+    }
+
+    class TestClass {
+        fun plus (numOne: Int, numTwo: Int):Number {
+            return numOne + numTwo
+        }
+
+        fun plus (num: Int):Number {
+            return num
+        }
+
+        fun plus (dumbEnum: DumbEnum?, num: Int): String {
+            return when (dumbEnum) {
+                DumbEnum.A -> "A$num"
+                DumbEnum.B -> "B$num"
+                DumbEnum.C -> "C$num"
+                else -> num.toString()
+            }
+        }
+    }
+
+    enum class DumbEnum {
+        A, B, C
+    }
+}

package/espresso-server/app/src/test/java/io/appium/espressoserver/test/helpers/XpathQueryParserTests.kt

@@ -0,0 +1,42 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * See the NOTICE file distributed with this work for additional
+ * information regarding copyright ownership.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.appium.espressoserver.test.helpers
+
+import io.appium.espressoserver.lib.model.ViewAttributesEnum
+import io.appium.espressoserver.lib.viewmatcher.fetchIncludedAttributes
+import org.junit.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+
+class `Xpath Query Parser Tests` {
+
+    @Test
+    fun `should parse attributes from query`() {
+        assertEquals(fetchIncludedAttributes("//*[@text=\"yolo\" and @enabled=\"true\"]"),
+        setOf(ViewAttributesEnum.TEXT, ViewAttributesEnum.ENABLED))
+    }
+
+    @Test
+    fun `should include all attributes for a wildcard`() {
+        assertNull(fetchIncludedAttributes("//*[@*=\"yolo\"]"))
+    }
+
+    @Test
+    fun `should include no attributes if the query has none`() {
+        assertEquals(fetchIncludedAttributes("//*[@foo=\"yolo\"]"), setOf())
+    }
+}

package/espresso-server/app/src/test/java/io/appium/espressoserver/test/helpers/w3c/ActionSequenceTest.kt

@@ -0,0 +1,220 @@
+package io.appium.espressoserver.test.helpers.w3c
+
+import com.google.gson.Gson
+
+import org.junit.Test
+
+import java.io.IOException
+import java.util.concurrent.ExecutionException
+
+import io.appium.espressoserver.lib.handlers.exceptions.AppiumException
+import io.appium.espressoserver.lib.handlers.exceptions.InvalidArgumentException
+import io.appium.espressoserver.lib.handlers.exceptions.NotYetImplementedException
+import io.appium.espressoserver.lib.helpers.w3c.adapter.DummyW3CActionAdapter
+import io.appium.espressoserver.lib.helpers.w3c.models.*
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource.ActionType
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource.PointerType
+import io.appium.espressoserver.lib.helpers.w3c.state.ActiveInputSources
+import io.appium.espressoserver.lib.helpers.w3c.state.InputStateTable
+import io.appium.espressoserver.lib.helpers.w3c.state.PointerInputState
+
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource.ActionType.KEY_DOWN
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource.ActionType.KEY_UP
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource.ActionType.PAUSE
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource.ActionType.POINTER_DOWN
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource.ActionType.POINTER_MOVE
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource.InputSourceType.KEY
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource.InputSourceType.POINTER
+import io.appium.espressoserver.test.assets.readAssetFile
+import org.junit.Assert.*
+
+class ActionSequenceTest {
+
+    @Test
+    @Throws(IOException::class, InvalidArgumentException::class, NotYetImplementedException::class)
+    fun shouldPullOutPointerActionsInW3CActions() {
+        val multiTouchJson = readAssetFile("multi-touch-actions.json")
+        val actions = Actions::class.java.cast(Gson().fromJson(multiTouchJson, Actions::class.java))
+        val actionSequence = ActionSequence(actions!!, ActiveInputSources(), InputStateTable())
+
+        // Tick #1 of 6
+        var tick = actionSequence.next()
+        var action = tick.next()
+        assertEquals(action.id, "finger1")
+        assertEquals(action.type, POINTER)
+        assertEquals(action.subType, POINTER_MOVE)
+        assertEquals(action.duration, 0f)
+        assertFloatEquals(action.x!!, 100f)
+        assertFloatEquals(action.y!!, 100f)
+
+        action = tick.next()
+        assertEquals(action.id, "finger2")
+        assertEquals(action.type, POINTER)
+        assertEquals(action.subType, POINTER_MOVE)
+        assertEquals(action.duration, 10f)
+        assertFloatEquals(action.x!!, 200f)
+        assertFloatEquals(action.y!!, 400f)
+
+        assertFalse(tick.hasNext())
+
+        // Tick #2 of 6
+        tick = actionSequence.next()
+        action = tick.next()
+        assertEquals(action.id, "finger1")
+        assertEquals(action.type, POINTER)
+        assertEquals(action.subType, POINTER_DOWN)
+        assertEquals(action.button.toLong(), 0)
+
+        action = tick.next()
+        assertEquals(action.id, "finger2")
+        assertEquals(action.type, POINTER)
+        assertEquals(action.subType, POINTER_DOWN)
+        assertEquals(action.button.toLong(), 0)
+
+        // Tick #3 of 6
+        tick = actionSequence.next()
+        action = tick.next()
+        assertEquals(action.id, "finger1")
+        assertEquals(action.type, POINTER)
+        assertEquals(action.subType, PAUSE)
+        assertEquals(action.button.toLong(), 0)
+
+        action = tick.next()
+        assertEquals(action.id, "finger2")
+        assertEquals(action.type, POINTER)
+        assertEquals(action.subType, PAUSE)
+        assertEquals(action.button.toLong(), 0)
+
+        assertFalse(tick.hasNext())
+
+        // Tick #4 of 6
+        tick = actionSequence.next()
+        action = tick.next()
+        assertEquals(action.id, "finger1")
+        assertEquals(action.type, POINTER)
+        assertEquals(action.subType, POINTER_MOVE)
+        assertEquals(action.duration, 1000f)
+        assertTrue(action.pointer == PointerType.TOUCH)
+        assertFloatEquals(action.x!!, 20f)
+        assertFloatEquals(action.y!!, 0f)
+
+        action = tick.next()
+        assertEquals(action.id, "finger2")
+        assertEquals(action.type, POINTER)
+        assertEquals(action.subType, POINTER_MOVE)
+        assertEquals(action.duration, 1000f)
+        assertEquals(action.origin.type, Origin.POINTER)
+        assertFloatEquals(action.x!!, 50f)
+        assertFloatEquals(action.y!!, 0f)
+
+        assertFalse(tick.hasNext())
+
+        // Tick #5 of 6
+        tick = actionSequence.next()
+        action = tick.next()
+        assertEquals(action.id, "finger1")
+        assertEquals(action.type, POINTER)
+        assertEquals(action.subType, ActionType.POINTER_UP)
+        assertEquals(action.button.toLong(), 0)
+
+        action = tick.next()
+        assertEquals(action.id, "finger2")
+        assertEquals(action.type, POINTER)
+        assertEquals(action.subType, ActionType.POINTER_UP)
+        assertEquals(action.button.toLong(), 0)
+
+        assertFalse(tick.hasNext())
+
+        // Tick #6 of 6
+        tick = actionSequence.next()
+        action = tick.next()
+        assertEquals(action.id, "finger2")
+        assertEquals(action.type, POINTER)
+        assertEquals(action.subType, PAUSE)
+        assertEquals(action.duration, 0f)
+
+        assertFalse(tick.hasNext())
+        assertFalse(actionSequence.hasNext())
+    }
+
+
+    @Test
+    @Throws(IOException::class, InvalidArgumentException::class, NotYetImplementedException::class)
+    fun shouldPullOutKeyActionsInW3CActions() {
+        val keyJson = readAssetFile("key-actions.json")
+        val actions = Actions::class.java.cast(Gson().fromJson(keyJson, Actions::class.java))
+        val actionSequence = ActionSequence(actions!!, ActiveInputSources(), InputStateTable())
+
+        var action: ActionObject
+        var tick: Tick
+
+        val unicodeChar = '\uE009'.toString()
+
+        val expectedSubTypes = arrayOf(KEY_DOWN, PAUSE, KEY_DOWN, KEY_UP, KEY_UP)
+        val expectedValue = arrayOf(unicodeChar, null, "s", unicodeChar, "s")
+
+
+        for (i in expectedSubTypes.indices) {
+            tick = actionSequence.next()
+            action = tick.next()
+            assertEquals(action.type, KEY)
+            assertEquals(action.subType, expectedSubTypes[i])
+            assertEquals(action.value, expectedValue[i])
+            assertEquals(action.id, "keyboard")
+            assertFalse(tick.hasNext())
+        }
+
+        assertFalse(actionSequence.hasNext())
+    }
+
+    @Test
+    @Throws(IOException::class, AppiumException::class, InterruptedException::class, ExecutionException::class)
+    fun shouldDispatchW3CPointerActions() {
+        class AlteredDummyAdapter : DummyW3CActionAdapter() {
+            override// Bump up viewport width so we don't get out of bounds issues
+            val viewportWidth: Long
+                get() = 251
+
+            override val viewportHeight: Long
+                get() = 401
+        }
+
+        val inputStateTable = InputStateTable()
+        val multiTouchJson = readAssetFile("multi-touch-actions.json")
+        val actions = Actions::class.java.cast(Gson().fromJson(multiTouchJson, Actions::class.java))
+        val actionSequence = ActionSequence(actions!!, ActiveInputSources(), InputStateTable())
+
+        val timeBefore = System.currentTimeMillis()
+        actionSequence.dispatch(AlteredDummyAdapter(), inputStateTable)
+        val elapsedTime = System.currentTimeMillis() - timeBefore
+
+        // Must be greater than 2s because that's the total duration
+        assertTrue(elapsedTime >= 2000)
+
+        // Check that it's under 2.5s though to verify that it's not TOO long
+        assertTrue(elapsedTime < 2500)
+
+        val finger1State = inputStateTable.getInputState("finger1") as PointerInputState
+        val finger2State = inputStateTable.getInputState("finger2") as PointerInputState
+
+        assertFloatEquals(finger1State.x, 120f)
+        assertFloatEquals(finger1State.y, 100f)
+        assertFloatEquals(finger2State.x, 250f)
+        assertFloatEquals(finger2State.y, 400f)
+    }
+
+    @Test
+    @Throws(IOException::class, AppiumException::class, InterruptedException::class, ExecutionException::class)
+    fun shouldDispatchW3CKeyActions() {
+        val inputStateTable = InputStateTable()
+        val multiTouchJson = readAssetFile("key-actions.json")
+        val actions = Actions::class.java.cast(Gson().fromJson(multiTouchJson, Actions::class.java))
+        val actionSequence = ActionSequence(actions!!, ActiveInputSources(), InputStateTable())
+
+        val timeBefore = System.currentTimeMillis()
+        actionSequence.dispatch(DummyW3CActionAdapter(), inputStateTable)
+        val elapsedTime = System.currentTimeMillis() - timeBefore
+        assertTrue(elapsedTime >= 500)
+        assertTrue(elapsedTime <= 600)
+    }
+}

package/espresso-server/app/src/test/java/io/appium/espressoserver/test/helpers/w3c/ActionsTest.kt

@@ -0,0 +1,76 @@
+package io.appium.espressoserver.test.helpers.w3c
+
+import com.google.gson.Gson
+import io.appium.espressoserver.lib.handlers.exceptions.AppiumException
+import io.appium.espressoserver.lib.helpers.w3c.adapter.DummyW3CActionAdapter
+import io.appium.espressoserver.lib.helpers.w3c.models.Actions
+import io.appium.espressoserver.lib.helpers.w3c.state.InputStateTable
+import io.appium.espressoserver.lib.helpers.w3c.state.KeyInputState
+import io.appium.espressoserver.lib.helpers.w3c.state.PointerInputState
+import io.appium.espressoserver.test.assets.readAssetFile
+import junit.framework.TestCase
+import org.junit.Assert
+import org.junit.Test
+import java.io.IOException
+
+class ActionsTest {
+    internal class AlteredDummyAdapter : DummyW3CActionAdapter() {
+        // Bump up viewport width so we don't get out of bounds issues
+        override val viewportWidth: Long
+            get() =// Bump up viewport width so we don't get out of bounds issues
+                300
+
+        // Bump up viewport width so we don't get out of bounds issues
+        override val viewportHeight: Long
+            get() =// Bump up viewport width so we don't get out of bounds issues
+                500
+    }
+
+    @Test
+    @Throws(IOException::class)
+    fun shouldThrowIfAdapterNotSet() {
+        val multiTouchJson = readAssetFile("multi-touch-actions.json")
+        val actions = Gson().fromJson(multiTouchJson, Actions::class.java)
+        try {
+            actions.perform("123")
+        } catch (e: AppiumException) {
+            TestCase.assertTrue(e.message!!.contains("Failed to initialize /actions adapter"))
+        }
+    }
+
+    @Test
+    @Throws(IOException::class, AppiumException::class)
+    fun shouldPerformPointerActionsOnASetOfInputSources() {
+        val multiTouchJson = readAssetFile("multi-touch-actions.json")
+        val actions = Gson().fromJson(multiTouchJson, Actions::class.java)
+        actions.adapter = AlteredDummyAdapter()
+        val sessionId = "123"
+        actions.perform(sessionId)
+        val inputStateTable = InputStateTable.getInputStateTableOfSession(sessionId)
+        val finger1 = inputStateTable.getInputState("finger1") as PointerInputState
+        val finger2 = inputStateTable.getInputState("finger2") as PointerInputState
+
+        // Check the state
+        assertFloatEquals(finger1.x, 120f)
+        assertFloatEquals(finger1.y, 100f)
+        assertFloatEquals(finger2.x, 250f)
+        assertFloatEquals(finger2.y, 400f)
+
+        // Sanity check that it's recording pointer move events
+        val pointerMoveEvents = (actions.adapter as DummyW3CActionAdapter?)!!.getPointerMoveEvents()
+        TestCase.assertTrue(pointerMoveEvents.isNotEmpty())
+    }
+
+    @Test
+    @Throws(IOException::class, AppiumException::class)
+    fun shouldPerformKeyActionsOnASetOfInputSources() {
+        val keyJson = readAssetFile("key-actions.json")
+        val actions = Gson().fromJson(keyJson, Actions::class.java)
+        actions.adapter = AlteredDummyAdapter()
+        val sessionId = "123"
+        actions.perform(sessionId)
+        val inputStateTable = InputStateTable.getInputStateTableOfSession(sessionId)
+        val keyboard = inputStateTable.getInputState("keyboard") as KeyInputState
+        Assert.assertFalse(keyboard.isPressed("\\uE009"))
+    }
+}