tests/tests/view/src/android/view/cts/VerifyInputEventTest.java - platform/cts - Git at Google

 /*
  * Copyright (C) 2020 The Android Open Source Project
  *
  * Licensed 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 android.view.cts;

 import static android.view.Display.DEFAULT_DISPLAY;
 import static android.view.InputDevice.SOURCE_JOYSTICK;
 import static android.view.KeyEvent.FLAG_CANCELED;
 import static android.view.KeyEvent.KEYCODE_A;
 import static android.view.MotionEvent.FLAG_WINDOW_IS_OBSCURED;
 import static android.view.MotionEvent.FLAG_WINDOW_IS_PARTIALLY_OBSCURED;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;

 import android.app.Instrumentation;
 import android.app.UiAutomation;
 import android.graphics.Point;
 import android.hardware.input.InputManager;
 import android.os.SystemClock;
 import android.view.InputDevice;
 import android.view.InputEvent;
 import android.view.KeyCharacterMap;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.VerifiedInputEvent;
 import android.view.VerifiedKeyEvent;
 import android.view.VerifiedMotionEvent;
 import android.view.View;

 import androidx.test.ext.junit.runners.AndroidJUnit4;
 import androidx.test.filters.SmallTest;
 import androidx.test.platform.app.InstrumentationRegistry;
 import androidx.test.rule.ActivityTestRule;

 import com.android.compatibility.common.util.WindowUtil;

 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;

 import java.util.Arrays;
 import java.util.List;

 /**
  * Test {@link android.hardware.input.InputManager#verifyInputEvent(InputEvent)} functionality.
  */
 @SmallTest
 @RunWith(AndroidJUnit4.class)
 public class VerifyInputEventTest {
     private static final int NANOS_PER_MILLISECOND = 1000000;
     private static final float EPSILON = 0.001f;
     private static final int INJECTED_EVENT_DEVICE_ID = KeyCharacterMap.VIRTUAL_KEYBOARD;

     private InputManager mInputManager;
     private UiAutomation mAutomation;
     private InputEventInterceptTestActivity mActivity;

     @Rule
     public ActivityTestRule<InputEventInterceptTestActivity> mActivityRule =
             new ActivityTestRule<>(InputEventInterceptTestActivity.class);

     @Before
     public void setup() {
         Instrumentation instrumentation = InstrumentationRegistry.getInstrumentation();
         mInputManager = instrumentation.getTargetContext().getSystemService(InputManager.class);
         assertNotNull(mInputManager);
         mAutomation = instrumentation.getUiAutomation();
         mActivity = mActivityRule.getActivity();
         WindowUtil.waitForFocus(mActivity);
     }

     @Test
     public void testKeyEvent() {
         final long downTime = SystemClock.uptimeMillis();
         final int keyCode = KEYCODE_A;
         KeyEvent downEvent = new KeyEvent(downTime, downTime,
                 KeyEvent.ACTION_DOWN, keyCode, 0 /* repeatCount */);
         mAutomation.injectInputEvent(downEvent, true);
         KeyEvent received = waitForKey();
         VerifiedInputEvent verified = mInputManager.verifyInputEvent(received);
         assertNotNull(verified);
         compareKeys(downEvent, verified);

         // Send UP event for consistency
         KeyEvent upEvent = new KeyEvent(downTime, SystemClock.uptimeMillis(),
                 KeyEvent.ACTION_UP, keyCode, 0 /* repeatCount */);
         mAutomation.injectInputEvent(upEvent, true);
         waitForKey();
     }

     /**
      * Try to verify an event that did not come from system, and therefore does not have an hmac
      * set properly.
      * Verification should fail.
      */
     @Test
     public void testKeyEventWithoutHmac() {
         final long downTime = SystemClock.uptimeMillis();
         final int keyCode = KEYCODE_A;
         KeyEvent downEvent = new KeyEvent(downTime, downTime,
                 KeyEvent.ACTION_DOWN, keyCode, 0 /* repeatCount */);
         mAutomation.injectInputEvent(downEvent, true);
         waitForKey(); // we will not be using the received event
         VerifiedInputEvent verified = mInputManager.verifyInputEvent(downEvent);
         assertNull(verified);

         // Send UP event for consistency
         KeyEvent upEvent = new KeyEvent(downTime, SystemClock.uptimeMillis(),
                 KeyEvent.ACTION_UP, keyCode, 0 /* repeatCount */);
         mAutomation.injectInputEvent(upEvent, true);
         waitForKey();
     }

     /**
      * Try to verify an event that came from system, but has been tempered with.
      * Verification should fail.
      */
     @Test
     public void testTamperedKeyEvent() {
         final long downTime = SystemClock.uptimeMillis();
         final int keyCode = KEYCODE_A;
         KeyEvent downEvent = new KeyEvent(downTime, downTime,
                 KeyEvent.ACTION_DOWN, keyCode, 0 /* repeatCount */);
         mAutomation.injectInputEvent(downEvent, true);
         KeyEvent received = waitForKey();
         received.setSource(SOURCE_JOYSTICK); // use the received event, but modify its source
         VerifiedInputEvent verified = mInputManager.verifyInputEvent(received);
         assertNull(verified);

         // Send UP event for consistency
         KeyEvent upEvent = new KeyEvent(downTime, SystemClock.uptimeMillis(),
                 KeyEvent.ACTION_UP, keyCode, 0 /* repeatCount */);
         mAutomation.injectInputEvent(upEvent, true);
         waitForKey();
     }

     @Test
     public void testMotionEvent() {
         final View view = mActivity.getWindow().getDecorView();
         final Point point = getViewCenterOnScreen(view);
         final long downTime = SystemClock.uptimeMillis();
         MotionEvent downEvent = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN,
                 point.x, point.y, 0 /*metaState*/);
         downEvent.setSource(InputDevice.SOURCE_TOUCHSCREEN);
         mAutomation.injectInputEvent(downEvent, true);
         MotionEvent received = waitForMotion();
         VerifiedInputEvent verified = mInputManager.verifyInputEvent(received);
         assertNotNull(verified);

         compareMotions(downEvent, verified);

         // Send UP event for consistency
         MotionEvent upEvent = MotionEvent.obtain(downTime, SystemClock.uptimeMillis(),
                 MotionEvent.ACTION_UP, point.x, point.y, 0 /*metaState*/);
         upEvent.setSource(InputDevice.SOURCE_TOUCHSCREEN);
         mAutomation.injectInputEvent(upEvent, true);
         waitForMotion();
     }

     /**
      * Try to verify an event that did not come from system, and therefore does not have an hmac
      * set properly.
      * Verification should fail.
      */
     @Test
     public void testMotionEventWithoutHmac() {
         final View view = mActivity.getWindow().getDecorView();
         final Point point = getViewCenterOnScreen(view);
         final long downTime = SystemClock.uptimeMillis();
         MotionEvent downEvent = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN,
                 point.x, point.y, 0 /*metaState*/);
         downEvent.setSource(InputDevice.SOURCE_TOUCHSCREEN);
         mAutomation.injectInputEvent(downEvent, true);
         waitForMotion(); // we will not be using the received event
         VerifiedInputEvent verified = mInputManager.verifyInputEvent(downEvent);
         assertNull(verified);

         // Send UP event for consistency
         MotionEvent upEvent = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_UP,
                 point.x, point.y, 0 /*metaState*/);
         upEvent.setSource(InputDevice.SOURCE_TOUCHSCREEN);
         mAutomation.injectInputEvent(upEvent, true);
         waitForMotion();
     }

     /**
      * Try to verify an event that came from system, but has been tempered with.
      * Verification should fail.
      */
     @Test
     public void testTamperedMotionEvent() {
         final View view = mActivity.getWindow().getDecorView();
         final Point point = getViewCenterOnScreen(view);
         final long downTime = SystemClock.uptimeMillis();
         MotionEvent downEvent = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN,
                 point.x, point.y, 0 /*metaState*/);
         downEvent.setSource(InputDevice.SOURCE_TOUCHSCREEN);
         mAutomation.injectInputEvent(downEvent, true);
         MotionEvent received = waitForMotion();
         // use the received event, by modify its action
         received.setAction(MotionEvent.ACTION_CANCEL);
         VerifiedInputEvent verified = mInputManager.verifyInputEvent(received);
         assertNull(verified);

         // Send UP event for consistency
         MotionEvent upEvent = MotionEvent.obtain(downTime, SystemClock.uptimeMillis(),
                 MotionEvent.ACTION_UP, point.x, point.y, 0 /*metaState*/);
         upEvent.setSource(InputDevice.SOURCE_TOUCHSCREEN);
         mAutomation.injectInputEvent(upEvent, true);
         waitForMotion();
     }

     /**
      * Ensure that injected key events that contain a real device id get injected as virtual
      * device events, to prevent misrepresentation of actual hardware.
      * The verified events should contain the virtual device id, which is consistent with what the
      * app receives.
      */
     @Test
     public void testDeviceIdBecomesVirtualForInjectedKeys() {
         final long downTime = SystemClock.uptimeMillis();
         KeyEvent downEvent = new KeyEvent(downTime, downTime, KeyEvent.ACTION_DOWN,
                 KeyEvent.KEYCODE_A, 0 /*repeat*/, 0 /*metaState*/,
                 1/*deviceId*/, 0 /*scanCode*/);
         mAutomation.injectInputEvent(downEvent, true);
         KeyEvent received = waitForKey();
         assertEquals(INJECTED_EVENT_DEVICE_ID, received.getDeviceId());

         // This event can still be verified, however.
         VerifiedInputEvent verified = mInputManager.verifyInputEvent(received);
         assertEquals(INJECTED_EVENT_DEVICE_ID, verified.getDeviceId());

         // Send UP event for consistency
         KeyEvent upEvent = new KeyEvent(downTime, SystemClock.uptimeMillis(), KeyEvent.ACTION_UP,
                 KeyEvent.KEYCODE_A, 0 /*repeat*/, 0 /*metaState*/,
                 1/*deviceId*/, 0 /*scanCode*/);
         mAutomation.injectInputEvent(upEvent, true);
         waitForKey();
     }

     /**
      * Ensure that injected motion events that contain a real device id get injected as virtual
      * device events, to prevent misrepresentation of actual hardware.
      * The verified events should contain the virtual device id, which is consistent with what the
      * app receives.
      */
     @Test
     public void testDeviceIdBecomesVirtualForInjectedMotions() {
         final View view = mActivity.getWindow().getDecorView();
         final Point point = getViewCenterOnScreen(view);
         final long downTime = SystemClock.uptimeMillis();
         MotionEvent downEvent = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN,
                 point.x, point.y, 1 /*pressure*/, 1 /*size*/, 0 /*metaState*/,
                 0 /*xPrecision*/, 0 /*yPrecision*/, 1 /*deviceId*/, 0 /*edgeFlags*/);
         downEvent.setSource(InputDevice.SOURCE_TOUCHSCREEN);
         mAutomation.injectInputEvent(downEvent, true);
         MotionEvent received = waitForMotion();
         assertEquals(INJECTED_EVENT_DEVICE_ID, received.getDeviceId());

         // This event can still be verified, however.
         VerifiedInputEvent verified = mInputManager.verifyInputEvent(received);
         assertEquals(INJECTED_EVENT_DEVICE_ID, verified.getDeviceId());

         // Send UP event for consistency
         MotionEvent upEvent = MotionEvent.obtain(downTime, SystemClock.uptimeMillis(),
                 MotionEvent.ACTION_UP, point.x, point.y, 0 /*pressure*/, 1 /*size*/,
                 0 /*metaState*/, 0 /*xPrecision*/, 0 /*yPrecision*/,
                 1 /*deviceId*/, 0 /*edgeFlags*/);
         upEvent.setSource(InputDevice.SOURCE_TOUCHSCREEN);
         mAutomation.injectInputEvent(upEvent, true);
         waitForMotion();
     }

     private static Point getViewCenterOnScreen(View view) {
         final int[] location = new int[2];
         view.getLocationOnScreen(location);
         final int width = view.getWidth();
         final int height = view.getHeight();

         return new Point(location[0] + width / 2, location[1] + height / 2);
     }

     private KeyEvent waitForKey() {
         return mActivity.mKeyEvents.poll();
     }

     private MotionEvent waitForMotion() {
         return mActivity.mMotionEvents.poll();
     }

     private static void compareKeys(KeyEvent keyEvent, VerifiedInputEvent verified) {
         assertEquals(INJECTED_EVENT_DEVICE_ID, verified.getDeviceId());
         assertEquals(keyEvent.getEventTime() * NANOS_PER_MILLISECOND,
                 verified.getEventTimeNanos());
         assertEquals(keyEvent.getSource(), verified.getSource());
         assertEquals(DEFAULT_DISPLAY, verified.getDisplayId());

         assertTrue(verified instanceof VerifiedKeyEvent);
         VerifiedKeyEvent verifiedKey = (VerifiedKeyEvent) verified;

         assertEquals(keyEvent.getAction(), verifiedKey.getAction());
         assertEquals(keyEvent.getDownTime() * NANOS_PER_MILLISECOND,
                 verifiedKey.getDownTimeNanos());
         compareKeyFlags(keyEvent.getFlags(), verifiedKey);
         assertEquals(keyEvent.getKeyCode(), verifiedKey.getKeyCode());
         assertEquals(keyEvent.getScanCode(), verifiedKey.getScanCode());
         assertEquals(keyEvent.getMetaState(), verifiedKey.getMetaState());
         assertEquals(keyEvent.getRepeatCount(), verifiedKey.getRepeatCount());
     }

     private static void compareMotions(MotionEvent motionEvent, VerifiedInputEvent verified) {
         assertEquals(INJECTED_EVENT_DEVICE_ID, verified.getDeviceId());
         assertEquals(motionEvent.getEventTime() * NANOS_PER_MILLISECOND,
                 verified.getEventTimeNanos());
         assertEquals(motionEvent.getSource(), verified.getSource());
         assertEquals(DEFAULT_DISPLAY, verified.getDisplayId());

         assertTrue(verified instanceof VerifiedMotionEvent);
         VerifiedMotionEvent verifiedMotion = (VerifiedMotionEvent) verified;

         assertEquals(motionEvent.getRawX(), verifiedMotion.getRawX(), EPSILON);
         assertEquals(motionEvent.getRawY(), verifiedMotion.getRawY(), EPSILON);
         assertEquals(motionEvent.getActionMasked(), verifiedMotion.getActionMasked());
         assertEquals(motionEvent.getDownTime() * NANOS_PER_MILLISECOND,
                 verifiedMotion.getDownTimeNanos());
         compareMotionFlags(motionEvent.getFlags(), verifiedMotion);
         assertEquals(motionEvent.getMetaState(), verifiedMotion.getMetaState());
         assertEquals(motionEvent.getButtonState(), verifiedMotion.getButtonState());
     }

     private static void compareKeyFlags(int expectedFlags, VerifiedKeyEvent verified) {
         final List<Integer> verifiedKeyFlags = Arrays.asList(
                 FLAG_CANCELED,
                 KeyEvent.FLAG_IS_ACCESSIBILITY_EVENT);
         // Separately check the value of verifiable flags
         for (int flag : verifiedKeyFlags) {
             assertFlag(expectedFlags, flag, verified);
         }
         // All other flags should be null, because they are not verifiable
         for (int i = 0; i < Integer.SIZE; i++) {
             int flag = 1 << i;
             if (verifiedKeyFlags.contains(flag)) {
                 continue;
             }
             assertNull(verified.getFlag(flag));
         }
     }

     private static void compareMotionFlags(int expectedFlags, VerifiedMotionEvent verified) {
         final List<Integer> verifiedMotionFlags = Arrays.asList(
                 FLAG_WINDOW_IS_OBSCURED,
                 FLAG_WINDOW_IS_PARTIALLY_OBSCURED,
                 MotionEvent.FLAG_IS_ACCESSIBILITY_EVENT);
         // Separately check the value of verifiable flags
         for (int flag : verifiedMotionFlags) {
             assertFlag(expectedFlags, flag, verified);
         }
         // All other flags should be null, because they are not verifiable
         for (int i = 0; i < Integer.SIZE; i++) {
             int flag = 1 << i;
             if (verifiedMotionFlags.contains(flag)) {
                 continue;
             }
             assertNull(verified.getFlag(flag));
         }
     }

     private static void assertFlag(int expectedFlags, int flag, VerifiedInputEvent verified) {
         final Boolean actual;
         if (verified instanceof VerifiedKeyEvent) {
             actual = ((VerifiedKeyEvent) verified).getFlag(flag);
         } else if (verified instanceof VerifiedMotionEvent) {
             actual = ((VerifiedMotionEvent) verified).getFlag(flag);
         } else {
             fail("Unknown type of VerifiedInputEvent");
             actual = null;
         }
         assertNotNull(actual);
         boolean flagValue = (expectedFlags & flag) != 0;
         assertEquals(flagValue, actual);
     }
 }
	/*
	* Copyright (C) 2020 The Android Open Source Project
	*
	* Licensed 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 android.view.cts;

	import static android.view.Display.DEFAULT_DISPLAY;
	import static android.view.InputDevice.SOURCE_JOYSTICK;
	import static android.view.KeyEvent.FLAG_CANCELED;
	import static android.view.KeyEvent.KEYCODE_A;
	import static android.view.MotionEvent.FLAG_WINDOW_IS_OBSCURED;
	import static android.view.MotionEvent.FLAG_WINDOW_IS_PARTIALLY_OBSCURED;

	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertNotNull;
	import static org.junit.Assert.assertNull;
	import static org.junit.Assert.assertTrue;
	import static org.junit.Assert.fail;

	import android.app.Instrumentation;
	import android.app.UiAutomation;
	import android.graphics.Point;
	import android.hardware.input.InputManager;
	import android.os.SystemClock;
	import android.view.InputDevice;
	import android.view.InputEvent;
	import android.view.KeyCharacterMap;
	import android.view.KeyEvent;
	import android.view.MotionEvent;
	import android.view.VerifiedInputEvent;
	import android.view.VerifiedKeyEvent;
	import android.view.VerifiedMotionEvent;
	import android.view.View;

	import androidx.test.ext.junit.runners.AndroidJUnit4;
	import androidx.test.filters.SmallTest;
	import androidx.test.platform.app.InstrumentationRegistry;
	import androidx.test.rule.ActivityTestRule;

	import com.android.compatibility.common.util.WindowUtil;

	import org.junit.Before;
	import org.junit.Rule;
	import org.junit.Test;
	import org.junit.runner.RunWith;

	import java.util.Arrays;
	import java.util.List;

	/**
	* Test {@link android.hardware.input.InputManager#verifyInputEvent(InputEvent)} functionality.
	*/
	@SmallTest
	@RunWith(AndroidJUnit4.class)
	public class VerifyInputEventTest {
	private static final int NANOS_PER_MILLISECOND = 1000000;
	private static final float EPSILON = 0.001f;
	private static final int INJECTED_EVENT_DEVICE_ID = KeyCharacterMap.VIRTUAL_KEYBOARD;

	private InputManager mInputManager;
	private UiAutomation mAutomation;
	private InputEventInterceptTestActivity mActivity;

	@Rule
	public ActivityTestRule<InputEventInterceptTestActivity> mActivityRule =
	new ActivityTestRule<>(InputEventInterceptTestActivity.class);

	@Before
	public void setup() {
	Instrumentation instrumentation = InstrumentationRegistry.getInstrumentation();
	mInputManager = instrumentation.getTargetContext().getSystemService(InputManager.class);
	assertNotNull(mInputManager);
	mAutomation = instrumentation.getUiAutomation();
	mActivity = mActivityRule.getActivity();
	WindowUtil.waitForFocus(mActivity);
	}

	@Test
	public void testKeyEvent() {
	final long downTime = SystemClock.uptimeMillis();
	final int keyCode = KEYCODE_A;
	KeyEvent downEvent = new KeyEvent(downTime, downTime,
	KeyEvent.ACTION_DOWN, keyCode, 0 /* repeatCount */);
	mAutomation.injectInputEvent(downEvent, true);
	KeyEvent received = waitForKey();
	VerifiedInputEvent verified = mInputManager.verifyInputEvent(received);
	assertNotNull(verified);
	compareKeys(downEvent, verified);

	// Send UP event for consistency
	KeyEvent upEvent = new KeyEvent(downTime, SystemClock.uptimeMillis(),
	KeyEvent.ACTION_UP, keyCode, 0 /* repeatCount */);
	mAutomation.injectInputEvent(upEvent, true);
	waitForKey();
	}

	/**
	* Try to verify an event that did not come from system, and therefore does not have an hmac
	* set properly.
	* Verification should fail.
	*/
	@Test
	public void testKeyEventWithoutHmac() {
	final long downTime = SystemClock.uptimeMillis();
	final int keyCode = KEYCODE_A;
	KeyEvent downEvent = new KeyEvent(downTime, downTime,
	KeyEvent.ACTION_DOWN, keyCode, 0 /* repeatCount */);
	mAutomation.injectInputEvent(downEvent, true);
	waitForKey(); // we will not be using the received event
	VerifiedInputEvent verified = mInputManager.verifyInputEvent(downEvent);
	assertNull(verified);

	// Send UP event for consistency
	KeyEvent upEvent = new KeyEvent(downTime, SystemClock.uptimeMillis(),
	KeyEvent.ACTION_UP, keyCode, 0 /* repeatCount */);
	mAutomation.injectInputEvent(upEvent, true);
	waitForKey();
	}

	/**
	* Try to verify an event that came from system, but has been tempered with.
	* Verification should fail.
	*/
	@Test
	public void testTamperedKeyEvent() {
	final long downTime = SystemClock.uptimeMillis();
	final int keyCode = KEYCODE_A;
	KeyEvent downEvent = new KeyEvent(downTime, downTime,
	KeyEvent.ACTION_DOWN, keyCode, 0 /* repeatCount */);
	mAutomation.injectInputEvent(downEvent, true);
	KeyEvent received = waitForKey();
	received.setSource(SOURCE_JOYSTICK); // use the received event, but modify its source
	VerifiedInputEvent verified = mInputManager.verifyInputEvent(received);
	assertNull(verified);

	// Send UP event for consistency
	KeyEvent upEvent = new KeyEvent(downTime, SystemClock.uptimeMillis(),
	KeyEvent.ACTION_UP, keyCode, 0 /* repeatCount */);
	mAutomation.injectInputEvent(upEvent, true);
	waitForKey();
	}

	@Test
	public void testMotionEvent() {
	final View view = mActivity.getWindow().getDecorView();
	final Point point = getViewCenterOnScreen(view);
	final long downTime = SystemClock.uptimeMillis();
	MotionEvent downEvent = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN,
	point.x, point.y, 0 /metaState/);
	downEvent.setSource(InputDevice.SOURCE_TOUCHSCREEN);
	mAutomation.injectInputEvent(downEvent, true);
	MotionEvent received = waitForMotion();
	VerifiedInputEvent verified = mInputManager.verifyInputEvent(received);
	assertNotNull(verified);

	compareMotions(downEvent, verified);

	// Send UP event for consistency
	MotionEvent upEvent = MotionEvent.obtain(downTime, SystemClock.uptimeMillis(),
	MotionEvent.ACTION_UP, point.x, point.y, 0 /metaState/);
	upEvent.setSource(InputDevice.SOURCE_TOUCHSCREEN);
	mAutomation.injectInputEvent(upEvent, true);
	waitForMotion();
	}

	/**
	* Try to verify an event that did not come from system, and therefore does not have an hmac
	* set properly.
	* Verification should fail.
	*/
	@Test
	public void testMotionEventWithoutHmac() {
	final View view = mActivity.getWindow().getDecorView();
	final Point point = getViewCenterOnScreen(view);
	final long downTime = SystemClock.uptimeMillis();
	MotionEvent downEvent = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN,
	point.x, point.y, 0 /metaState/);
	downEvent.setSource(InputDevice.SOURCE_TOUCHSCREEN);
	mAutomation.injectInputEvent(downEvent, true);
	waitForMotion(); // we will not be using the received event
	VerifiedInputEvent verified = mInputManager.verifyInputEvent(downEvent);
	assertNull(verified);

	// Send UP event for consistency
	MotionEvent upEvent = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_UP,
	point.x, point.y, 0 /metaState/);
	upEvent.setSource(InputDevice.SOURCE_TOUCHSCREEN);
	mAutomation.injectInputEvent(upEvent, true);
	waitForMotion();
	}

	/**
	* Try to verify an event that came from system, but has been tempered with.
	* Verification should fail.
	*/
	@Test
	public void testTamperedMotionEvent() {
	final View view = mActivity.getWindow().getDecorView();
	final Point point = getViewCenterOnScreen(view);
	final long downTime = SystemClock.uptimeMillis();
	MotionEvent downEvent = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN,
	point.x, point.y, 0 /metaState/);
	downEvent.setSource(InputDevice.SOURCE_TOUCHSCREEN);
	mAutomation.injectInputEvent(downEvent, true);
	MotionEvent received = waitForMotion();
	// use the received event, by modify its action
	received.setAction(MotionEvent.ACTION_CANCEL);
	VerifiedInputEvent verified = mInputManager.verifyInputEvent(received);
	assertNull(verified);

	// Send UP event for consistency
	MotionEvent upEvent = MotionEvent.obtain(downTime, SystemClock.uptimeMillis(),
	MotionEvent.ACTION_UP, point.x, point.y, 0 /metaState/);
	upEvent.setSource(InputDevice.SOURCE_TOUCHSCREEN);
	mAutomation.injectInputEvent(upEvent, true);
	waitForMotion();
	}

	/**
	* Ensure that injected key events that contain a real device id get injected as virtual
	* device events, to prevent misrepresentation of actual hardware.
	* The verified events should contain the virtual device id, which is consistent with what the
	* app receives.
	*/
	@Test
	public void testDeviceIdBecomesVirtualForInjectedKeys() {
	final long downTime = SystemClock.uptimeMillis();
	KeyEvent downEvent = new KeyEvent(downTime, downTime, KeyEvent.ACTION_DOWN,
	KeyEvent.KEYCODE_A, 0 /repeat/, 0 /metaState/,
	1/deviceId/, 0 /scanCode/);
	mAutomation.injectInputEvent(downEvent, true);
	KeyEvent received = waitForKey();
	assertEquals(INJECTED_EVENT_DEVICE_ID, received.getDeviceId());

	// This event can still be verified, however.
	VerifiedInputEvent verified = mInputManager.verifyInputEvent(received);
	assertEquals(INJECTED_EVENT_DEVICE_ID, verified.getDeviceId());

	// Send UP event for consistency
	KeyEvent upEvent = new KeyEvent(downTime, SystemClock.uptimeMillis(), KeyEvent.ACTION_UP,
	KeyEvent.KEYCODE_A, 0 /repeat/, 0 /metaState/,
	1/deviceId/, 0 /scanCode/);
	mAutomation.injectInputEvent(upEvent, true);
	waitForKey();
	}

	/**
	* Ensure that injected motion events that contain a real device id get injected as virtual
	* device events, to prevent misrepresentation of actual hardware.
	* The verified events should contain the virtual device id, which is consistent with what the
	* app receives.
	*/
	@Test
	public void testDeviceIdBecomesVirtualForInjectedMotions() {
	final View view = mActivity.getWindow().getDecorView();
	final Point point = getViewCenterOnScreen(view);
	final long downTime = SystemClock.uptimeMillis();
	MotionEvent downEvent = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN,
	point.x, point.y, 1 /pressure/, 1 /size/, 0 /metaState/,
	0 /xPrecision/, 0 /yPrecision/, 1 /deviceId/, 0 /edgeFlags/);
	downEvent.setSource(InputDevice.SOURCE_TOUCHSCREEN);
	mAutomation.injectInputEvent(downEvent, true);
	MotionEvent received = waitForMotion();
	assertEquals(INJECTED_EVENT_DEVICE_ID, received.getDeviceId());

	// This event can still be verified, however.
	VerifiedInputEvent verified = mInputManager.verifyInputEvent(received);
	assertEquals(INJECTED_EVENT_DEVICE_ID, verified.getDeviceId());

	// Send UP event for consistency
	MotionEvent upEvent = MotionEvent.obtain(downTime, SystemClock.uptimeMillis(),
	MotionEvent.ACTION_UP, point.x, point.y, 0 /pressure/, 1 /size/,
	0 /metaState/, 0 /xPrecision/, 0 /yPrecision/,
	1 /deviceId/, 0 /edgeFlags/);
	upEvent.setSource(InputDevice.SOURCE_TOUCHSCREEN);
	mAutomation.injectInputEvent(upEvent, true);
	waitForMotion();
	}

	private static Point getViewCenterOnScreen(View view) {
	final int[] location = new int[2];
	view.getLocationOnScreen(location);
	final int width = view.getWidth();
	final int height = view.getHeight();

	return new Point(location[0] + width / 2, location[1] + height / 2);
	}

	private KeyEvent waitForKey() {
	return mActivity.mKeyEvents.poll();
	}

	private MotionEvent waitForMotion() {
	return mActivity.mMotionEvents.poll();
	}

	private static void compareKeys(KeyEvent keyEvent, VerifiedInputEvent verified) {
	assertEquals(INJECTED_EVENT_DEVICE_ID, verified.getDeviceId());
	assertEquals(keyEvent.getEventTime() * NANOS_PER_MILLISECOND,
	verified.getEventTimeNanos());
	assertEquals(keyEvent.getSource(), verified.getSource());
	assertEquals(DEFAULT_DISPLAY, verified.getDisplayId());

	assertTrue(verified instanceof VerifiedKeyEvent);
	VerifiedKeyEvent verifiedKey = (VerifiedKeyEvent) verified;

	assertEquals(keyEvent.getAction(), verifiedKey.getAction());
	assertEquals(keyEvent.getDownTime() * NANOS_PER_MILLISECOND,
	verifiedKey.getDownTimeNanos());
	compareKeyFlags(keyEvent.getFlags(), verifiedKey);
	assertEquals(keyEvent.getKeyCode(), verifiedKey.getKeyCode());
	assertEquals(keyEvent.getScanCode(), verifiedKey.getScanCode());
	assertEquals(keyEvent.getMetaState(), verifiedKey.getMetaState());
	assertEquals(keyEvent.getRepeatCount(), verifiedKey.getRepeatCount());
	}

	private static void compareMotions(MotionEvent motionEvent, VerifiedInputEvent verified) {
	assertEquals(INJECTED_EVENT_DEVICE_ID, verified.getDeviceId());
	assertEquals(motionEvent.getEventTime() * NANOS_PER_MILLISECOND,
	verified.getEventTimeNanos());
	assertEquals(motionEvent.getSource(), verified.getSource());
	assertEquals(DEFAULT_DISPLAY, verified.getDisplayId());

	assertTrue(verified instanceof VerifiedMotionEvent);
	VerifiedMotionEvent verifiedMotion = (VerifiedMotionEvent) verified;

	assertEquals(motionEvent.getRawX(), verifiedMotion.getRawX(), EPSILON);
	assertEquals(motionEvent.getRawY(), verifiedMotion.getRawY(), EPSILON);
	assertEquals(motionEvent.getActionMasked(), verifiedMotion.getActionMasked());
	assertEquals(motionEvent.getDownTime() * NANOS_PER_MILLISECOND,
	verifiedMotion.getDownTimeNanos());
	compareMotionFlags(motionEvent.getFlags(), verifiedMotion);
	assertEquals(motionEvent.getMetaState(), verifiedMotion.getMetaState());
	assertEquals(motionEvent.getButtonState(), verifiedMotion.getButtonState());
	}

	private static void compareKeyFlags(int expectedFlags, VerifiedKeyEvent verified) {
	final List<Integer> verifiedKeyFlags = Arrays.asList(
	FLAG_CANCELED,
	KeyEvent.FLAG_IS_ACCESSIBILITY_EVENT);
	// Separately check the value of verifiable flags
	for (int flag : verifiedKeyFlags) {
	assertFlag(expectedFlags, flag, verified);
	}
	// All other flags should be null, because they are not verifiable
	for (int i = 0; i < Integer.SIZE; i++) {
	int flag = 1 << i;
	if (verifiedKeyFlags.contains(flag)) {
	continue;
	}
	assertNull(verified.getFlag(flag));
	}
	}

	private static void compareMotionFlags(int expectedFlags, VerifiedMotionEvent verified) {
	final List<Integer> verifiedMotionFlags = Arrays.asList(
	FLAG_WINDOW_IS_OBSCURED,
	FLAG_WINDOW_IS_PARTIALLY_OBSCURED,
	MotionEvent.FLAG_IS_ACCESSIBILITY_EVENT);
	// Separately check the value of verifiable flags
	for (int flag : verifiedMotionFlags) {
	assertFlag(expectedFlags, flag, verified);
	}
	// All other flags should be null, because they are not verifiable
	for (int i = 0; i < Integer.SIZE; i++) {
	int flag = 1 << i;
	if (verifiedMotionFlags.contains(flag)) {
	continue;
	}
	assertNull(verified.getFlag(flag));
	}
	}

	private static void assertFlag(int expectedFlags, int flag, VerifiedInputEvent verified) {
	final Boolean actual;
	if (verified instanceof VerifiedKeyEvent) {
	actual = ((VerifiedKeyEvent) verified).getFlag(flag);
	} else if (verified instanceof VerifiedMotionEvent) {
	actual = ((VerifiedMotionEvent) verified).getFlag(flag);
	} else {
	fail("Unknown type of VerifiedInputEvent");
	actual = null;
	}
	assertNotNull(actual);
	boolean flagValue = (expectedFlags & flag) != 0;
	assertEquals(flagValue, actual);
	}
	}