appium-espresso-driver 1.46.0

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

@@ -0,0 +1,76 @@
+package io.appium.espressoserver.test.helpers.w3c
+
+import io.appium.espressoserver.lib.handlers.exceptions.InvalidArgumentException
+import org.junit.Test
+
+import io.appium.espressoserver.lib.helpers.w3c.caps.parseCapabilities
+
+import org.junit.Assert.*
+
+class CapsUtilsTest {
+
+    @Test
+    fun shouldParseValidW3CCapabilitiesFromFirstMatch() {
+        val parsedCaps = parseCapabilities(listOf(mapOf(
+               "appActivity" to "com.package.activity",
+               "appPackage" to "com.package"
+               )), null)
+        assertEquals(parsedCaps["appActivity"], "com.package.activity")
+        assertEquals(parsedCaps["appPackage"], "com.package")
+    }
+
+    @Test
+    fun shouldParseValidEmptyW3CCapabilities() {
+        val parsedCaps = parseCapabilities(null, null)
+        assertEquals(parsedCaps.size, 0)
+    }
+
+    @Test
+    fun shouldParseValidW3CCapabilitiesFromAlwaysMatch() {
+        val parsedCaps = parseCapabilities(listOf(), mapOf(
+                "appActivity" to "com.package.activity",
+                "appPackage" to "com.package"
+        ))
+        assertEquals(parsedCaps["appActivity"], "com.package.activity")
+        assertEquals(parsedCaps["appPackage"], "com.package")
+    }
+
+    @Test
+    fun shouldParseValidW3CCapabilitiesFromBothMatches() {
+        val parsedCaps = parseCapabilities(listOf(mapOf(
+                "appActivity" to "com.package.activity"
+        )), mapOf(
+                "appPackage" to "com.package"
+        ))
+        assertEquals(parsedCaps["appActivity"], "com.package.activity")
+        assertEquals(parsedCaps["appPackage"], "com.package")
+    }
+
+    @Test
+    fun shouldParseValidW3CCapabilitiesFromBothMatchesWithPrefixes() {
+        val parsedCaps = parseCapabilities(listOf(mapOf(
+                "appium:appActivity" to "com.package.activity"
+        )), mapOf(
+                "appium:appPackage" to "com.package"
+        ))
+        assertEquals(parsedCaps["appActivity"], "com.package.activity")
+        assertEquals(parsedCaps["appPackage"], "com.package")
+    }
+
+    @Test(expected = InvalidArgumentException::class)
+    fun shouldThrowInvalidArgumentIfPropertyExistsInBothFirstAndAlwaysMatch() {
+        parseCapabilities(listOf(mapOf(
+                "appium:appActivity" to "com.package.activity"
+        )), mapOf(
+                "appActivity" to "com.package.activity",
+                "appium:appPackage" to "com.package"
+        ))
+    }
+
+    @Test(expected = InvalidArgumentException::class)
+    fun shouldThrowInvalidArgumentIfStandardPropertyIsPrefixed() {
+        parseCapabilities(listOf(mapOf(
+                "appium:platformName" to "android"
+        )), null)
+    }
+}

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

@@ -0,0 +1,7 @@
+package io.appium.espressoserver.test.helpers.w3c
+
+import org.junit.Assert
+
+fun assertFloatEquals(floatOne: Float, floatTwo: Float) {
+    Assert.assertEquals(floatOne.toDouble(), floatTwo.toDouble(), Math.ulp(1.0))
+}

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

