appium-espresso-driver 1.46.0

package/espresso-server/app/src/androidTest/java/io/appium/espressoserver/lib/helpers/reflection/ArrayUtils.java

@@ -0,0 +1,110 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  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.lib.helpers.reflection;
+
+import java.lang.reflect.Array;
+
+public class ArrayUtils {
+    public static final Class<?>[] EMPTY_CLASS_ARRAY = new Class[0];
+    public static final Object[] EMPTY_OBJECT_ARRAY = new Object[0];
+
+    public static boolean isEmpty(final Object[] array) {
+        return getLength(array) == 0;
+    }
+
+    public static int getLength(final Object array) {
+        if (array == null) {
+            return 0;
+        }
+        return Array.getLength(array);
+    }
+
+    public static Object[] nullToEmpty(final Object[] array) {
+        if (isEmpty(array)) {
+            return EMPTY_OBJECT_ARRAY;
+        }
+        return array;
+    }
+
+    public static boolean isSameLength(final Object[] array1, final Object[] array2) {
+        return getLength(array1) == getLength(array2);
+    }
+
+    @SuppressWarnings("RedundantCast")
+    public static Object toPrimitive(final Object array) {
+        if (array == null) {
+            return null;
+        }
+        final Class<?> ct = array.getClass().getComponentType();
+        final Class<?> pt = ClassUtils.wrapperToPrimitive(ct);
+        if (Integer.TYPE.equals(pt)) {
+            return toPrimitive((Integer[]) array);
+        }
+        if (Long.TYPE.equals(pt)) {
+            return toPrimitive((Long[]) array);
+        }
+        if (Short.TYPE.equals(pt)) {
+            return toPrimitive((Short[]) array);
+        }
+        if (Double.TYPE.equals(pt)) {
+            return toPrimitive((Double[]) array);
+        }
+        if (Float.TYPE.equals(pt)) {
+            return toPrimitive((Float[]) array);
+        }
+        return array;
+    }
+
+    public static <T> T[] clone(final T[] array) {
+        if (array == null) {
+            return null;
+        }
+        return array.clone();
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T> T[] addAll(final T[] array1, final T... array2) {
+        if (array1 == null) {
+            return clone(array2);
+        } else if (array2 == null) {
+            return clone(array1);
+        }
+        final Class<?> type1 = array1.getClass().getComponentType();
+        @SuppressWarnings("unchecked") // OK, because array is of type T
+        final T[] joinedArray = (T[]) Array.newInstance(type1, array1.length + array2.length);
+        System.arraycopy(array1, 0, joinedArray, 0, array1.length);
+        try {
+            System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
+        } catch (final ArrayStoreException ase) {
+            // Check if problem was due to incompatible types
+            /*
+             * We do this here, rather than before the copy because:
+             * - it would be a wasted check most of the time
+             * - safer, in case check turns out to be too strict
+             */
+            final Class<?> type2 = array2.getClass().getComponentType();
+            //noinspection ConstantConditions
+            if (!type1.isAssignableFrom(type2)) {
+                throw new IllegalArgumentException("Cannot store " + type2.getName() + " in an array of "
+                        + type1.getName(), ase);
+            }
+            throw ase; // No, so rethrow original
+        }
+        return joinedArray;
+    }
+}

package/espresso-server/app/src/androidTest/java/io/appium/espressoserver/lib/helpers/reflection/ClassUtils.java

@@ -0,0 +1,180 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  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.lib.helpers.reflection;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class ClassUtils {
+
+    private static final Map<Class<?>, Class<?>> primitiveWrapperMap = new HashMap<>();
+    static {
+        primitiveWrapperMap.put(Boolean.TYPE, Boolean.class);
+        primitiveWrapperMap.put(Byte.TYPE, Byte.class);
+        primitiveWrapperMap.put(Character.TYPE, Character.class);
+        primitiveWrapperMap.put(Short.TYPE, Short.class);
+        primitiveWrapperMap.put(Integer.TYPE, Integer.class);
+        primitiveWrapperMap.put(Long.TYPE, Long.class);
+        primitiveWrapperMap.put(Double.TYPE, Double.class);
+        primitiveWrapperMap.put(Float.TYPE, Float.class);
+        primitiveWrapperMap.put(Void.TYPE, Void.TYPE);
+    }
+
+    private static final Map<Class<?>, Class<?>> wrapperPrimitiveMap = new HashMap<>();
+    static {
+        for (final Map.Entry<Class<?>, Class<?>> entry : primitiveWrapperMap.entrySet()) {
+            final Class<?> primitiveClass = entry.getKey();
+            final Class<?> wrapperClass = entry.getValue();
+            if (!primitiveClass.equals(wrapperClass)) {
+                wrapperPrimitiveMap.put(wrapperClass, primitiveClass);
+            }
+        }
+    }
+
+    public static Class<?> primitiveToWrapper(final Class<?> cls) {
+        Class<?> convertedClass = cls;
+        if (cls != null && cls.isPrimitive()) {
+            convertedClass = primitiveWrapperMap.get(cls);
+        }
+        return convertedClass;
+    }
+
+    public static Class<?> wrapperToPrimitive(final Class<?> cls) {
+        return wrapperPrimitiveMap.get(cls);
+    }
+
+    public static boolean isAssignable(Class<?>[] classArray, Class<?>[] toClassArray, final boolean autoboxing) {
+        if (!ArrayUtils.isSameLength(classArray, toClassArray)) {
+            return false;
+        }
+        if (classArray == null) {
+            classArray = ArrayUtils.EMPTY_CLASS_ARRAY;
+        }
+        if (toClassArray == null) {
+            toClassArray = ArrayUtils.EMPTY_CLASS_ARRAY;
+        }
+        for (int i = 0; i < classArray.length; i++) {
+            if (!isAssignable(classArray[i], toClassArray[i], autoboxing)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @SuppressWarnings("DuplicateExpressions")
+    public static boolean isAssignable(Class<?> cls, final Class<?> toClass, final boolean autoboxing) {
+        if (toClass == null) {
+            return false;
+        }
+        // have to check for null, as isAssignableFrom doesn't
+        if (cls == null) {
+            return !toClass.isPrimitive();
+        }
+        //autoboxing:
+        if (autoboxing) {
+            if (cls.isPrimitive() && !toClass.isPrimitive()) {
+                cls = primitiveToWrapper(cls);
+                if (cls == null) {
+                    return false;
+                }
+            }
+            if (toClass.isPrimitive() && !cls.isPrimitive()) {
+                cls = wrapperToPrimitive(cls);
+                if (cls == null) {
+                    return false;
+                }
+            }
+        }
+        if (cls.equals(toClass)) {
+            return true;
+        }
+        if (cls.isPrimitive()) {
+            if (!toClass.isPrimitive()) {
+                return false;
+            }
+            if (Integer.TYPE.equals(cls)) {
+                return Long.TYPE.equals(toClass)
+                        || Float.TYPE.equals(toClass)
+                        || Double.TYPE.equals(toClass);
+            }
+            if (Long.TYPE.equals(cls)) {
+                return Float.TYPE.equals(toClass)
+                        || Double.TYPE.equals(toClass);
+            }
+            if (Boolean.TYPE.equals(cls)) {
+                return false;
+            }
+            if (Double.TYPE.equals(cls)) {
+                return false;
+            }
+            if (Float.TYPE.equals(cls)) {
+                return Double.TYPE.equals(toClass);
+            }
+            if (Character.TYPE.equals(cls)) {
+                return Integer.TYPE.equals(toClass)
+                        || Long.TYPE.equals(toClass)
+                        || Float.TYPE.equals(toClass)
+                        || Double.TYPE.equals(toClass);
+            }
+            if (Short.TYPE.equals(cls)) {
+                return Integer.TYPE.equals(toClass)
+                        || Long.TYPE.equals(toClass)
+                        || Float.TYPE.equals(toClass)
+                        || Double.TYPE.equals(toClass);
+            }
+            if (Byte.TYPE.equals(cls)) {
+                return Short.TYPE.equals(toClass)
+                        || Integer.TYPE.equals(toClass)
+                        || Long.TYPE.equals(toClass)
+                        || Float.TYPE.equals(toClass)
+                        || Double.TYPE.equals(toClass);
+            }
+            // should never get here
+            return false;
+        }
+        return toClass.isAssignableFrom(cls);
+    }
+
+    public static List<Class<?>> getAllSuperclasses(final Class<?> cls) {
+        if (cls == null) {
+            return null;
+        }
+        final List<Class<?>> classes = new ArrayList<>();
+        Class<?> superclass = cls.getSuperclass();
+        while (superclass != null) {
+            classes.add(superclass);
+            superclass = superclass.getSuperclass();
+        }
+        return classes;
+    }
+
+    public static Class<?>[] toClass(final Object... array) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return ArrayUtils.EMPTY_CLASS_ARRAY;
+        }
+        final Class<?>[] classes = new Class[array.length];
+        for (int i = 0; i < array.length; i++) {
+            classes[i] = array[i] == null ? null : array[i].getClass();
+        }
+        return classes;
+    }
+}

package/espresso-server/app/src/androidTest/java/io/appium/espressoserver/lib/helpers/reflection/MethodUtils.java

@@ -0,0 +1,155 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  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.lib.helpers.reflection;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * Copied from org.apache.commons.lang3.reflect
+ */
+public class MethodUtils {
+
+    public static Object invokeMethod(final Object object, final String methodName, Object... args)
+            throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
+        args = ArrayUtils.nullToEmpty(args);
+        final Class<?>[] parameterTypes = ClassUtils.toClass(args);
+        Method method = getMatchingMethod(object.getClass(), methodName, parameterTypes);
+        if (method != null && !method.isAccessible()) {
+            method.setAccessible(true);
+        }
+
+        if (method == null) {
+            throw new NoSuchMethodException("No such method: " + methodName + "() on object: " + object.getClass().getName());
+        }
+        args = toVarArgs(method, args);
+        return method.invoke(object, args);
+    }
+
+    public static Object invokeStaticMethod(final Class<?> cls, final String methodName, Object... args)
+            throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
+        args = ArrayUtils.nullToEmpty(args);
+        final Class<?>[] parameterTypes = ClassUtils.toClass(args);
+        final Method method = getMatchingMethod(cls, methodName, parameterTypes);
+        if (method != null && !method.isAccessible()) {
+            method.setAccessible(true);
+        }
+
+        if (method == null) {
+            throw new NoSuchMethodException("No such method: " + methodName + "() on class: " + cls.getName());
+        }
+        args = toVarArgs(method, args);
+        return method.invoke(null, args);
+    }
+
+
+    private static Object[] getVarArgs(final Object[] args, final Class<?>[] methodParameterTypes) {
+        if (args.length == methodParameterTypes.length && (args[args.length - 1] == null ||
+                args[args.length - 1].getClass().equals(methodParameterTypes[methodParameterTypes.length - 1]))) {
+            // The args array is already in the canonical form for the method.
+            return args;
+        }
+
+        // Construct a new array matching the method's declared parameter types.
+        final Object[] newArgs = new Object[methodParameterTypes.length];
+
+        // Copy the normal (non-varargs) parameters
+        System.arraycopy(args, 0, newArgs, 0, methodParameterTypes.length - 1);
+
+        // Construct a new array for the variadic parameters
+        final Class<?> varArgComponentType = methodParameterTypes[methodParameterTypes.length - 1].getComponentType();
+        final int varArgLength = args.length - methodParameterTypes.length + 1;
+
+        Object varArgsArray = Array.newInstance(ClassUtils.primitiveToWrapper(varArgComponentType), varArgLength);
+        // Copy the variadic arguments into the varargs array.
+        //noinspection SuspiciousSystemArraycopy
+        System.arraycopy(args, methodParameterTypes.length - 1, varArgsArray, 0, varArgLength);
+
+        //noinspection ConstantConditions
+        if (varArgComponentType.isPrimitive()) {
+            // unbox from wrapper type to primitive type
+            varArgsArray = ArrayUtils.toPrimitive(varArgsArray);
+        }
+
+        // Store the varargs array in the last position of the array to return
+        newArgs[methodParameterTypes.length - 1] = varArgsArray;
+
+        // Return the canonical varargs array.
+        return newArgs;
+    }
+
+    private static Object[] toVarArgs(final Method method, Object[] args) {
+        if (method.isVarArgs()) {
+            final Class<?>[] methodParameterTypes = method.getParameterTypes();
+            args = getVarArgs(args, methodParameterTypes);
+        }
+        return args;
+    }
+
+    private static Method getMatchingMethod(final Class<?> cls, final String methodName, final Class<?>... parameterTypes) {
+        Validate.notNull(cls, "Null class not allowed.");
+        Validate.notEmpty(methodName, "Null or blank methodName not allowed.");
+
+        // Address methods in superclasses
+        Method[] methodArray = cls.getDeclaredMethods();
+        final List<Class<?>> superclassList = ClassUtils.getAllSuperclasses(cls);
+        for (final Class<?> klass : superclassList) {
+            methodArray = ArrayUtils.addAll(methodArray, klass.getDeclaredMethods());
+        }
+
+        Method inexactMatch = null;
+        for (final Method method : methodArray) {
+            if (methodName.equals(method.getName()) &&
+                    Objects.deepEquals(parameterTypes, method.getParameterTypes())) {
+                return method;
+            } else if (methodName.equals(method.getName()) &&
+                    ClassUtils.isAssignable(parameterTypes, method.getParameterTypes(), true)) {
+                if ((inexactMatch == null) || (distance(parameterTypes, method.getParameterTypes())
+                        < distance(parameterTypes, inexactMatch.getParameterTypes()))) {
+                    inexactMatch = method;
+                }
+            }
+        }
+        return inexactMatch;
+    }
+
+    private static int distance(final Class<?>[] classArray, final Class<?>[] toClassArray) {
+        int answer = 0;
+
+        if (!ClassUtils.isAssignable(classArray, toClassArray, true)) {
+            return -1;
+        }
+        for (int offset = 0; offset < classArray.length; offset++) {
+            // Note InheritanceUtils.distance() uses different scoring system.
+            if (classArray[offset].equals(toClassArray[offset])) {
+                //noinspection UnnecessaryContinue
+                continue;
+            } else if (ClassUtils.isAssignable(classArray[offset], toClassArray[offset], true)
+                    && !ClassUtils.isAssignable(classArray[offset], toClassArray[offset], false)) {
+                answer++;
+            } else {
+                answer = answer + 2;
+            }
+        }
+
+        return answer;
+    }
+}

