appium-espresso-driver 1.46.0

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

@@ -0,0 +1,265 @@
+package io.appium.espressoserver.test.helpers.w3c
+
+import org.junit.Test
+import java.util.concurrent.ExecutionException
+import java.util.concurrent.ExecutorCompletionService
+import java.util.concurrent.Executors
+
+import io.appium.espressoserver.lib.handlers.exceptions.AppiumException
+import io.appium.espressoserver.lib.handlers.exceptions.InvalidArgumentException
+import io.appium.espressoserver.lib.helpers.w3c.adapter.DummyW3CActionAdapter
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.BaseDispatchResult
+import io.appium.espressoserver.lib.helpers.w3c.models.ActionObject
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource.PointerType
+import io.appium.espressoserver.lib.helpers.w3c.models.Origin
+import io.appium.espressoserver.lib.helpers.w3c.models.Tick
+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.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.NONE
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource.InputSourceType.POINTER
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource.PointerType.TOUCH
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
+
+class TickTest {
+
+    @Test
+    fun `should calculate max duration as zero if no durations`() {
+        val tick = Tick()
+        tick.addAction(ActionObject())
+        assertFloatEquals(tick.calculateTickDuration(), 0f)
+    }
+
+    @Test
+    fun `should calculate the max duration`() {
+
+        val valueOne = arrayOf(10F, 30F, 0F)
+        val valueTwo = arrayOf(20F, 10F, 1F)
+        val expectedMax = arrayOf(20F, 30F, 1F)
+
+        for (i in valueOne.indices) {
+            val tick = Tick()
+            val actionObjectOne = ActionObject()
+            actionObjectOne.type = NONE
+            actionObjectOne.subType = PAUSE
+            actionObjectOne.duration = valueOne[i]
+
+            val actionObjectTwo = ActionObject()
+            actionObjectTwo.type = POINTER
+            actionObjectTwo.subType = POINTER_MOVE
+            actionObjectTwo.duration = valueTwo[i]
+
+            val actionObjectThree = ActionObject()
+            actionObjectTwo.type = POINTER
+            actionObjectTwo.subType = POINTER_MOVE
+
+            tick.addAction(actionObjectOne)
+            tick.addAction(actionObjectTwo)
+            tick.addAction(actionObjectThree)
+
+            assertFloatEquals(tick.calculateTickDuration(), expectedMax[i])
+        }
+    }
+
+    @Test
+    @Throws(AppiumException::class)
+    fun `should add key to key input state when running key actions`() {
+        val inputStateTable = InputStateTable()
+        val tick = Tick()
+        val sourceId = "something1"
+        val actionObject = ActionObject(sourceId, KEY, null, 0)
+        actionObject.subType = KEY_DOWN
+        actionObject.value = "F"
+        tick.addAction(actionObject)
+        assertFalse(inputStateTable.hasInputState(sourceId))
+        tick.dispatchAll(DummyW3CActionAdapter(), inputStateTable, tick.calculateTickDuration())
+        assertTrue(inputStateTable.getInputState(sourceId) is KeyInputState)
+    }
+
+    @Test
+    @Throws(AppiumException::class)
+    fun `should add pointer input state when running pointer actions`() {
+        val inputStateTable = InputStateTable()
+        val tick = Tick()
+        val sourceId = "something2"
+        val actionObject = ActionObject(sourceId, POINTER, null, 0)
+        actionObject.subType = POINTER_DOWN
+        actionObject.button = 0
+        tick.addAction(actionObject)
+        assertFalse(inputStateTable.hasInputState(sourceId))
+        tick.dispatchAll(DummyW3CActionAdapter(), inputStateTable, tick.calculateTickDuration())
+        assertTrue(inputStateTable.getInputState(sourceId) is PointerInputState)
+    }
+
+    @Test
+    @Throws(AppiumException::class)
+    fun `should not affect input state when NONE event is dispatched`() {
+        val inputStateTable = InputStateTable()
+        val tick = Tick()
+        val sourceId = "something3"
+        val actionObject = ActionObject(sourceId, NONE, null, 0)
+        tick.addAction(actionObject)
+        assertFalse(inputStateTable.hasInputState(sourceId))
+        tick.dispatchAll(DummyW3CActionAdapter(), inputStateTable, tick.calculateTickDuration())
+        assertFalse(inputStateTable.hasInputState(sourceId))
+    }
+
+    @Test
+    @Throws(AppiumException::class)
+    fun `should dispatch a sequence of key events`() {
+        val inputStateTable = InputStateTable()
+        val tick = Tick()
+        val sourceId = "something4"
+        var keyInputState = KeyInputState()
+        keyInputState.addPressed("g")
+        inputStateTable.addInputState(sourceId, keyInputState)
+        val actionObjectOne = ActionObject(sourceId, KEY, null, 0)
+        actionObjectOne.subType = KEY_DOWN
+        actionObjectOne.value = "e"
+
+        val actionObjectTwo = ActionObject(sourceId, KEY, null, 0)
+        actionObjectTwo.subType = KEY_DOWN
+        actionObjectTwo.value = "f"
+
+        val actionObjectThree = ActionObject(sourceId, KEY, null, 0)
+        actionObjectThree.subType = KEY_UP
+        actionObjectThree.value = "g"
+
+        val actionObjectFour = ActionObject(sourceId, KEY, null, 0)
+        actionObjectFour.subType = KEY_DOWN
+        actionObjectFour.value = "\uE008"
+
+        tick.addAction(actionObjectOne)
+        tick.addAction(actionObjectTwo)
+        tick.addAction(actionObjectThree)
+        tick.addAction(actionObjectFour)
+
+        keyInputState = inputStateTable.getInputState(sourceId) as KeyInputState
+        assertFalse(keyInputState.isPressed("e"))
+        assertFalse(keyInputState.isPressed("f"))
+        assertTrue(keyInputState.isPressed("g"))
+        assertFalse(keyInputState.isShift)
+
+        tick.dispatchAll(DummyW3CActionAdapter(), inputStateTable, tick.calculateTickDuration())
+        assertTrue(keyInputState.isPressed("e"))
+        assertTrue(keyInputState.isPressed("f"))
+        assertFalse(keyInputState.isPressed("g"))
+        assertTrue(keyInputState.isShift)
+    }
+
+    @Test
+    @Throws(AppiumException::class, InterruptedException::class, ExecutionException::class)
+    fun `should dispatch a series of pointer move events`() {
+        val inputStateTable = InputStateTable()
+        val keyInputState = KeyInputState()
+        keyInputState.isShift = true
+        inputStateTable.addInputState("keyInputs", keyInputState)
+        val tick = Tick()
+
+        val sourceId = "something4"
+        val sourceId2 = "something5"
+        val pointerInputState = PointerInputState(TOUCH)
+        pointerInputState.type = TOUCH
+        pointerInputState.x = 5f
+        pointerInputState.y = 6f
+        pointerInputState.addPressed(0)
+        pointerInputState.addPressed(1)
+        inputStateTable.addInputState(sourceId, pointerInputState)
+        inputStateTable.addInputState(sourceId2, pointerInputState)
+
+        // Construct pointer move event
+        val actionObjectOne = ActionObject(sourceId, POINTER, null, 0)
+        actionObjectOne.subType = POINTER_MOVE
+        actionObjectOne.pointer = TOUCH
+        actionObjectOne.x = 10.0f
+        actionObjectOne.y = 20.0f
+        actionObjectOne.origin = Origin(Origin.VIEWPORT)
+
+        // Construct another pointer move event
+        val actionObjectTwo = ActionObject(sourceId2, POINTER, null, 0)
+        actionObjectTwo.subType = POINTER_MOVE
+        actionObjectTwo.pointer = TOUCH
+        actionObjectTwo.x = 10.0f
+        actionObjectTwo.y = 20.0f
+        actionObjectTwo.origin = Origin(Origin.VIEWPORT)
+
+        // Add two pointer move actions to verify that they can run on multiple threads separately
+        tick.addAction(actionObjectOne)
+        tick.addAction(actionObjectTwo)
+
+        class ExtendedDummyW3CActionAdapter : DummyW3CActionAdapter() {
+            @Suppress("UNUSED_PARAMETER", "unused")
+            fun pointerMove(sourceId: String,
+                            pointerType: PointerType,
+                            currentX: Float?, currentY: Float?,
+                            x: Float?, y: Float?,
+                            buttons: Set<Int>,
+                            globalKeyInputState: KeyInputState) {
+                assertEquals(pointerType, TOUCH)
+                assertFloatEquals(currentX!!, 5f)
+                assertFloatEquals(currentY!!, 6f)
+                assertFloatEquals(x!!, 10f)
+                assertFloatEquals(y!!, 20f)
+                assertTrue(buttons.contains(0))
+                assertTrue(buttons.contains(1))
+                assertTrue(globalKeyInputState.isShift)
+            }
+        }
+
+        val dummyAdapter = ExtendedDummyW3CActionAdapter()
+
+        val callables = tick.dispatchAll(dummyAdapter, inputStateTable, tick.calculateTickDuration())
+        val executor = Executors.newFixedThreadPool(callables.size)
+        val completionService = ExecutorCompletionService<BaseDispatchResult>(executor)
+        for (callable in callables) {
+            completionService.submit(callable)
+        }
+
+        var received = 0
+        while (received < callables.size) {
+            val resultFuture = completionService.take() //blocks if none available
+            resultFuture.get()
+            received++
+        }
+    }
+
+    @Test
+    @Throws(AppiumException::class)
+    fun `should throw invalid cast if using same source ID but different type`() {
+        val inputStateTable = InputStateTable()
+        val tick = Tick()
+        val sourceId = "something4"
+        val pointerInputState = PointerInputState(TOUCH)
+        inputStateTable.addInputState(sourceId, pointerInputState)
+
+        // Depress the shift key
+        val actionObjectTwo = ActionObject(sourceId, KEY, null, 0)
+        actionObjectTwo.subType = KEY_DOWN
+
+        // Construct pointer move event
+        val actionObjectOne = ActionObject(sourceId, POINTER, null, 0)
+        actionObjectOne.subType = POINTER_DOWN
+
+        tick.addAction(actionObjectOne)
+        tick.addAction(actionObjectTwo)
+
+        try {
+            tick.dispatchAll(DummyW3CActionAdapter(), inputStateTable, tick.calculateTickDuration())
+        } catch (e: InvalidArgumentException) {
+            assertTrue(e.message!!.contains("Attempted to apply action of type"))
+            return
+        }
+
+        fail("Should have called 'InvalidArgumentException'")
+    }
+}

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

