tests/tests/view/src/android/view/cts/KeyEventTest.java

/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.view.cts;

import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetClass;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargets;
import dalvik.annotation.ToBeFixed;

import android.os.Parcel;
import android.os.Parcelable;
import android.os.SystemClock;
import android.test.AndroidTestCase;
import android.text.method.MetaKeyKeyListener;
import android.view.KeyEvent;
import android.view.KeyCharacterMap.KeyData;
import android.view.KeyEvent.Callback;

import junit.framework.Assert;

/**
 * Test {@link KeyEvent}.
 */
@TestTargetClass(KeyEvent.class)
public class KeyEventTest extends AndroidTestCase {
    private KeyEvent mKeyEvent;
    private long mDownTime;
    private long mEventTime;

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0);

        mDownTime = SystemClock.uptimeMillis();
        mEventTime = SystemClock.uptimeMillis();
    }

    @TestTargets({
        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Test constructor(s) of {@link KeyEvent}",
            method = "KeyEvent",
            args = {int.class, int.class}
        ),
        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Test constructor(s) of {@link KeyEvent}",
            method = "KeyEvent",
            args = {android.view.KeyEvent.class, long.class, int.class}
        ),
        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Test constructor(s) of {@link KeyEvent}",
            method = "KeyEvent",
            args = {long.class, long.class, int.class, int.class, int.class}
        ),
        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Test constructor(s) of {@link KeyEvent}",
            method = "KeyEvent",
            args = {long.class, long.class, int.class, int.class, int.class, int.class}
        ),
        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Test constructor(s) of {@link KeyEvent}",
            method = "KeyEvent",
            args = {long.class, long.class, int.class, int.class, int.class, int.class,
                    int.class, int.class}
        ),
        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Test constructor(s) of {@link KeyEvent}",
            method = "KeyEvent",
            args = {long.class, long.class, int.class, int.class, int.class, int.class,
                    int.class, int.class, int.class}
        ),
        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Test constructor(s) of {@link KeyEvent}",
            method = "KeyEvent",
            args = {long.class, String.class, int.class, int.class}
        ),
        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "Test constructor(s) of {@link KeyEvent}",
            method = "KeyEvent",
            args = {android.view.KeyEvent.class}
        )
    })
    public void testConstructor() {
        new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0);

        new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5);

        new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5,
                KeyEvent.META_SHIFT_ON);

        new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5,
                KeyEvent.META_SHIFT_ON, 1, 1);

        new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5,
                KeyEvent.META_SHIFT_ON, 1, 1, KeyEvent.FLAG_SOFT_KEYBOARD);

        KeyEvent keyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0);
        new KeyEvent(keyEvent);
        new KeyEvent(keyEvent, mEventTime, 1);

        new KeyEvent(mDownTime, "test", 0, KeyEvent.FLAG_SOFT_KEYBOARD);
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#getCharacters()}",
        method = "getCharacters",
        args = {}
    )
    public void testGetCharacters() {
        String characters = "android_test";
        mKeyEvent = new KeyEvent(mDownTime, characters, 0, KeyEvent.FLAG_SOFT_KEYBOARD);
        assertEquals(KeyEvent.ACTION_MULTIPLE, mKeyEvent.getAction());
        assertEquals(KeyEvent.KEYCODE_UNKNOWN, mKeyEvent.getKeyCode());
        assertEquals(characters, mKeyEvent.getCharacters());

        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0);
        assertNull(mKeyEvent.getCharacters());
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#getMaxKeyCode()}",
        method = "getMaxKeyCode",
        args = {}
    )
    public void testGetMaxKeyCode() {
        assertTrue(KeyEvent.getMaxKeyCode() > 0);
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#isShiftPressed()}",
        method = "isShiftPressed",
        args = {}
    )
    public void testIsShiftPressed() {
        assertFalse(mKeyEvent.isShiftPressed());
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5,
                KeyEvent.META_SHIFT_ON);
        assertTrue(mKeyEvent.isShiftPressed());
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5,
                KeyEvent.META_ALT_ON);
        assertFalse(mKeyEvent.isShiftPressed());
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#getDeadChar(int, int)}",
        method = "getDeadChar",
        args = {int.class, int.class}
    )
    public void testGetDeadChar() {
        // decimal number of è is 232.
        assertEquals(232, KeyEvent.getDeadChar('`', 'e'));
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#getKeyData(KeyData)}",
        method = "getKeyData",
        args = {android.view.KeyCharacterMap.KeyData.class}
    )
    public void testGetKeyData() {
        KeyEvent keyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_Z);
        KeyData keyData = new KeyData();
        assertTrue(keyEvent.getKeyData(keyData));

        assertEquals('Z', keyData.displayLabel);
        assertEquals(0, keyData.number);
        assertEquals('z', keyData.meta[0]);
        assertEquals('Z', keyData.meta[1]);
        assertEquals(0, keyData.meta[3]);
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#dispatch(Callback)}",
        method = "dispatch",
        args = {android.view.KeyEvent.Callback.class}
    )
    public void testDispatch() {
        MockCallback callback = new MockCallback();
        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0);
        callback.reset();
        assertFalse(callback.isKeyDown());
        assertTrue(mKeyEvent.dispatch(callback));
        assertTrue(callback.isKeyDown());
        assertEquals(KeyEvent.KEYCODE_0, callback.getKeyCode());
        assertSame(mKeyEvent, callback.getKeyEvent());

        mKeyEvent = new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_0);
        callback.reset();
        assertFalse(callback.isKeyUp());
        assertTrue(mKeyEvent.dispatch(callback));
        assertTrue(callback.isKeyUp());
        assertEquals(KeyEvent.KEYCODE_0, callback.getKeyCode());
        assertSame(mKeyEvent, callback.getKeyEvent());

        callback.reset();
        int count = 2;
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_MULTIPLE,
                KeyEvent.KEYCODE_0, count);
        assertFalse(callback.isKeyMultiple());
        assertTrue(mKeyEvent.dispatch(callback));
        assertTrue(callback.isKeyMultiple());
        assertEquals(KeyEvent.KEYCODE_0, callback.getKeyCode());
        assertSame(mKeyEvent, callback.getKeyEvent());
        assertEquals(count, callback.getCount());

        callback.reset();
        count = 0;
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_MULTIPLE,
                KeyEvent.KEYCODE_0, count);
        assertTrue(mKeyEvent.dispatch(callback));
        assertTrue(callback.isKeyMultiple());
        assertTrue(callback.isKeyDown());
        assertTrue(callback.isKeyUp());
        assertEquals(count, callback.getCount());
        assertEquals(KeyEvent.KEYCODE_0, callback.getKeyCode());
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#getMetaState()}",
        method = "getMetaState",
        args = {}
    )
    public void testGetMetaState() {
        int metaState = KeyEvent.META_ALT_ON;
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_MULTIPLE,
                KeyEvent.KEYCODE_1, 1, metaState);
        assertEquals(metaState, mKeyEvent.getMetaState());
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#getEventTime()}",
        method = "getEventTime",
        args = {}
    )
    public void testGetEventTime() {
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN,
                KeyEvent.KEYCODE_0, 5);
        assertEquals(mEventTime, mKeyEvent.getEventTime());
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#getDownTime()}",
        method = "getDownTime",
        args = {}
    )
    public void testGetDownTime() {
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN,
                KeyEvent.KEYCODE_0, 5);
        assertEquals(mDownTime, mKeyEvent.getDownTime());
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#getUnicodeChar()}",
        method = "getUnicodeChar",
        args = {}
    )
    public void testGetUnicodeChar1() {
        // 48 is Unicode character of '0'
        assertEquals(48, mKeyEvent.getUnicodeChar());

        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN,
                KeyEvent.KEYCODE_9, 5, 0);
        // 57 is Unicode character of '9'
        assertEquals(57, mKeyEvent.getUnicodeChar());

        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN,
                KeyEvent.KEYCODE_ALT_LEFT, 5, KeyEvent.META_SHIFT_ON);
        // 'ALT' key is not a type Unicode character.
        assertEquals(0, mKeyEvent.getUnicodeChar());
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#getUnicodeChar(int)}",
        method = "getUnicodeChar",
        args = {int.class}
    )
    public void testGetUnicodeChar2() {
        // 48 is Unicode character of '0'
        assertEquals(48, mKeyEvent.getUnicodeChar(MetaKeyKeyListener.META_CAP_LOCKED));
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN,
                KeyEvent.KEYCODE_9, 5, 0);

        // 57 is Unicode character of '9'
        assertEquals(57, mKeyEvent.getUnicodeChar(0));

        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN,
                KeyEvent.KEYCODE_ALT_LEFT, 5, KeyEvent.META_SHIFT_ON);
        // 'ALT' key is not a type Unicode character.
        assertEquals(0, mKeyEvent.getUnicodeChar(0));
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#getNumber()}",
        method = "getNumber",
        args = {}
    )
    public void testGetNumber() {
        // 48 is associated with key '0'
        assertEquals(48, mKeyEvent.getNumber());

        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_3);
        // 51 is associated with key '3'
        assertEquals(51, mKeyEvent.getNumber());
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#isSymPressed()}",
        method = "isSymPressed",
        args = {}
    )
    public void testIsSymPressed() {
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5,
                KeyEvent.META_SYM_ON);
        assertTrue(mKeyEvent.isSymPressed());

        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5,
                KeyEvent.META_SHIFT_ON);
        assertFalse(mKeyEvent.isSymPressed());
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#getDeviceId()}",
        method = "getDeviceId",
        args = {}
    )
    public void testGetDeviceId() {
        int deviceId = 1;
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5,
                KeyEvent.META_SHIFT_ON, deviceId, 1);
        assertEquals(deviceId, mKeyEvent.getDeviceId());
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#toString()}",
        method = "toString",
        args = {}
    )
    public void testToString() {
        // make sure it does not throw any exception.
        mKeyEvent.toString();
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#isAltPressed()}",
        method = "isAltPressed",
        args = {}
    )
    public void testIsAltPressed() {
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5,
                KeyEvent.META_ALT_ON);
        assertTrue(mKeyEvent.isAltPressed());

        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5,
                KeyEvent.META_SHIFT_ON);
        assertFalse(mKeyEvent.isAltPressed());
    }

    public void testGetModifierMetaStateMask() {
        int mask = KeyEvent.getModifierMetaStateMask();
        assertTrue((mask & KeyEvent.META_SHIFT_ON) != 0);
        assertTrue((mask & KeyEvent.META_SHIFT_LEFT_ON) != 0);
        assertTrue((mask & KeyEvent.META_SHIFT_RIGHT_ON) != 0);
        assertTrue((mask & KeyEvent.META_ALT_ON) != 0);
        assertTrue((mask & KeyEvent.META_ALT_LEFT_ON) != 0);
        assertTrue((mask & KeyEvent.META_ALT_RIGHT_ON) != 0);
        assertTrue((mask & KeyEvent.META_CTRL_ON) != 0);
        assertTrue((mask & KeyEvent.META_CTRL_LEFT_ON) != 0);
        assertTrue((mask & KeyEvent.META_CTRL_RIGHT_ON) != 0);
        assertTrue((mask & KeyEvent.META_META_ON) != 0);
        assertTrue((mask & KeyEvent.META_META_LEFT_ON) != 0);
        assertTrue((mask & KeyEvent.META_META_RIGHT_ON) != 0);
        assertTrue((mask & KeyEvent.META_SYM_ON) != 0);
        assertTrue((mask & KeyEvent.META_FUNCTION_ON) != 0);

        assertFalse((mask & KeyEvent.META_CAPS_LOCK_ON) != 0);
        assertFalse((mask & KeyEvent.META_NUM_LOCK_ON) != 0);
        assertFalse((mask & KeyEvent.META_SCROLL_LOCK_ON) != 0);
    }

    public void testIsModifierKey() {
        assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_SHIFT_LEFT));
        assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_SHIFT_RIGHT));
        assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_ALT_LEFT));
        assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_ALT_RIGHT));
        assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_CTRL_LEFT));
        assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_CTRL_RIGHT));
        assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_META_LEFT));
        assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_META_RIGHT));
        assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_SYM));
        assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_NUM));
        assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_FUNCTION));

        assertFalse(KeyEvent.isModifierKey(KeyEvent.KEYCODE_0));
    }

    private static final int UNDEFINED_META_STATE = 0x80000000;

    public void testNormalizeMetaState() {
        // Already normalized values.
        assertEquals(0, KeyEvent.normalizeMetaState(0));
        assertEquals(KeyEvent.getModifierMetaStateMask(),
                KeyEvent.normalizeMetaState(KeyEvent.getModifierMetaStateMask()));

        // Values that require normalization.
        assertEquals(KeyEvent.META_SHIFT_LEFT_ON | KeyEvent.META_SHIFT_ON,
                KeyEvent.normalizeMetaState(KeyEvent.META_SHIFT_LEFT_ON));
        assertEquals(KeyEvent.META_SHIFT_RIGHT_ON | KeyEvent.META_SHIFT_ON,
                KeyEvent.normalizeMetaState(KeyEvent.META_SHIFT_RIGHT_ON));
        assertEquals(KeyEvent.META_ALT_LEFT_ON | KeyEvent.META_ALT_ON,
                KeyEvent.normalizeMetaState(KeyEvent.META_ALT_LEFT_ON));
        assertEquals(KeyEvent.META_ALT_RIGHT_ON | KeyEvent.META_ALT_ON,
                KeyEvent.normalizeMetaState(KeyEvent.META_ALT_RIGHT_ON));
        assertEquals(KeyEvent.META_CTRL_LEFT_ON | KeyEvent.META_CTRL_ON,
                KeyEvent.normalizeMetaState(KeyEvent.META_CTRL_LEFT_ON));
        assertEquals(KeyEvent.META_CTRL_RIGHT_ON | KeyEvent.META_CTRL_ON,
                KeyEvent.normalizeMetaState(KeyEvent.META_CTRL_RIGHT_ON));
        assertEquals(KeyEvent.META_META_LEFT_ON | KeyEvent.META_META_ON,
                KeyEvent.normalizeMetaState(KeyEvent.META_META_LEFT_ON));
        assertEquals(KeyEvent.META_META_RIGHT_ON | KeyEvent.META_META_ON,
                KeyEvent.normalizeMetaState(KeyEvent.META_META_RIGHT_ON));
        assertEquals(KeyEvent.META_CAPS_LOCK_ON,
                KeyEvent.normalizeMetaState(MetaKeyKeyListener.META_CAP_LOCKED));
        assertEquals(KeyEvent.META_ALT_ON,
                KeyEvent.normalizeMetaState(MetaKeyKeyListener.META_ALT_LOCKED));
        assertEquals(KeyEvent.META_SYM_ON,
                KeyEvent.normalizeMetaState(MetaKeyKeyListener.META_SYM_LOCKED));
        assertEquals(KeyEvent.META_SHIFT_ON,
                KeyEvent.normalizeMetaState(KeyEvent.META_SHIFT_ON | UNDEFINED_META_STATE));
    }

    public void testMetaStateHasNoModifiers() {
        assertTrue(KeyEvent.metaStateHasNoModifiers(0));
        assertTrue(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_CAPS_LOCK_ON));
        assertTrue(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_NUM_LOCK_ON));
        assertTrue(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_SCROLL_LOCK_ON));

        assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_SHIFT_ON));
        assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_SHIFT_LEFT_ON));
        assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_SHIFT_RIGHT_ON));
        assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_ALT_ON));
        assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_ALT_LEFT_ON));
        assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_ALT_RIGHT_ON));
        assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_CTRL_ON));
        assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_CTRL_LEFT_ON));
        assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_CTRL_RIGHT_ON));
        assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_META_ON));
        assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_META_LEFT_ON));
        assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_META_RIGHT_ON));
        assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_SYM_ON));
        assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_FUNCTION_ON));
    }

    public void testMetaStateHasModifiers() {
        assertTrue(KeyEvent.metaStateHasModifiers(0, 0));
        assertTrue(KeyEvent.metaStateHasModifiers(
                KeyEvent.META_NUM_LOCK_ON | KeyEvent.META_CAPS_LOCK_ON
                        | KeyEvent.META_SCROLL_LOCK_ON, 0));
        assertTrue(KeyEvent.metaStateHasModifiers(
                KeyEvent.META_SHIFT_ON | KeyEvent.META_SHIFT_LEFT_ON,
                KeyEvent.META_SHIFT_LEFT_ON));
        assertTrue(KeyEvent.metaStateHasModifiers(
                KeyEvent.META_SHIFT_LEFT_ON | KeyEvent.META_SHIFT_RIGHT_ON,
                KeyEvent.META_SHIFT_LEFT_ON | KeyEvent.META_SHIFT_RIGHT_ON));
        assertTrue(KeyEvent.metaStateHasModifiers(
                KeyEvent.META_SHIFT_LEFT_ON,
                KeyEvent.META_SHIFT_LEFT_ON));
        assertTrue(KeyEvent.metaStateHasModifiers(
                KeyEvent.META_NUM_LOCK_ON | KeyEvent.META_CAPS_LOCK_ON
                        | KeyEvent.META_SCROLL_LOCK_ON | KeyEvent.META_SHIFT_LEFT_ON,
                KeyEvent.META_SHIFT_LEFT_ON));
        assertTrue(KeyEvent.metaStateHasModifiers(
                KeyEvent.META_SHIFT_ON | KeyEvent.META_SHIFT_LEFT_ON,
                KeyEvent.META_SHIFT_ON));
        assertTrue(KeyEvent.metaStateHasModifiers(
                KeyEvent.META_ALT_ON | KeyEvent.META_ALT_RIGHT_ON,
                KeyEvent.META_ALT_ON));
        assertTrue(KeyEvent.metaStateHasModifiers(
                KeyEvent.META_ALT_LEFT_ON | KeyEvent.META_SHIFT_LEFT_ON,
                KeyEvent.META_ALT_ON | KeyEvent.META_SHIFT_ON));
        assertTrue(KeyEvent.metaStateHasModifiers(
                KeyEvent.META_CTRL_RIGHT_ON | KeyEvent.META_META_LEFT_ON,
                KeyEvent.META_CTRL_RIGHT_ON | KeyEvent.META_META_ON));
        assertTrue(KeyEvent.metaStateHasModifiers(
                KeyEvent.META_SYM_ON | KeyEvent.META_FUNCTION_ON | KeyEvent.META_CAPS_LOCK_ON,
                KeyEvent.META_SYM_ON | KeyEvent.META_FUNCTION_ON));

        assertFalse(KeyEvent.metaStateHasModifiers(0, KeyEvent.META_SHIFT_ON));
        assertFalse(KeyEvent.metaStateHasModifiers(
                KeyEvent.META_ALT_ON | KeyEvent.META_SHIFT_LEFT_ON,
                KeyEvent.META_SHIFT_ON));
        assertFalse(KeyEvent.metaStateHasModifiers(
                KeyEvent.META_ALT_LEFT_ON | KeyEvent.META_SHIFT_LEFT_ON,
                KeyEvent.META_SHIFT_ON));
        assertFalse(KeyEvent.metaStateHasModifiers(
                KeyEvent.META_ALT_LEFT_ON,
                KeyEvent.META_ALT_RIGHT_ON));
        assertFalse(KeyEvent.metaStateHasModifiers(
                KeyEvent.META_ALT_LEFT_ON,
                KeyEvent.META_CTRL_LEFT_ON));

        final int[] invalidModifiers = new int[] {
                KeyEvent.META_CAPS_LOCK_ON,
                KeyEvent.META_NUM_LOCK_ON,
                KeyEvent.META_SCROLL_LOCK_ON,
                MetaKeyKeyListener.META_CAP_LOCKED,
                MetaKeyKeyListener.META_ALT_LOCKED,
                MetaKeyKeyListener.META_SYM_LOCKED,
                KeyEvent.META_SHIFT_ON | KeyEvent.META_SHIFT_LEFT_ON,
                KeyEvent.META_SHIFT_ON | KeyEvent.META_SHIFT_RIGHT_ON,
                KeyEvent.META_SHIFT_ON | KeyEvent.META_SHIFT_LEFT_ON| KeyEvent.META_SHIFT_RIGHT_ON,
                KeyEvent.META_ALT_ON | KeyEvent.META_ALT_LEFT_ON,
                KeyEvent.META_ALT_ON | KeyEvent.META_ALT_RIGHT_ON,
                KeyEvent.META_ALT_ON | KeyEvent.META_ALT_LEFT_ON| KeyEvent.META_ALT_RIGHT_ON,
                KeyEvent.META_CTRL_ON | KeyEvent.META_CTRL_LEFT_ON,
                KeyEvent.META_CTRL_ON | KeyEvent.META_CTRL_RIGHT_ON,
                KeyEvent.META_CTRL_ON | KeyEvent.META_CTRL_LEFT_ON| KeyEvent.META_CTRL_RIGHT_ON,
                KeyEvent.META_META_ON | KeyEvent.META_META_LEFT_ON,
                KeyEvent.META_META_ON | KeyEvent.META_META_RIGHT_ON,
                KeyEvent.META_META_ON | KeyEvent.META_META_LEFT_ON| KeyEvent.META_META_RIGHT_ON,
        };
        for (int modifiers : invalidModifiers) {
            try {
                KeyEvent.metaStateHasModifiers(0, modifiers);
                Assert.fail("Expected IllegalArgumentException");
            } catch (IllegalArgumentException ex) {
            }
        }

        assertFalse(KeyEvent.metaStateHasModifiers(0, UNDEFINED_META_STATE));
    }

    public void testHasNoModifiers() {
        KeyEvent ev = new KeyEvent(0, 0, KeyEvent.ACTION_DOWN,
                KeyEvent.KEYCODE_A, 0, KeyEvent.META_CAPS_LOCK_ON);
        assertTrue(ev.hasNoModifiers());

        ev = new KeyEvent(0, 0, KeyEvent.ACTION_DOWN,
                KeyEvent.KEYCODE_A, 0, KeyEvent.META_CAPS_LOCK_ON | KeyEvent.META_SHIFT_ON);
        assertFalse(ev.hasNoModifiers());
    }

    public void testHasModifiers() {
        KeyEvent ev = new KeyEvent(0, 0, KeyEvent.ACTION_DOWN,
                KeyEvent.KEYCODE_A, 0, KeyEvent.META_CAPS_LOCK_ON);
        assertTrue(ev.hasModifiers(0));

        ev = new KeyEvent(0, 0, KeyEvent.ACTION_DOWN,
                KeyEvent.KEYCODE_A, 0, KeyEvent.META_CAPS_LOCK_ON | KeyEvent.META_SHIFT_ON);
        assertTrue(ev.hasModifiers(KeyEvent.META_SHIFT_ON));

        ev = new KeyEvent(0, 0, KeyEvent.ACTION_DOWN,
                KeyEvent.KEYCODE_A, 0,
                KeyEvent.META_CAPS_LOCK_ON | KeyEvent.META_SHIFT_ON | KeyEvent.META_SHIFT_RIGHT_ON);
        assertFalse(ev.hasModifiers(KeyEvent.META_SHIFT_LEFT_ON));
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#getDisplayLabel()}",
        method = "getDisplayLabel",
        args = {}
    )
    @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete")
    public void testGetDisplayLabel() {
        assertTrue(mKeyEvent.getDisplayLabel() > 0);
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#isSystem()}",
        method = "isSystem",
        args = {}
    )
    @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete, " +
            "javadoc does not tell user the system key set.")
    public void testIsSystem() {
        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_MENU);
        assertTrue(mKeyEvent.isSystem());

        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_SOFT_RIGHT);
        assertTrue(mKeyEvent.isSystem());

        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_HOME);
        assertTrue(mKeyEvent.isSystem());

        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BACK);
        assertTrue(mKeyEvent.isSystem());

        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_CALL);
        assertTrue(mKeyEvent.isSystem());

        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_ENDCALL);
        assertTrue(mKeyEvent.isSystem());

        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_VOLUME_UP);
        assertTrue(mKeyEvent.isSystem());

        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_VOLUME_DOWN);
        assertTrue(mKeyEvent.isSystem());

        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_POWER);
        assertTrue(mKeyEvent.isSystem());

        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_SEARCH);
        assertTrue(mKeyEvent.isSystem());

        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_HEADSETHOOK);
        assertTrue(mKeyEvent.isSystem());

        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_CAMERA);
        assertTrue(mKeyEvent.isSystem());

        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_FOCUS);
        assertTrue(mKeyEvent.isSystem());

        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0);
        assertFalse(mKeyEvent.isSystem());
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#isPrintingKey()}",
        method = "isPrintingKey",
        args = {}
    )
    @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete, " +
            "javadoc does not tell user the printing key set.")
    public void testIsPrintingKey() {
        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, Character.SPACE_SEPARATOR);
        assertTrue(mKeyEvent.isPrintingKey());

        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, Character.LINE_SEPARATOR);
        assertTrue(mKeyEvent.isPrintingKey());

        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, Character.PARAGRAPH_SEPARATOR);
        assertTrue(mKeyEvent.isPrintingKey());

        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, Character.CONTROL);
        assertTrue(mKeyEvent.isPrintingKey());

        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, Character.FORMAT);
        assertTrue(mKeyEvent.isPrintingKey());

        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0);
        assertTrue(mKeyEvent.isPrintingKey());
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#getMatch(char[])}",
        method = "getMatch",
        args = {char[].class}
    )
    public void testGetMatch1() {
        char[] codes1 = new char[] { '0', '1', '2' };
        assertEquals('0', mKeyEvent.getMatch(codes1));

        char[] codes2 = new char[] { 'A', 'B', 'C' };
        assertEquals('\0', mKeyEvent.getMatch(codes2));

        char[] codes3 = { '2', 'S' };
        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_S);
        assertEquals('S', mKeyEvent.getMatch(codes3));
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#getAction()}",
        method = "getAction",
        args = {}
    )
    public void testGetAction() {
        assertEquals(KeyEvent.ACTION_DOWN, mKeyEvent.getAction());
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#getRepeatCount()}",
        method = "getRepeatCount",
        args = {}
    )
    public void testGetRepeatCount() {
        int repeatCount = 1;
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_MULTIPLE,
                KeyEvent.KEYCODE_0, repeatCount);
        assertEquals(repeatCount, mKeyEvent.getRepeatCount());
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#writeToParcel(Parcel, int)}",
        method = "writeToParcel",
        args = {android.os.Parcel.class, int.class}
    )
    public void testWriteToParcel() {
        Parcel parcel = Parcel.obtain();
        mKeyEvent.writeToParcel(parcel, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
        parcel.setDataPosition(0);

        KeyEvent keyEvent = KeyEvent.CREATOR.createFromParcel(parcel);
        parcel.recycle();

        assertEquals(mKeyEvent.getAction(), keyEvent.getAction());
        assertEquals(mKeyEvent.getKeyCode(), keyEvent.getKeyCode());
        assertEquals(mKeyEvent.getRepeatCount(), keyEvent.getRepeatCount());
        assertEquals(mKeyEvent.getMetaState(), keyEvent.getMetaState());
        assertEquals(mKeyEvent.getDeviceId(), keyEvent.getDeviceId());
        assertEquals(mKeyEvent.getScanCode(), keyEvent.getScanCode());
        assertEquals(mKeyEvent.getFlags(), keyEvent.getFlags());
        assertEquals(mKeyEvent.getDownTime(), keyEvent.getDownTime());
        assertEquals(mKeyEvent.getEventTime(), keyEvent.getEventTime());
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#describeContents()}, this function always returns 0",
        method = "describeContents",
        args = {}
    )
    @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete.")
    public void testDescribeContents() {
        // make sure it never shrow any exception.
        mKeyEvent.describeContents();
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#getKeyCode()}",
        method = "getKeyCode",
        args = {}
    )
    public void testGetKeyCode() {
        assertEquals(KeyEvent.KEYCODE_0, mKeyEvent.getKeyCode());
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#getFlags()}",
        method = "getFlags",
        args = {}
    )
    public void testGetFlags() {
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN,
                KeyEvent.KEYCODE_0, 5, KeyEvent.META_SHIFT_ON, 1, 1, KeyEvent.FLAG_WOKE_HERE);
        assertEquals(KeyEvent.FLAG_WOKE_HERE, mKeyEvent.getFlags());

        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN,
                KeyEvent.KEYCODE_0, 5, KeyEvent.META_SHIFT_ON, 1, 1, KeyEvent.FLAG_SOFT_KEYBOARD);
        assertEquals(KeyEvent.FLAG_SOFT_KEYBOARD, mKeyEvent.getFlags());
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Test {@link KeyEvent#getScanCode()}",
        method = "getScanCode",
        args = {}
    )
    public void testGetScanCode() {
        int scanCode = 1;
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN,
                KeyEvent.KEYCODE_0, 5, KeyEvent.META_SHIFT_ON, 1, scanCode);
        assertEquals(scanCode, mKeyEvent.getScanCode());
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "changeAction",
        args = {android.view.KeyEvent.class, int.class}
    )
    public void testChangeAction() {
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN,
                KeyEvent.KEYCODE_0, 5, KeyEvent.META_SHIFT_ON, 1, 1, KeyEvent.FLAG_WOKE_HERE);

        KeyEvent newEvent = KeyEvent.changeAction(mKeyEvent, KeyEvent.ACTION_UP);
        assertEquals(KeyEvent.ACTION_UP, newEvent.getAction());
        assertEquals(mKeyEvent.getFlags(), newEvent.getFlags());
        assertEquals(mKeyEvent.getCharacters(), newEvent.getCharacters());
        assertEquals(mKeyEvent.getDisplayLabel(), newEvent.getDisplayLabel());
        assertEquals(mKeyEvent.getDeviceId(), newEvent.getDeviceId());
        assertEquals(mKeyEvent.getDownTime(), newEvent.getDownTime());
        assertEquals(mKeyEvent.getEventTime(), newEvent.getEventTime());
        assertEquals(mKeyEvent.getKeyCode(), newEvent.getKeyCode());
        assertEquals(mKeyEvent.getRepeatCount(), newEvent.getRepeatCount());
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "changeFlags",
        args = {android.view.KeyEvent.class, int.class}
    )
    public void testChangeFlags() {
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN,
                KeyEvent.KEYCODE_0, 5, KeyEvent.META_SHIFT_ON, 1, 1, KeyEvent.FLAG_WOKE_HERE);

        KeyEvent newEvent = KeyEvent.changeFlags(mKeyEvent, KeyEvent.FLAG_FROM_SYSTEM);
        assertEquals(KeyEvent.FLAG_FROM_SYSTEM, newEvent.getFlags());
        assertEquals(mKeyEvent.getAction(), newEvent.getAction());
        assertEquals(mKeyEvent.getCharacters(), newEvent.getCharacters());
        assertEquals(mKeyEvent.getDisplayLabel(), newEvent.getDisplayLabel());
        assertEquals(mKeyEvent.getDeviceId(), newEvent.getDeviceId());
        assertEquals(mKeyEvent.getDownTime(), newEvent.getDownTime());
        assertEquals(mKeyEvent.getEventTime(), newEvent.getEventTime());
        assertEquals(mKeyEvent.getKeyCode(), newEvent.getKeyCode());
        assertEquals(mKeyEvent.getRepeatCount(), newEvent.getRepeatCount());
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "changeTimeRepeat",
        args = {android.view.KeyEvent.class, long.class, int.class}
    )
    public void testChangeTimeRepeat() {
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN,
                KeyEvent.KEYCODE_0, 5, KeyEvent.META_SHIFT_ON, 1, 1, KeyEvent.FLAG_WOKE_HERE);

        long newEventTime = SystemClock.uptimeMillis();
        int newRepeat = mKeyEvent.getRepeatCount() + 1;
        KeyEvent newEvent = KeyEvent.changeTimeRepeat(mKeyEvent, newEventTime, newRepeat);
        assertEquals(newEventTime, newEvent.getEventTime());
        assertEquals(newRepeat, newEvent.getRepeatCount());
        assertEquals(mKeyEvent.getFlags(), newEvent.getFlags());
        assertEquals(mKeyEvent.getAction(), newEvent.getAction());
        assertEquals(mKeyEvent.getCharacters(), newEvent.getCharacters());
        assertEquals(mKeyEvent.getDisplayLabel(), newEvent.getDisplayLabel());
        assertEquals(mKeyEvent.getDeviceId(), newEvent.getDeviceId());
        assertEquals(mKeyEvent.getDownTime(), newEvent.getDownTime());
        assertEquals(mKeyEvent.getKeyCode(), newEvent.getKeyCode());
    }

    private class MockCallback implements Callback {
        private boolean mIsKeyDown;
        private boolean mIsKeyUp;
        private boolean mIsMultiple;
        private int mKeyCode;
        private KeyEvent mKeyEvent;
        private int mCount;

        public boolean isKeyDown() {
            return mIsKeyDown;
        }

        public boolean isKeyUp() {
            return mIsKeyUp;
        }

        public boolean isKeyMultiple() {
            return mIsMultiple;
        }

        public int getKeyCode() {
            return mKeyCode;
        }

        public KeyEvent getKeyEvent() {
            return mKeyEvent;
        }

        public int getCount() {
            return mCount;
        }

        public void reset() {
            mIsKeyDown = false;
            mIsKeyUp = false;
            mIsMultiple = false;
        }

        public boolean onKeyDown(int keyCode, KeyEvent event) {
            mIsKeyDown = true;
            mKeyCode = keyCode;
            mKeyEvent = event;
            return true;
        }

        public boolean onKeyLongPress(int keyCode, KeyEvent event) {
            return false;
        }

        public boolean onKeyMultiple(int keyCode, int count, KeyEvent event) {
            mIsMultiple = true;
            mKeyCode = keyCode;
            mKeyEvent = event;
            mCount = count;
            if (count < 1) {
                return false; // this key event never repeat.
            }
            return true;
        }

        public boolean onKeyUp(int keyCode, KeyEvent event) {
            mIsKeyUp = true;
            mKeyCode = keyCode;
            mKeyEvent = event;
            return true;
        }
    }
}