@@ -0,0 +1,153 @@
+package io.appium.espressoserver.test.helpers.w3c
+
+import com.google.gson.Gson
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource.InputSourceType
+import io.appium.espressoserver.lib.helpers.w3c.models.Origin
+import io.appium.espressoserver.lib.helpers.w3c.state.KeyInputState
+import io.appium.espressoserver.lib.helpers.w3c.state.PointerInputState
+import org.junit.Assert
+import org.junit.Test
+import java.util.*
+import kotlin.test.assertEquals
+
+class InputSourceTest {
+    @Test
+    fun shouldDeserializeInputSource() {
+        val postJson = "{\"id\":\"something1\"}"
+        val inputSource = Gson().fromJson(postJson, InputSource::class.java)
+        Assert.assertEquals(inputSource.id, "something1")
+    }
+
+    @Test
+    fun shouldDeserializePointerInputSource() {
+        val postJson = "{\"type\":\"pointer\",\"id\":\"something2\", \"parameters\": {\"pointerType\": \"touch\"}}"
+        val inputSource = Gson().fromJson(postJson, InputSource::class.java)
+        Assert.assertEquals(inputSource.id, "something2")
+        Assert.assertEquals(inputSource.pointerType, InputSource.PointerType.TOUCH)
+    }
+
+    @Test
+    fun shouldDeserializeElementOriginPointer() {
+        val postJson = "{\"type\":\"pointer\",\"id\":\"something2\", \"parameters\": {\"pointerType\": \"touch\"}, " +
+                "\"actions\": [{\"type\":\"pointerMove\",\"duration\":1000,\"origin\":{\"element-6066-11e4-a52e-4f735466cecf\":\"some-element-id\"},\"x\":50,\"y\":0}]}"
+        val inputSource = Gson().fromJson(postJson, InputSource::class.java)
+        Assert.assertEquals(inputSource.id, "something2")
+        Assert.assertEquals(inputSource.pointerType, InputSource.PointerType.TOUCH)
+        val action = inputSource.actions!![0]
+        Assert.assertEquals(action.origin.type, Origin.ELEMENT)
+        Assert.assertEquals(action.origin.elementId, "some-element-id")
+    }
+
+    @Test
+    fun shouldDeserializeComplexPointerObject() {
+        val postJson = "{\"type\":\"pointer\",\"id\":\"finger1\",\"parameters\":{\"pointerType\":\"touch\"},\"actions\":[{\"type\":\"pointerMove\",\"duration\":0,\"x\":100,\"y\":200},{\"type\":\"pointerDown\",\"button\":0},{\"type\":\"pause\",\"duration\":500},{\"type\":\"pointerMove\",\"duration\":1000,\"origin\":\"pointer\",\"x\":50,\"y\":10},{\"type\":\"pointerUp\",\"button\":0}]}"
+        val inputSource = Gson().fromJson(postJson, InputSource::class.java)
+        Assert.assertEquals(inputSource.type, InputSourceType.POINTER)
+        Assert.assertEquals(inputSource.id, "finger1")
+        Assert.assertEquals(inputSource.pointerType, InputSource.PointerType.TOUCH)
+        val actions = inputSource.actions
+        val actionOne = actions!![0]
+        Assert.assertEquals(actionOne.type, InputSource.ActionType.POINTER_MOVE)
+        assertFloatEquals(actionOne.duration!!, 0f)
+        assertFloatEquals(actionOne.x!!, 100f)
+        assertFloatEquals(actionOne.y!!, 200f)
+        val actionTwo = actions[1]
+        Assert.assertEquals(actionTwo.type, InputSource.ActionType.POINTER_DOWN)
+        assertEquals(actionTwo.button, 0)
+        val actionThree = actions[2]
+        Assert.assertEquals(actionThree.type, InputSource.ActionType.PAUSE)
+        assertFloatEquals(actionThree.duration!!, 500f)
+        val actionFour = actions[3]
+        Assert.assertEquals(actionFour.type, InputSource.ActionType.POINTER_MOVE)
+        assertFloatEquals(actionFour.duration!!, 1000f)
+        Assert.assertEquals(actionFour.origin.type, "pointer")
+        Assert.assertTrue(actionFour.isOriginPointer)
+        assertFloatEquals(actionFour.x!!, 50f)
+        assertFloatEquals(actionFour.y!!, 10f)
+        val actionFive = actions[4]
+        Assert.assertEquals(actionFive.type, InputSource.ActionType.POINTER_UP)
+        assertEquals(actionFive.button, 0)
+    }
+
+    @Test
+    fun shouldDeserializeComplexKeyObject() {
+        val postJson = "{\"type\":\"key\",\"id\":\"keyboard\",\"actions\":[{\"type\":\"keyDown\",\"value\":\"key1\"},{\"type\":\"keyDown\",\"value\":\"key2\"},{\"type\":\"keyUp\",\"value\":\"key1\"},{\"type\":\"keyUp\",\"value\":\"key2\"}]}"
+        val inputSource = Gson().fromJson(postJson, InputSource::class.java)
+        Assert.assertEquals(inputSource.type, InputSourceType.KEY)
+        Assert.assertEquals(inputSource.id, "keyboard")
+        Assert.assertNull(inputSource.pointerType)
+        val actions = inputSource.actions
+        val actionOne = actions!![0]
+        Assert.assertEquals(actionOne.type, InputSource.ActionType.KEY_DOWN)
+        Assert.assertEquals(actionOne.value, "key1")
+        val actionTwo = actions[1]
+        Assert.assertEquals(actionTwo.type, InputSource.ActionType.KEY_DOWN)
+        Assert.assertEquals(actionTwo.value, "key2")
+        val actionThree = actions[2]
+        Assert.assertEquals(actionThree.type, InputSource.ActionType.KEY_UP)
+        Assert.assertEquals(actionThree.value, "key1")
+        val actionFour = actions[3]
+        Assert.assertEquals(actionFour.type, InputSource.ActionType.KEY_UP)
+        Assert.assertEquals(actionFour.value, "key2")
+    }
+
+    @Test
+    fun shouldDefaultPointerTypeToTouch() {
+        val inputSource = InputSource()
+        inputSource.type = InputSourceType.POINTER
+        Assert.assertEquals(inputSource.pointerType, InputSource.PointerType.TOUCH)
+    }
+
+    @Test
+    fun shouldMapKeyObjectToKeyInputState() {
+        val actions: MutableList<InputSource.Action> = ArrayList()
+        val action = InputSource.Action()
+        action.type = InputSource.ActionType.KEY_DOWN
+        actions.add(action)
+        val inputSource = InputSource(InputSourceType.KEY, "any", null, actions)
+
+        // Check the initial state
+        val inputState = inputSource.defaultState as KeyInputState?
+        Assert.assertFalse(inputState!!.isAlt)
+        Assert.assertFalse(inputState.isCtrl)
+        Assert.assertFalse(inputState.isMeta)
+        Assert.assertFalse(inputState.isShift)
+
+        // Add and remove a key and check the state along the way
+        Assert.assertFalse(inputState.isPressed("a"))
+        inputState.addPressed("a")
+        Assert.assertTrue(inputState.isPressed("a"))
+        inputState.removePressed("a")
+        Assert.assertFalse(inputState.isPressed("a"))
+    }
+
+    @Test
+    fun shouldMapPointerObjectToPointerInputState() {
+        val actions: MutableList<InputSource.Action> = ArrayList()
+        val action = InputSource.Action()
+        action.type = InputSource.ActionType.POINTER_DOWN
+        actions.add(action)
+        val parameters = InputSource.Parameters()
+        parameters.pointerType = InputSource.PointerType.TOUCH
+        val inputSource = InputSource(InputSourceType.POINTER, "any", parameters, actions)
+
+        // Check the initial state
+        val inputState = inputSource.defaultState as PointerInputState?
+        Assert.assertFalse(inputState!!.isPressed(1))
+        inputState.addPressed(1)
+        Assert.assertTrue(inputState.isPressed(1))
+        inputState.removePressed(1)
+        Assert.assertFalse(inputState.isPressed(1))
+    }
+
+    @Test
+    fun shouldMapNullInputSourceStateToNull() {
+        val actions: MutableList<InputSource.Action> = ArrayList()
+        val action = InputSource.Action()
+        action.type = InputSource.ActionType.POINTER_DOWN
+        actions.add(action)
+        val inputSource = InputSource(InputSourceType.NONE, "any", null, actions)
+        Assert.assertNull(inputSource.defaultState)
+    }
+}

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