@@ -0,0 +1,114 @@
+package io.appium.espressoserver.test.helpers.w3c.adapter
+
+import android.os.SystemClock
+import android.view.KeyEvent
+import android.view.MotionEvent
+import androidx.test.espresso.UiController
+import io.appium.espressoserver.lib.handlers.exceptions.AppiumException
+import io.appium.espressoserver.lib.helpers.w3c.adapter.espresso.AndroidKeyEvent
+import io.appium.espressoserver.lib.helpers.w3c.adapter.espresso.EspressoW3CActionAdapter
+import io.appium.espressoserver.lib.helpers.w3c.adapter.espresso.keyCodeToEvent
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.W3CKeyEvent
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys.BACKSPACE
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.getKeyEvent
+import org.junit.Assert
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import java.util.*
+
+@RunWith(RobolectricTestRunner::class)
+class AndroidKeyEventTest {
+    class MockUiController : UiController {
+        var keyEvents: MutableList<KeyEvent> = LinkedList()
+        override fun injectMotionEvent(event: MotionEvent): Boolean {
+            return false
+        }
+
+        override fun injectMotionEventSequence(events: Iterable<MotionEvent>): Boolean {
+            return false
+        }
+
+        override fun injectKeyEvent(event: KeyEvent): Boolean {
+            keyEvents.add(event)
+            return true
+        }
+
+        override fun injectString(str: String): Boolean {
+            return false
+        }
+
+        override fun loopMainThreadUntilIdle() {
+            SystemClock.sleep(100)
+        }
+
+        override fun loopMainThreadForAtLeast(millisDelay: Long) {
+            SystemClock.sleep(millisDelay)
+        }
+    }
+
+    @Test
+    @Throws(AppiumException::class)
+    fun keyUpNoop() {
+        // Dispatch an up event that has no corresponding down event and check that the state was unchanged
+        val w3CKeyEvent = W3CKeyEvent()
+        w3CKeyEvent.key = "A"
+        val mockUiController = MockUiController()
+        Assert.assertEquals(mockUiController.keyEvents.size.toLong(), 0)
+        AndroidKeyEvent(mockUiController).keyUp(w3CKeyEvent)
+        Assert.assertEquals(mockUiController.keyEvents.size.toLong(), 0)
+    }
+
+    @Test
+    @Throws(AppiumException::class)
+    fun keyDown() {
+        val mockUiController = MockUiController()
+
+        // Dispatch a key event
+        val w3CKeyEvent = getKeyEvent(EspressoW3CActionAdapter(mockUiController), "B")
+        w3CKeyEvent.isAltKey = true
+        w3CKeyEvent.isShiftKey = true
+        w3CKeyEvent.isCtrlKey = false
+        AndroidKeyEvent(mockUiController).keyDown(w3CKeyEvent)
+
+        // Check that one was dispatched
+        Assert.assertEquals(mockUiController.keyEvents.size.toLong(), 1)
+
+        // Check the right key event was dispatched
+        val keyEvent = mockUiController.keyEvents[mockUiController.keyEvents.size - 1]
+        keyEvent.keyCode
+        Assert.assertEquals(keyEvent.keyCode.toLong(), KeyEvent.KEYCODE_B.toLong())
+        Assert.assertEquals(keyEvent.action.toLong(), KeyEvent.ACTION_DOWN.toLong())
+        Assert.assertEquals(keyEvent.metaState, KeyEvent.META_SHIFT_MASK or KeyEvent.META_ALT_MASK)
+    }
+
+    @Test
+    @Throws(AppiumException::class)
+    fun keyDownAndUp() {
+        val mockUiController = MockUiController()
+        val androidKeyEvent = AndroidKeyEvent(mockUiController)
+
+        // Key Down C
+        val w3CKeyEvent = getKeyEvent(EspressoW3CActionAdapter(mockUiController), "C")
+        androidKeyEvent.keyDown(w3CKeyEvent)
+
+        // Check that KEYCODE_C went down
+        var keyEvent = mockUiController.keyEvents[mockUiController.keyEvents.size - 1]
+        keyEvent.keyCode
+        Assert.assertEquals(keyEvent.keyCode.toLong(), KeyEvent.KEYCODE_C.toLong())
+        Assert.assertEquals(keyEvent.action.toLong(), KeyEvent.ACTION_DOWN.toLong())
+
+        // Release Key Code C and check that there's no keys down
+        androidKeyEvent.keyUp(w3CKeyEvent)
+        keyEvent = mockUiController.keyEvents[mockUiController.keyEvents.size - 1]
+        keyEvent.keyCode
+        Assert.assertEquals(keyEvent.keyCode.toLong(), KeyEvent.KEYCODE_C.toLong())
+        Assert.assertEquals(keyEvent.action.toLong(), KeyEvent.ACTION_UP.toLong())
+    }
+
+    @Test
+    fun keyCode() {
+        Assert.assertEquals(keyCodeToEvent(BACKSPACE, 0).toLong(), KeyEvent.KEYCODE_DEL.toLong())
+        Assert.assertEquals(keyCodeToEvent("A", 0).toLong(), -1)
+    }
+}

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