package/espresso-server/app/src/androidTest/java/io/appium/espressoserver/lib/helpers/reflection/Validate.java

@@ -0,0 +1,34 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  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.lib.helpers.reflection;
+
+public class Validate {
+    public static <T> T notNull(final T object, final String message, final Object... values) {
+        if (object == null) {
+            throw new NullPointerException(String.format(message, values));
+        }
+        return object;
+    }
+
+    public static <T extends CharSequence> T notEmpty(final T chars, final String message, final Object... values) {
+        if (notNull(chars, message, values).length() == 0) {
+            throw new IllegalArgumentException(String.format(message, values));
+        }
+        return chars;
+    }
+}

package/espresso-server/app/src/androidTest/java/io/appium/espressoserver/lib/helpers/w3c/adapter/BaseW3CActionAdapter.kt

@@ -0,0 +1,71 @@
+package io.appium.espressoserver.lib.helpers.w3c.adapter
+
+import java.util.concurrent.locks.ReentrantLock
+
+import io.appium.espressoserver.lib.handlers.exceptions.AppiumException
+import io.appium.espressoserver.lib.helpers.w3c.state.PointerInputState
+
+abstract class BaseW3CActionAdapter : W3CActionAdapter {
+
+    override fun getKeyCode(keyValue: String?, location: Int): Int {
+        keyValue?.let {
+            return Character.getNumericValue(keyValue[0])
+        }
+        return -1
+    }
+
+    override fun getCharCode(keyValue: String?, location: Int): Int = -1
+
+    override fun getWhich(keyValue: String?, location: Int): Int = -1
+
+    override fun lockAdapter() {
+        reentrantLock.lock()
+    }
+
+    override fun unlockAdapter() {
+        reentrantLock.unlock()
+    }
+
+    /**
+     * Determines how close coordinates must be to the target coordinates before we
+     * decide to just skip ahead to the target coordinates. 0.01 is arbitrary.
+     *
+     * (see item 4 of 'perform a pointer move' algorithm in 17.4.3)
+     * @param pointerInputState What the state of the pointer is currently
+     * @return How close the coordinates need to be to just go to the final coordinate.
+     */
+    override fun getPointerMoveDurationMargin(pointerInputState: PointerInputState): Double = 0.01
+
+    /**
+     * How long (in ms) does the adapter need to perform a pointer move event
+     *
+     * (see 17.4.3)
+     * @return Time in MS to perform operations
+     */
+    override fun pointerMoveIntervalDuration(): Int = 5 // Default to 5 ms (120 moves per second)
+
+    @Throws(AppiumException::class)
+    override fun sleep(duration: Float) {
+        try {
+            Thread.sleep(Math.round(duration).toLong())
+        } catch (ie: InterruptedException) {
+            throw AppiumException("Could not run 'sleep' method: ${ie.cause}")
+        }
+    }
+
+    /**
+     * Waits for the UI to complete before moving forward
+     */
+    override fun waitForUiThread() {
+        // No-op by default.
+    }
+
+    @Throws(AppiumException::class)
+    override fun sychronousTickActionsComplete() {
+        // No-op by default
+    }
+
+    companion object {
+        private val reentrantLock = ReentrantLock()
+    }
+}