@@ -0,0 +1,72 @@
+package io.appium.espressoserver.test.helpers.w3c
+
+import io.appium.espressoserver.lib.handlers.exceptions.AppiumException
+import io.appium.espressoserver.lib.helpers.w3c.adapter.DummyW3CActionAdapter
+import io.appium.espressoserver.lib.helpers.w3c.adapter.W3CActionAdapter
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.KeyNormalizer
+import io.appium.espressoserver.lib.helpers.w3c.models.ActionObject
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource.InputSourceType
+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 org.junit.Test
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class InputStateTableTest {
+    @Test
+    @Throws(AppiumException::class)
+    fun shouldUndoPointerDownEvents() {
+        val inputStateTable = InputStateTable()
+        val adapter: W3CActionAdapter = DummyW3CActionAdapter()
+
+        // Create a pointer down action
+        val actionObject = ActionObject()
+        actionObject.type = InputSourceType.POINTER
+        actionObject.subType = InputSource.ActionType.POINTER_DOWN
+        actionObject.button = 5
+        actionObject.id = "123"
+
+        // Call the pointer down action
+        actionObject.dispatch(adapter, inputStateTable, 0f, 0)
+
+        // Check that the button is depressed
+        val inputState = inputStateTable.getInputState("123") as PointerInputState?
+        assertTrue(inputState!!.buttons.contains(5))
+
+        // Undo the action and check that it is not depressed anymore
+        inputStateTable.undoAll(adapter, 0)
+        assertFalse(inputState.buttons.contains(5))
+        assertTrue(inputState.buttons.isEmpty())
+    }
+
+    @Test
+    @Throws(AppiumException::class)
+    fun shouldUndoKeyDownEvents() {
+        val inputStateTable = InputStateTable()
+        val adapter: W3CActionAdapter = DummyW3CActionAdapter()
+        val SHIFT = "\uE008"
+
+        // Create a pointer down action
+        val actionObject = ActionObject()
+        actionObject.type = InputSourceType.KEY
+        actionObject.subType = InputSource.ActionType.KEY_DOWN
+        actionObject.value = SHIFT
+        actionObject.id = "456"
+
+        // Call the pointer down action
+        actionObject.dispatch(adapter, inputStateTable, 0f, 0)
+
+        // Check that the button is depressed
+        val normalizedKey = KeyNormalizer.toNormalizedKey(SHIFT)
+        val inputState = inputStateTable.getInputState("456") as KeyInputState?
+        assertTrue(inputState!!.isPressed(normalizedKey))
+        assertTrue(inputState.isShift)
+
+        // Undo the action and check that it is not depressed anymore
+        inputStateTable.undoAll(adapter, 0)
+        assertFalse(inputState.isPressed(normalizedKey))
+        assertFalse(inputState.isShift)
+    }
+}

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

