Merge "Improvements on KeyEventTest."
diff --git a/core/tests/coretests/src/android/view/KeyEventTest.java b/core/tests/coretests/src/android/view/KeyEventTest.java
index bbb25a3..c10ef00 100644
--- a/core/tests/coretests/src/android/view/KeyEventTest.java
+++ b/core/tests/coretests/src/android/view/KeyEventTest.java
@@ -18,8 +18,8 @@
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 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 @@
@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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 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);
}
}