@@ -0,0 +1,31 @@
+package io.appium.espressoserver.test.helpers.w3c.adapter
+
+import android.graphics.Point
+import android.view.MotionEvent
+import io.appium.espressoserver.lib.helpers.w3c.adapter.espresso.getToolType
+import io.appium.espressoserver.lib.helpers.w3c.adapter.espresso.toCoordinates
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource
+import org.junit.Assert
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class HelpersTest {
+    @Test
+    fun toolTypeDefaultIsFinger() {
+        Assert.assertEquals(getToolType(null).toLong(), MotionEvent.TOOL_TYPE_FINGER.toLong())
+    }
+
+    @Test
+    fun toolTypeTest() {
+        Assert.assertEquals(getToolType(InputSource.PointerType.MOUSE).toLong(), MotionEvent.TOOL_TYPE_MOUSE.toLong())
+        Assert.assertEquals(getToolType(InputSource.PointerType.PEN).toLong(), MotionEvent.TOOL_TYPE_STYLUS.toLong())
+        Assert.assertEquals(getToolType(InputSource.PointerType.TOUCH).toLong(), MotionEvent.TOOL_TYPE_FINGER.toLong())
+    }
+
+    @Test
+    fun toCoordinatesTest() {
+        Assert.assertEquals(toCoordinates(123.0f, 456.0f), Point(123, 456))
+    }
+}