@@ -0,0 +1,133 @@
+package io.appium.espressoserver.test.helpers.w3c
+
+import io.appium.espressoserver.lib.handlers.exceptions.AppiumException
+import io.appium.espressoserver.lib.helpers.w3c.adapter.DummyW3CActionAdapter
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.KeyNormalizer
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.constants.NormalizedKeys
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.dispatchKeyDown
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.dispatchKeyUp
+import io.appium.espressoserver.lib.helpers.w3c.models.ActionObject
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource.InputSourceType
+import io.appium.espressoserver.lib.helpers.w3c.state.InputStateTable
+import io.appium.espressoserver.lib.helpers.w3c.state.KeyInputState
+import org.junit.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+class KeyDispatchTest {
+    @Test
+    @Throws(AppiumException::class)
+    fun shouldToggleAltIfAltPassedToBlankKeyState() {
+        val adapter = DummyW3CActionAdapter()
+        val inputStateTable = InputStateTable()
+        val id = "keyboard"
+        val alt = "\uE00A"
+        val actionObject = ActionObject(id, InputSourceType.KEY, InputSource.ActionType.KEY_DOWN, 0)
+        actionObject.value = alt
+        val keyInputState = KeyInputState()
+        assertFalse(keyInputState.isAlt)
+        assertFalse(keyInputState.isCtrl)
+        val cancelList = inputStateTable.cancelList
+        assertTrue(cancelList.isEmpty())
+        dispatchKeyDown(adapter, actionObject, keyInputState, inputStateTable)
+        assertEquals(cancelList.size, 1)
+        val cancelObject = cancelList[0]
+        assertEquals(cancelObject.subType, InputSource.ActionType.KEY_UP)
+        assertEquals(cancelObject.value, alt)
+        assertTrue(keyInputState.isAlt)
+        assertFalse(keyInputState.isCtrl)
+    }
+
+    @Test
+    @Throws(AppiumException::class)
+    fun shouldAddKeysToKeyPressedState() {
+        val adapter = DummyW3CActionAdapter()
+        val inputStateTable = InputStateTable()
+        val id = "keyboard"
+        val value = "F"
+        val actionObject = ActionObject(id, InputSourceType.KEY, InputSource.ActionType.KEY_DOWN, 0)
+        actionObject.value = value
+        val keyInputState = KeyInputState()
+        assertFalse(keyInputState.isPressed(value))
+        dispatchKeyDown(adapter, actionObject, keyInputState, inputStateTable)
+        assertTrue(keyInputState.isPressed(value))
+    }
+
+    @Test
+    @Throws(AppiumException::class)
+    fun shouldPassKeyCodeToEvent() {
+        val adapter = DummyW3CActionAdapter()
+        val inputStateTable = InputStateTable()
+        val id = "keyboard"
+        val actionObject = ActionObject(id, InputSourceType.KEY, InputSource.ActionType.KEY_DOWN, 0)
+        actionObject.value = "F"
+        val keyInputState = KeyInputState()
+        val keyEvent = dispatchKeyDown(adapter, actionObject, keyInputState, inputStateTable)
+        assertEquals(keyEvent!!.code, "KeyF")
+    }
+
+    @Test
+    @Throws(AppiumException::class)
+    fun shouldPassNullKeyCodeAndLocationZeroIfNotDefined() {
+        val adapter = DummyW3CActionAdapter()
+        val inputStateTable = InputStateTable()
+        val id = "keyboard"
+        val actionObject = ActionObject(id, InputSourceType.KEY, InputSource.ActionType.KEY_DOWN, 0)
+        actionObject.value = "\uFFFF"
+        val keyInputState = KeyInputState()
+        val keyEvent = dispatchKeyDown(adapter, actionObject, keyInputState, inputStateTable)
+        assertNull(keyEvent!!.code)
+        assertEquals(keyEvent.location, 0)
+    }
+
+    @Test
+    @Throws(AppiumException::class)
+    fun shouldReleaseAltOnAltKeyUp() {
+        val adapter = DummyW3CActionAdapter()
+        val inputStateTable = InputStateTable()
+        val id = "keyboard"
+        val alt = "\uE00A"
+        val actionObject = ActionObject(id, InputSourceType.KEY, InputSource.ActionType.KEY_DOWN, 0)
+        actionObject.value = alt
+        val keyInputState = KeyInputState()
+        keyInputState.addPressed("ALT")
+        keyInputState.isAlt = true
+        keyInputState.isCtrl = true
+        assertTrue(keyInputState.isAlt)
+        assertTrue(keyInputState.isCtrl)
+        dispatchKeyUp(adapter, actionObject, keyInputState, inputStateTable)
+        assertFalse(keyInputState.isAlt)
+        assertTrue(keyInputState.isCtrl)
+    }
+
+    @Test
+    @Throws(AppiumException::class)
+    fun shouldAddAndRemoveKeysFromKeyPressedState() {
+        val adapter = DummyW3CActionAdapter()
+        val inputStateTable = InputStateTable()
+        val id = "keyboard"
+        val value = "~"
+        val actionObject = ActionObject(id, InputSourceType.KEY, InputSource.ActionType.KEY_DOWN, 0)
+        actionObject.value = value
+        val keyInputState = KeyInputState()
+        assertFalse(keyInputState.isPressed(value))
+
+        // Press down a key and check that it's pressed
+        dispatchKeyDown(adapter, actionObject, keyInputState, inputStateTable)
+        assertTrue(keyInputState.isPressed(value))
+
+        // Release a key and check that it's not pressed
+        dispatchKeyUp(adapter, actionObject, keyInputState, inputStateTable)
+        assertFalse(keyInputState.isPressed(value))
+    }
+
+    @Test
+    @Throws(AppiumException::class)
+    fun shouldNormalizeKeys() {
+        val normalizedKey = KeyNormalizer.toNormalizedKey("\uE008")
+        assertEquals(normalizedKey, NormalizedKeys.SHIFT)
+    }
+}

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

