Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Improvements on KeyEventTest."

Browse Source
This commit is contained in:
Felipe Leme
2023-02-14 01:39:21 +00:00
committed by Android (Google) Code Review
parent 29297912c4 7630a4e0ea
commit dc6ec7e86d
1 changed files with 157 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files

210
core/tests/coretests/src/android/view/KeyEventTest.java
View File

@@ -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();
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);
}
}