package/espresso-server/app/src/androidTest/java/io/appium/espressoserver/lib/helpers/w3c/adapter/DummyW3CActionAdapter.kt

@@ -0,0 +1,133 @@
+package io.appium.espressoserver.lib.helpers.w3c.adapter
+
+import android.graphics.Point
+
+import java.util.ArrayList
+
+import io.appium.espressoserver.lib.handlers.exceptions.AppiumException
+import io.appium.espressoserver.lib.handlers.exceptions.NoSuchElementException
+import io.appium.espressoserver.lib.handlers.exceptions.StaleElementException
+import io.appium.espressoserver.lib.helpers.Logger
+import io.appium.espressoserver.lib.helpers.w3c.dispatcher.W3CKeyEvent
+import io.appium.espressoserver.lib.helpers.w3c.models.InputSource.PointerType
+import io.appium.espressoserver.lib.helpers.w3c.state.KeyInputState
+import io.appium.espressoserver.lib.helpers.w3c.state.PointerInputState
+
+open class DummyW3CActionAdapter : BaseW3CActionAdapter() {
+
+    // Keep a log of pointer move events so the values can be checked in the unit tests
+    private val pointerMoveEvents = ArrayList<PointerMoveEvent>()
+    override val logger: Logger = DummyLogger()
+
+    override val viewportHeight: Long
+        get() = 400
+
+    override val viewportWidth: Long
+        get() = 200
+
+    class PointerMoveEvent {
+        var sourceId: String? = null
+        var pointerType: PointerType? = null
+        var currentX: Float = 0.toFloat()
+        var currentY: Float = 0.toFloat()
+        var x: Float = 0.toFloat()
+        var y: Float = 0.toFloat()
+        var buttons: Set<Int>? = null
+        var globalKeyInputState: KeyInputState? = null
+    }
+
+    private inner class DummyLogger : Logger {
+        override fun error(vararg messages: Any) {
+            // No-op
+        }
+
+        override fun error(message: String, throwable: Throwable) {
+            // No-op
+        }
+
+        override fun info(vararg messages: Any) {
+            // No-op
+        }
+
+        override fun debug(vararg messages: Any) {
+            // No-op
+        }
+
+        override fun warn(vararg messages: Any) {
+            // No-op
+        }
+    }
+
+    override fun keyDown(keyDownEvent: W3CKeyEvent) {
+        // No-op
+    }
+
+    override fun keyUp(keyUpEvent: W3CKeyEvent) {
+        // No-op
+    }
+
+    @Throws(AppiumException::class)
+    override fun pointerUp(button: Int, sourceId: String, pointerType: PointerType?,
+                       x: Float, y: Float, depressedButtons: Set<Int>,
+                       globalKeyInputState: KeyInputState?) {
+        // No-op
+    }
+
+    @Throws(AppiumException::class)
+    override fun pointerDown(button: Int, sourceId: String, pointerType: PointerType?,
+                         x: Float, y: Float, depressedButtons: Set<Int>,
+                         globalKeyInputState: KeyInputState?) {
+        // No-op
+    }
+
+    override fun pointerCancel(sourceId: String, pointerType: PointerType) {
+        // No-op
+    }
+
+    override fun getPointerMoveDurationMargin(pointerInputState: PointerInputState): Double {
+        return if (pointerInputState.type == PointerType.TOUCH && !pointerInputState.hasPressedButtons()) {
+            // If no buttons are pushed nothing happens, so skip to the end
+            // of the pointer move
+            // e.g.: touch move without pressed buttons is like a finger moving without
+            //      being pressed on the screen
+            1.0
+        } else 0.01
+
+        // Give a margin of error of 1%
+    }
+
+    override fun pointerMove(sourceId: String, pointerType: PointerType?,
+                             currentX: Float, currentY: Float, x: Float, y: Float,
+                             buttons: Set<Int>?, globalKeyInputState: KeyInputState?) {
+        // Add the pointer move event to the logs
+        val pointerMoveEvent = PointerMoveEvent()
+        pointerMoveEvent.apply {
+            this.sourceId = sourceId
+            this.pointerType = pointerType
+            this.currentX = currentX
+            this.currentY = currentY
+            this.x = x
+            this.y = y
+            this.buttons = buttons
+            this.globalKeyInputState = globalKeyInputState
+        }
+        pointerMoveEvents.add(pointerMoveEvent)
+    }
+
+    fun getPointerMoveEvents(): List<PointerMoveEvent> {
+        return pointerMoveEvents
+    }
+
+    @Throws(AppiumException::class)
+    override fun getElementCenterPoint(elementId: String?): Point {
+        when(elementId) {
+            "none" -> throw NoSuchElementException("Could not find element with id: ${elementId}")
+            "stale" -> throw StaleElementException("Element with id ${elementId} no longer exists")
+        }
+
+        val point = Point()
+        point.x = 10
+        point.y = 10
+        return point
+    }
+}