@@ -0,0 +1,74 @@
+package io.appium.espressoserver.test.helpers.w3c
+
+import io.appium.espressoserver.lib.helpers.w3c.state.KeyInputState
+import io.appium.espressoserver.lib.helpers.w3c.state.getGlobalKeyState
+import org.junit.Assert
+import org.junit.Before
+import org.junit.Test
+
+class KeyInputStateTest {
+    private var keyInputStateOne: KeyInputState? = null
+    private var keyInputStateTwo: KeyInputState? = null
+
+    @Before
+    fun before() {
+        keyInputStateOne = KeyInputState()
+        keyInputStateTwo = KeyInputState()
+    }
+
+    @Test
+    fun shouldSetAltToTrueIfJustOneIsTrue() {
+        keyInputStateOne!!.isAlt = true
+        keyInputStateTwo!!.isAlt = false
+        val keyInputStates = arrayOf(keyInputStateOne, keyInputStateTwo)
+        val aggregateKeyInputState = getGlobalKeyState(listOfNotNull(*keyInputStates))
+        Assert.assertTrue(aggregateKeyInputState.isAlt)
+    }
+
+    @Test
+    fun shouldSetAltToFalseIfAllAreFalse() {
+        keyInputStateOne!!.isAlt = false
+        keyInputStateTwo!!.isAlt = false
+        val keyInputStates = arrayOf(keyInputStateOne, keyInputStateTwo)
+        val aggregateKeyInputState = getGlobalKeyState(listOfNotNull(*keyInputStates))
+        Assert.assertFalse(aggregateKeyInputState.isAlt)
+    }
+
+    @Test
+    fun shouldTestSeveralKeyStates() {
+        keyInputStateOne!!.isAlt = true
+        keyInputStateOne!!.isCtrl = true
+        keyInputStateOne!!.isShift = false
+        keyInputStateOne!!.isMeta = false
+        keyInputStateTwo!!.isAlt = false
+        keyInputStateTwo!!.isCtrl = true
+        keyInputStateTwo!!.isShift = false
+        keyInputStateTwo!!.isMeta = true
+        val keyInputStates = arrayOf(keyInputStateOne, keyInputStateTwo)
+        val aggregateKeyInputState = getGlobalKeyState(listOfNotNull(*keyInputStates))
+        Assert.assertTrue(aggregateKeyInputState.isAlt)
+        Assert.assertTrue(aggregateKeyInputState.isCtrl)
+        Assert.assertFalse(aggregateKeyInputState.isShift)
+        Assert.assertTrue(aggregateKeyInputState.isMeta)
+    }
+
+    @Test
+    fun shouldCombinePressed() {
+        keyInputStateOne!!.addPressed("a")
+        keyInputStateOne!!.addPressed("b")
+        keyInputStateOne!!.addPressed("c")
+        keyInputStateOne!!.addPressed("d")
+        keyInputStateTwo!!.addPressed("d")
+        keyInputStateTwo!!.addPressed("e")
+        keyInputStateTwo!!.addPressed("f")
+        val keyInputStates = arrayOf(keyInputStateOne, keyInputStateTwo)
+        val aggregateKeyInputState = getGlobalKeyState(listOfNotNull(*keyInputStates))
+        Assert.assertTrue(aggregateKeyInputState.isPressed("a"))
+        Assert.assertTrue(aggregateKeyInputState.isPressed("b"))
+        Assert.assertTrue(aggregateKeyInputState.isPressed("c"))
+        Assert.assertTrue(aggregateKeyInputState.isPressed("d"))
+        Assert.assertTrue(aggregateKeyInputState.isPressed("e"))
+        Assert.assertTrue(aggregateKeyInputState.isPressed("f"))
+        Assert.assertFalse(aggregateKeyInputState.isPressed("g"))
+    }
+}