Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7630a4e0 authored by Felipe Leme's avatar Felipe Leme
Browse files

Improvements on KeyEventTest. 

These improvements will make it easier to change KeyEvent
constructors:

- Replaced JUnit assertions by Truth's.
- Add a message explaining which field assertion failes.
- Use proper APIs to assert collections.
- Replaced some assertions to use expect.

Test: atest KeyEventTest

Bug: 266851112
Bug: 268103680

Change-Id: I79a35d8dd3a0bc7eca0650c4d2b42613c94e9d8e
parent 35b1662e

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);

    }

}