package/espresso-server/app/src/test/java/io/appium/espressoserver/test/http/RouteDefinitionTest.kt

@@ -0,0 +1,74 @@
+package io.appium.espressoserver.test.http
+
+import fi.iki.elonen.NanoHTTPD
+import io.appium.espressoserver.lib.handlers.RequestHandler
+import io.appium.espressoserver.lib.http.RouteDefinition
+import io.appium.espressoserver.lib.model.AppiumParams
+import org.junit.Assert
+import org.junit.Before
+import org.junit.Test
+
+class DummyHandler: RequestHandler<AppiumParams, Void?> {
+    override fun handle(params: AppiumParams): Void? {
+        return null
+    }
+
+    override fun handleInternal(params: AppiumParams): Void? {
+        return null
+    }
+}
+
+class RouteDefinitionTest {
+    private val dummyHandler = DummyHandler()
+    private var routeDefinitionWithOneParam: RouteDefinition? = null
+    private var routeDefinitionWithZeroParams: RouteDefinition? = null
+    private var routeDefinitionWithTwoParams: RouteDefinition? = null
+
+    @Before
+    fun before() {
+        routeDefinitionWithZeroParams = RouteDefinition(
+                NanoHTTPD.Method.GET,
+                "/hello",
+                dummyHandler,
+                AppiumParams::class.java
+        )
+        routeDefinitionWithOneParam = RouteDefinition(
+                NanoHTTPD.Method.GET,
+                "/hello/:param/world",
+                dummyHandler,
+                AppiumParams::class.java
+        )
+        routeDefinitionWithTwoParams = RouteDefinition(
+                NanoHTTPD.Method.GET,
+                "/hello/:paramOne/something/:paramTwo/world",
+                dummyHandler,
+                AppiumParams::class.java
+        )
+    }
+
+    @Test
+    fun shouldProperlyParamsRoutesToUri() {
+        Assert.assertTrue(routeDefinitionWithZeroParams!!.isMatch("/hello"))
+        Assert.assertTrue(routeDefinitionWithZeroParams!!.isMatch("/hello/"))
+        Assert.assertFalse(routeDefinitionWithZeroParams!!.isMatch("/hello/world"))
+        Assert.assertFalse(routeDefinitionWithZeroParams!!.isMatch("/hellooooooooo"))
+        Assert.assertTrue(routeDefinitionWithOneParam!!.isMatch("/hello/something/world"))
+        Assert.assertTrue(routeDefinitionWithOneParam!!.isMatch("/hello/something/world/"))
+        Assert.assertFalse(routeDefinitionWithOneParam!!.isMatch("/hello/something/something/world"))
+        Assert.assertFalse(routeDefinitionWithOneParam!!.isMatch("/hello/world"))
+        Assert.assertFalse(routeDefinitionWithOneParam!!.isMatch("/something/hello/something/world"))
+        Assert.assertTrue(routeDefinitionWithTwoParams!!.isMatch("/hello/paramOne/something/paramTwo/world"))
+        Assert.assertTrue(routeDefinitionWithTwoParams!!.isMatch("/hello/paramOne/something/paramTwo/world/"))
+        Assert.assertFalse(routeDefinitionWithTwoParams!!.isMatch("/hello/paramOne/world"))
+        Assert.assertFalse(routeDefinitionWithTwoParams!!.isMatch("/hello/paramOne/paramTwo/world"))
+        Assert.assertFalse(routeDefinitionWithTwoParams!!.isMatch("/hello/paramOne/something/world"))
+    }
+
+    @Test
+    fun shouldProperlyParseUriParameters() {
+        Assert.assertEquals("something", routeDefinitionWithOneParam!!.getUriParams("/hello/something/world")["param"])
+        Assert.assertTrue("something", routeDefinitionWithZeroParams!!.getUriParams("/hello").isEmpty())
+        Assert.assertEquals("p1", routeDefinitionWithTwoParams!!.getUriParams("/hello/p1/something/p2/world/")["paramOne"])
+        Assert.assertEquals("p2", routeDefinitionWithTwoParams!!.getUriParams("/hello/p1/something/p2/world/")["paramTwo"])
+    }
+}

