diff --git a/core/tests/coretests/src/android/view/KeyEventTest.java b/core/tests/coretests/src/android/view/KeyEventTest.java index bbb25a37dd0b5..c10ef007c3c0b 100644 --- a/core/tests/coretests/src/android/view/KeyEventTest.java +++ b/core/tests/coretests/src/android/view/KeyEventTest.java @@ -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 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(); - Parcel parcel = Parcel.obtain(); - key1.writeToParcel(parcel, 0 /*flags*/); - parcel.setDataPosition(0); + KeyEvent key2; - KeyEvent key2 = KeyEvent.CREATOR.createFromParcel(parcel); - parcel.recycle(); + Parcel parcel = Parcel.obtain(); + try { + key1.writeToParcel(parcel, /* flags= */ 0); + parcel.setDataPosition(0); + + 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); } }