Merge "Improvements on KeyEventTest." (dc6ec7e8) · Commits · e / os / android_frameworks_base

core/tests/coretests/src/android/view/KeyEventTest.java

+156 −52

Original line number	Diff line number	Diff line
		@@ -18,8 +18,8 @@ package android.view;

		import static android.view.Display.INVALID_DISPLAY;

		import static org.junit.Assert.assertEquals;
		import static org.junit.Assert.assertFalse;
		import static com.google.common.truth.Truth.assertThat;
		import static com.google.common.truth.Truth.assertWithMessage;

		import android.os.Parcel;
		import android.platform.test.annotations.Presubmit;
		@@ -27,6 +27,9 @@ import android.platform.test.annotations.Presubmit;
		import androidx.test.ext.junit.runners.AndroidJUnit4;
		import androidx.test.filters.SmallTest;

		import com.google.common.truth.Expect;

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

		@@ -36,7 +39,7 @@ import java.util.Set;
		@SmallTest
		@RunWith(AndroidJUnit4.class)
		@Presubmit
		public class KeyEventTest {
		public final class KeyEventTest {

		private static final int DOWN_TIME = 50;
		private static final long EVENT_TIME = 100;
		@@ -52,22 +55,14 @@ public class KeyEventTest {

		private static final int ID_SOURCE_MASK = 0x3 << 30;

		@Rule public final Expect expect = Expect.create();

		@Test
		public void testObtain() {
		KeyEvent keyEvent = KeyEvent.obtain(DOWN_TIME, EVENT_TIME, ACTION, KEYCODE, REPEAT,
		METASTATE, DEVICE_ID, SCAN_CODE, FLAGS, SOURCE, CHARACTERS);
		assertEquals(DOWN_TIME, keyEvent.getDownTime());
		assertEquals(EVENT_TIME, keyEvent.getEventTime());
		assertEquals(ACTION, keyEvent.getAction());
		assertEquals(KEYCODE, keyEvent.getKeyCode());
		assertEquals(REPEAT, keyEvent.getRepeatCount());
		assertEquals(METASTATE, keyEvent.getMetaState());
		assertEquals(DEVICE_ID, keyEvent.getDeviceId());
		assertEquals(SCAN_CODE, keyEvent.getScanCode());
		assertEquals(FLAGS, keyEvent.getFlags());
		assertEquals(SOURCE, keyEvent.getSource());
		assertEquals(INVALID_DISPLAY, keyEvent.getDisplayId());
		assertEquals(CHARACTERS, keyEvent.getCharacters());

		assertHasDefaultFields(keyEvent, INVALID_DISPLAY);
		}

		@Test
		@@ -75,6 +70,7 @@ public class KeyEventTest {
		KeyEvent keyEvent = KeyEvent.obtain(DOWN_TIME, EVENT_TIME, ACTION, KEYCODE, REPEAT,
		METASTATE, DEVICE_ID, SCAN_CODE, FLAGS, SOURCE, CHARACTERS);
		KeyEvent keyEvent2 = KeyEvent.obtain(keyEvent);

		compareKeys(keyEvent, keyEvent2);
		}

		@@ -83,18 +79,8 @@ public class KeyEventTest {
		final int displayId = 5;
		KeyEvent keyEvent = KeyEvent.obtain(DOWN_TIME, EVENT_TIME, ACTION, KEYCODE, REPEAT,
		METASTATE, DEVICE_ID, SCAN_CODE, FLAGS, SOURCE, displayId, CHARACTERS);
		assertEquals(DOWN_TIME, keyEvent.getDownTime());
		assertEquals(EVENT_TIME, keyEvent.getEventTime());
		assertEquals(ACTION, keyEvent.getAction());
		assertEquals(KEYCODE, keyEvent.getKeyCode());
		assertEquals(REPEAT, keyEvent.getRepeatCount());
		assertEquals(METASTATE, keyEvent.getMetaState());
		assertEquals(DEVICE_ID, keyEvent.getDeviceId());
		assertEquals(SCAN_CODE, keyEvent.getScanCode());
		assertEquals(FLAGS, keyEvent.getFlags());
		assertEquals(SOURCE, keyEvent.getSource());
		assertEquals(displayId, keyEvent.getDisplayId());
		assertEquals(CHARACTERS, keyEvent.getCharacters());

		assertHasDefaultFields(keyEvent, displayId);
		}

		/**
		@@ -109,8 +95,8 @@ public class KeyEventTest {
		for (int i = 0; i < 500; ++i) {
		KeyEvent keyEvent = KeyEvent.obtain(DOWN_TIME, EVENT_TIME, ACTION, KEYCODE, REPEAT,
		METASTATE, DEVICE_ID, SCAN_CODE, FLAGS, SOURCE, CHARACTERS);
		assertFalse("Found duplicate ID in round " + i,
		set.contains(keyEvent.getId()));
		assertWithMessage("event IDs (event generated on round %s: %s)", i, keyEvent)
		.that(set).doesNotContain(keyEvent.getId());
		set.add(keyEvent.getSequenceNumber());
		}
		}
		@@ -120,8 +106,8 @@ public class KeyEventTest {
		Set<Integer> set = new HashSet<>();
		for (int i = 0; i < 500; ++i) {
		KeyEvent keyEvent = new KeyEvent(DOWN_TIME, EVENT_TIME, ACTION, KEYCODE, REPEAT);
		assertFalse("Found duplicate sequence number in round " + i,
		set.contains(keyEvent.getId()));
		assertWithMessage("sequence numbers (event generated on round %s: %s)", i, keyEvent)
		.that(set).doesNotContain(keyEvent.getSequenceNumber());
		set.add(keyEvent.getSequenceNumber());
		}
		}
		@@ -131,7 +117,7 @@ public class KeyEventTest {
		for (int i = 0; i < 500; ++i) {
		KeyEvent keyEvent = KeyEvent.obtain(DOWN_TIME, EVENT_TIME, ACTION, KEYCODE, REPEAT,
		METASTATE, DEVICE_ID, SCAN_CODE, FLAGS, SOURCE, CHARACTERS);
		assertEquals(0x3 << 30, ID_SOURCE_MASK & keyEvent.getId());
		assertThat((ID_SOURCE_MASK & keyEvent.getId())).isEqualTo((0x3 << 30));
		}
		}

		@@ -139,48 +125,166 @@ public class KeyEventTest {
		public void testConstructorGeneratesIdWithRightSource() {
		for (int i = 0; i < 500; ++i) {
		KeyEvent keyEvent = new KeyEvent(DOWN_TIME, EVENT_TIME, ACTION, KEYCODE, REPEAT);
		assertEquals(0x3 << 30, ID_SOURCE_MASK & keyEvent.getId());
		assertThat((ID_SOURCE_MASK & keyEvent.getId())).isEqualTo((0x3 << 30));
		}
		}

		@Test
		public void testParcelUnparcel() {
		KeyEvent key1 = createKey();
		KeyEvent key2;

		Parcel parcel = Parcel.obtain();
		key1.writeToParcel(parcel, 0 /flags/);
		try {
		key1.writeToParcel(parcel, /* flags= */ 0);
		parcel.setDataPosition(0);

		KeyEvent key2 = KeyEvent.CREATOR.createFromParcel(parcel);
		key2 = KeyEvent.CREATOR.createFromParcel(parcel);
		} finally {
		parcel.recycle();
		}

		compareKeys(key1, key2);
		}

		@Test
		public void testConstructor() {
		public void testCopyConstructor() {
		KeyEvent key1 = createKey();
		KeyEvent key2 = new KeyEvent(key1);

		compareKeys(key1, key2);
		}

		@Test
		public void testConstructorWith10Args() {
		KeyEvent key = new KeyEvent(DOWN_TIME, EVENT_TIME, ACTION, KEYCODE, REPEAT, METASTATE,
		DEVICE_ID, SCAN_CODE, FLAGS, SOURCE);

		assertKeyEventFields(key, DOWN_TIME, EVENT_TIME, ACTION, KEYCODE, REPEAT, METASTATE,
		DEVICE_ID, SCAN_CODE, FLAGS, SOURCE, INVALID_DISPLAY, CHARACTERS);
		}

		@Test
		public void testConstructorWith9Args() {
		KeyEvent key = new KeyEvent(DOWN_TIME, EVENT_TIME, ACTION, KEYCODE, REPEAT, METASTATE,
		DEVICE_ID, SCAN_CODE, FLAGS);

		assertKeyEventFields(key, DOWN_TIME, EVENT_TIME, ACTION, KEYCODE, REPEAT, METASTATE,
		DEVICE_ID, SCAN_CODE, FLAGS, /* source= / 0, / displayId= */ 0,
		CHARACTERS);
		}

		@Test
		public void testConstructorWith8Args() {
		KeyEvent key = new KeyEvent(DOWN_TIME, EVENT_TIME, ACTION, KEYCODE, REPEAT, METASTATE,
		DEVICE_ID, SCAN_CODE);

		assertKeyEventFields(key, DOWN_TIME, EVENT_TIME, ACTION, KEYCODE, REPEAT, METASTATE,
		DEVICE_ID, SCAN_CODE, /* flags= / 0, / source= / 0, / displayId= */ 0,
		CHARACTERS);
		}

		@Test
		public void testConstructorWith6Args() {
		KeyEvent key = new KeyEvent(DOWN_TIME, EVENT_TIME, ACTION, KEYCODE, REPEAT, METASTATE);

		assertKeyEventFields(key, DOWN_TIME, EVENT_TIME, ACTION, KEYCODE, REPEAT, METASTATE,
		KeyCharacterMap.VIRTUAL_KEYBOARD, /* scanCode= / 0, / flags= */ 0,
		/* source= / 0, / displayId= */ 0, CHARACTERS);
		}

		@Test
		public void testConstructorWith5Args() {
		KeyEvent key = new KeyEvent(DOWN_TIME, EVENT_TIME, ACTION, KEYCODE, REPEAT);

		assertKeyEventFields(key, DOWN_TIME, EVENT_TIME, ACTION, KEYCODE, REPEAT,
		/* metaState= / 0, KeyCharacterMap.VIRTUAL_KEYBOARD, / scanCode= */ 0,
		/* flags= / 0, / source= / 0, / displayId= */ 0, CHARACTERS);
		}

		@Test
		public void testConstructorWith4Args() {
		KeyEvent key = new KeyEvent(42, CHARACTERS, DEVICE_ID, FLAGS);

		assertKeyEventFields(key, /* downTime= / 42, / eventTime= */ 42, KeyEvent.ACTION_MULTIPLE,
		KeyEvent.KEYCODE_UNKNOWN, /* repeat= / 0, / metaState= */ 0, DEVICE_ID,
		/* scanCode= */ 0, FLAGS, InputDevice.SOURCE_KEYBOARD, INVALID_DISPLAY, CHARACTERS);
		}

		@Test
		public void testConstructorWith2rgs() {
		KeyEvent key = new KeyEvent(ACTION, KEYCODE);

		assertKeyEventFields(key, /* downTime= / 0, / eventTime= */ 0, ACTION, KEYCODE,
		/* repeat= / 0, / metaState= */ 0, KeyCharacterMap.VIRTUAL_KEYBOARD,
		/* scanCode= / 0, FLAGS, / source= / 0, / displayId= */ 0, CHARACTERS);
		}

		private static KeyEvent createKey() {
		return KeyEvent.obtain(DOWN_TIME, EVENT_TIME, ACTION, KEYCODE, REPEAT, METASTATE,
		DEVICE_ID, SCAN_CODE, FLAGS, SOURCE, INVALID_DISPLAY, CHARACTERS);
		}

		private static void compareKeys(KeyEvent key1, KeyEvent key2) {
		assertEquals(key1.getId(), key2.getId());
		assertEquals(key1.getDownTime(), key2.getDownTime());
		assertEquals(key1.getEventTime(), key2.getEventTime());
		assertEquals(key1.getAction(), key2.getAction());
		assertEquals(key1.getKeyCode(), key2.getKeyCode());
		assertEquals(key1.getRepeatCount(), key2.getRepeatCount());
		assertEquals(key1.getMetaState(), key2.getMetaState());
		assertEquals(key1.getDeviceId(), key2.getDeviceId());
		assertEquals(key1.getScanCode(), key2.getScanCode());
		assertEquals(key1.getFlags(), key2.getFlags());
		assertEquals(key1.getSource(), key2.getSource());
		assertEquals(key1.getDisplayId(), key2.getDisplayId());
		assertEquals(key1.getCharacters(), key2.getCharacters());
		private void compareKeys(KeyEvent key1, KeyEvent key2) {
		expect.withMessage("id (key1=%s, key2=%s)", key1, key2)
		.that(key2.getId()).isEqualTo(key1.getId());
		expect.withMessage("downTime (key1=%s, key2=%s)", key1, key2)
		.that(key2.getDownTime()).isEqualTo(key1.getDownTime());
		expect.withMessage("eventTime (key1=%s, key2=%s)", key1, key2)
		.that(key2.getEventTime()).isEqualTo(key1.getEventTime());
		expect.withMessage("action (key1=%s, key2=%s)", key1, key2)
		.that(key2.getAction()).isEqualTo(key1.getAction());
		expect.withMessage("keyCode (key1=%s, key2=%s)", key1, key2)
		.that(key2.getKeyCode()).isEqualTo(key1.getKeyCode());
		expect.withMessage("repatCount (key1=%s, key2=%s)", key1, key2)
		.that(key2.getRepeatCount()).isEqualTo(key1.getRepeatCount());
		expect.withMessage("metaState (key1=%s, key2=%s)", key1, key2)
		.that(key2.getMetaState()).isEqualTo(key1.getMetaState());
		expect.withMessage("deviceId (key1=%s, key2=%s)", key1, key2)
		.that(key2.getDeviceId()).isEqualTo(key1.getDeviceId());
		expect.withMessage("scanCode (key1=%s, key2=%s)", key1, key2)
		.that(key2.getScanCode()).isEqualTo(key1.getScanCode());
		expect.withMessage("flags (key1=%s, key2=%s)", key1, key2)
		.that(key2.getFlags()).isEqualTo(key1.getFlags());
		expect.withMessage("source (key1=%s, key2=%s)", key1, key2)
		.that(key2.getSource()).isEqualTo(key1.getSource());
		expect.withMessage("displayId(key1=%s, key2=%s)", key1, key2)
		.that(key2.getDisplayId()).isEqualTo(key1.getDisplayId());
		expect.withMessage("characters(key1=%s, key2=%s)", key1, key2)
		.that(key2.getCharacters()).isEqualTo(key1.getCharacters());
		}

		private void assertHasDefaultFields(KeyEvent keyEvent, int displayId) {
		assertKeyEventFields(keyEvent, DOWN_TIME, EVENT_TIME, ACTION, KEYCODE, REPEAT, METASTATE,
		DEVICE_ID, SCAN_CODE, FLAGS, InputDevice.SOURCE_KEYBOARD, displayId, CHARACTERS);
		}

		private void assertKeyEventFields(KeyEvent keyEvent, long downTime, long eventTime,
		int action, int keyCode, int repeat, int metaState, int deviceId, int scanCode,
		int flags, int source, int displayId, String characters) {
		expect.withMessage("downTime on %s", keyEvent)
		.that(keyEvent.getDownTime()).isEqualTo(downTime);
		expect.withMessage("eventTime on %s", keyEvent)
		.that(keyEvent.getEventTime()).isEqualTo(eventTime);
		expect.withMessage("action on %s", keyEvent)
		.that(keyEvent.getAction()).isEqualTo(action);
		expect.withMessage("keyCode on %s", keyEvent)
		.that(keyEvent.getKeyCode()).isEqualTo(keyCode);
		expect.withMessage("repeatCount on %s", keyEvent)
		.that(keyEvent.getRepeatCount()).isEqualTo(repeat);
		expect.withMessage("metaState on %s", keyEvent)
		.that(keyEvent.getMetaState()).isEqualTo(metaState);
		expect.withMessage("deviceId on %s", keyEvent)
		.that(keyEvent.getDeviceId()).isEqualTo(deviceId);
		expect.withMessage("scanCode on %s", keyEvent)
		.that(keyEvent.getScanCode()).isEqualTo(scanCode);
		expect.withMessage("flags on %s", keyEvent)
		.that(keyEvent.getFlags()).isEqualTo(flags);
		expect.withMessage("source on %s", keyEvent)
		.that(keyEvent.getSource()).isEqualTo(source);
		expect.withMessage("displayId on %s", keyEvent)
		.that(keyEvent.getDisplayId()).isEqualTo(displayId);
		expect.withMessage("characters on %s", keyEvent)
		.that(keyEvent.getCharacters()).isEqualTo(characters);
		}
		}