package/espresso-server/app/src/test/java/io/appium/espressoserver/test/model/HamcrestMatcherTest.kt

@@ -0,0 +1,112 @@
+package io.appium.espressoserver.test.model
+
+import androidx.test.espresso.matcher.CursorMatchers
+import androidx.test.espresso.matcher.CursorMatchers.CursorMatcher
+import com.google.gson.Gson
+import com.google.gson.JsonParseException
+import io.appium.espressoserver.lib.model.HamcrestMatcher
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class HamcrestMatcherTest {
+    val g = Gson()
+
+    @Test
+    fun `should parse Hamcrest matcher with single string arg`() {
+        val matcher = g.fromJson("""
+            {"name": "containsString", "args": "Hello World!"}
+        """.trimIndent(), HamcrestMatcher::class.java)
+        assertEquals(matcher.name, "containsString")
+        assertTrue(matcher.args contentEquals arrayOf<Any?>("Hello World!"))
+    }
+
+    @Test
+    fun `should parse Hamcrest matcher with array of primitive args` () {
+        val matcher = g.fromJson("""
+            {"name": "fakeMatcher", "args": [1, true, "Hello World!", null]}
+        """.trimIndent(), HamcrestMatcher::class.java)
+        assertEquals(matcher.name, "fakeMatcher")
+        val numberArg = matcher.args[0]
+        assertTrue(numberArg is Number)
+        assertEquals(numberArg.toInt(), 1)
+        assertEquals(matcher.args[1], true)
+        assertEquals(matcher.args[2], "Hello World!")
+        assertEquals(matcher.args[3], null)
+    }
+
+    @Test
+    fun `should parse empty args` () {
+        val matcher = g.fromJson("""
+            {"name": "isAThing"}
+        """.trimIndent(), HamcrestMatcher::class.java)
+        assertEquals(matcher.name, "isAThing")
+        assertTrue(matcher.args contentEquals emptyArray())
+    }
+
+    @Test
+    fun `should parse string as matcher with no args` () {
+        val matcher = g.fromJson("arglessMethod", HamcrestMatcher::class.java)
+        assertEquals(matcher.name, "arglessMethod")
+        assertTrue(matcher.args contentEquals emptyArray())
+    }
+
+    @Test
+    fun `should default the matcher class type to 'org_hamcrest_Matchers'` () {
+        val matcher = g.fromJson("""
+            {"name": "containsString", "args": "Hello"}
+        """.trimIndent(), HamcrestMatcher::class.java)
+        assertEquals(matcher.matcherClass, org.hamcrest.Matchers::class)
+        val containsStringMatcher = matcher.invoke()
+        assertTrue(containsStringMatcher.matches("Hello World"))
+        assertFalse(containsStringMatcher.matches("Goodbye World"))
+    }
+
+    @Test
+    fun `should parse the matcher class type` () {
+        val matcher = g.fromJson("""
+            {"name": "withRowBlob", "class": "androidx.test.espresso.matcher.CursorMatchers"}
+        """.trimIndent(), HamcrestMatcher::class.java)
+        assertEquals(matcher.matcherClass, CursorMatchers::class)
+    }
+
+    @Test
+    fun `should use 'androidx_test_espresso_matcher' when class provided but package not provided` () {
+        val matcher = g.fromJson("""
+            {"name": "withRowDouble", "args": ["Hello", 2.0], "class": "CursorMatchers"}
+        """.trimIndent(), HamcrestMatcher::class.java)
+        assertEquals(matcher.matcherClass, CursorMatchers::class)
+        assertTrue(matcher.invoke() is CursorMatcher)
+    }
+
+    @Test
+    fun `should parse matchers that have Class as an arg` () {
+        val matcher = g.fromJson("""
+            {"name": "instanceOf", "args": "String.class"}
+        """.trimIndent(), HamcrestMatcher::class.java)
+        assertTrue(matcher.invoke().matches("Hello World"))
+        assertFalse(matcher.invoke().matches(123))
+    }
+
+    @Test
+    fun `should parse nested Hamcrest matchers` () {
+        val matcher = g.fromJson("""
+            {"name": "anyOf", "args": [
+                {"name": "containsString", "args": "Hello"},
+                {"name": "instanceOf", "args": "Integer"}
+        ]}""".trimIndent(), HamcrestMatcher::class.java)
+        val nestedMatcher = matcher.invoke()
+        assertTrue(nestedMatcher.matches("Hello"))
+        assertTrue(nestedMatcher.matches(100))
+        assertFalse(nestedMatcher.matches("World"))
+        assertFalse(nestedMatcher.matches(100.1))
+    }
+
+    @Test(expected = JsonParseException::class)
+    fun `should fail if name not provided` () {
+        g.fromJson("""
+            {"args": "Hello World!"}
+        """.trimIndent(), HamcrestMatcher::class.java)
+    }
+}

package/espresso-server/app/src/test/java/io/appium/espressoserver/test/model/MatcherJsonTest.kt

@@ -0,0 +1,20 @@
+package io.appium.espressoserver.test.model
+
+import com.google.gson.Gson
+import io.appium.espressoserver.lib.model.MatcherJson
+import org.junit.Test
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class `MatcherJson Tests` {
+    val g = Gson()
+
+    @Test
+    fun `should parse matchers`() {
+        val dataMatcher = g.fromJson("""{
+            "name": "instanceOf", "args": "String.class"
+        }""".trimIndent(), MatcherJson::class.java)
+        assertTrue(dataMatcher.matcher.matches("A STRING"))
+        assertFalse(dataMatcher.matcher.matches(100))
+    }
+}