/*
 * 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 static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;

import android.os.Parcel;
import android.os.Parcelable;
import android.os.SystemClock;
import android.text.method.MetaKeyKeyListener;
import android.view.InputDevice;
import android.view.KeyCharacterMap;
import android.view.KeyCharacterMap.KeyData;
import android.view.KeyEvent;

import androidx.test.filters.SmallTest;
import androidx.test.runner.AndroidJUnit4;

import junit.framework.Assert;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.invocation.InvocationOnMock;

/**
 * Test {@link KeyEvent}.
 */
@SmallTest
@RunWith(AndroidJUnit4.class)
public class KeyEventTest {
    private KeyEvent mKeyEvent;
    private long mDownTime;
    private long mEventTime;

    @Before
    public void setup() {
        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0);

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

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

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

    @Test
    public void testGetMaxKeyCode() {
        assertTrue(KeyEvent.getMaxKeyCode() > 0);
    }

    @Test
    public void testMetaKeyStates() {
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5,
                KeyEvent.META_ALT_ON);
        assertTrue(mKeyEvent.isAltPressed());
        assertFalse(mKeyEvent.isCtrlPressed());
        assertFalse(mKeyEvent.isFunctionPressed());
        assertFalse(mKeyEvent.isMetaPressed());
        assertFalse(mKeyEvent.isShiftPressed());
        assertFalse(mKeyEvent.isSymPressed());

        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_1, 4,
                KeyEvent.META_CTRL_ON);
        assertFalse(mKeyEvent.isAltPressed());
        assertTrue(mKeyEvent.isCtrlPressed());
        assertFalse(mKeyEvent.isFunctionPressed());
        assertFalse(mKeyEvent.isMetaPressed());
        assertFalse(mKeyEvent.isShiftPressed());
        assertFalse(mKeyEvent.isSymPressed());

        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_2, 3,
                KeyEvent.META_FUNCTION_ON);
        assertFalse(mKeyEvent.isAltPressed());
        assertFalse(mKeyEvent.isCtrlPressed());
        assertTrue(mKeyEvent.isFunctionPressed());
        assertFalse(mKeyEvent.isMetaPressed());
        assertFalse(mKeyEvent.isShiftPressed());
        assertFalse(mKeyEvent.isSymPressed());

        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_3, 2,
                KeyEvent.META_META_ON);
        assertFalse(mKeyEvent.isAltPressed());
        assertFalse(mKeyEvent.isCtrlPressed());
        assertFalse(mKeyEvent.isFunctionPressed());
        assertTrue(mKeyEvent.isMetaPressed());
        assertFalse(mKeyEvent.isShiftPressed());
        assertFalse(mKeyEvent.isSymPressed());

        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_4, 1,
                KeyEvent.META_SHIFT_ON);
        assertFalse(mKeyEvent.isAltPressed());
        assertFalse(mKeyEvent.isCtrlPressed());
        assertFalse(mKeyEvent.isFunctionPressed());
        assertFalse(mKeyEvent.isMetaPressed());
        assertTrue(mKeyEvent.isShiftPressed());
        assertFalse(mKeyEvent.isSymPressed());

        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_5, 0,
                KeyEvent.META_SYM_ON);
        assertFalse(mKeyEvent.isAltPressed());
        assertFalse(mKeyEvent.isCtrlPressed());
        assertFalse(mKeyEvent.isFunctionPressed());
        assertFalse(mKeyEvent.isMetaPressed());
        assertFalse(mKeyEvent.isShiftPressed());
        assertTrue(mKeyEvent.isSymPressed());
    }

    @Test
    public void testGetDeadChar() {
        // decimal number of &egrave; is 232.
        assertEquals(232, KeyEvent.getDeadChar('`', 'e'));
    }

    @Test
    public void testGetKeyData() {
        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_Z);
        KeyData keyData = new KeyData();
        assertTrue(mKeyEvent.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]);
    }

    @Test
    public void testDispatch() {
        final KeyEvent.Callback callback = mock(KeyEvent.Callback.class);
        doReturn(true).when(callback).onKeyDown(anyInt(), any(KeyEvent.class));
        doReturn(true).when(callback).onKeyUp(anyInt(), any(KeyEvent.class));
        doAnswer((InvocationOnMock invocation) -> {
            final int count = (Integer) invocation.getArguments()[1];
            return (count < 1) ? false : true;
        }).when(callback).onKeyMultiple(anyInt(), anyInt(), any(KeyEvent.class));

        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0);
        verify(callback, never()).onKeyDown(anyInt(), any(KeyEvent.class));
        assertTrue(mKeyEvent.dispatch(callback));
        verify(callback, times(1)).onKeyDown(KeyEvent.KEYCODE_0, mKeyEvent);
        verifyNoMoreInteractions(callback);

        mKeyEvent = new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_0);
        verify(callback, never()).onKeyUp(anyInt(), any(KeyEvent.class));
        assertTrue(mKeyEvent.dispatch(callback));
        verify(callback, times(1)).onKeyUp(KeyEvent.KEYCODE_0, mKeyEvent);
        verifyNoMoreInteractions(callback);

        int count = 2;
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_MULTIPLE,
                KeyEvent.KEYCODE_0, count);
        verify(callback, never()).onKeyMultiple(anyInt(), anyInt(), any(KeyEvent.class));
        assertTrue(mKeyEvent.dispatch(callback));
        verify(callback, times(1)).onKeyMultiple(KeyEvent.KEYCODE_0, count, mKeyEvent);
        verifyNoMoreInteractions(callback);

        count = 0;
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_MULTIPLE,
                KeyEvent.KEYCODE_0, count);
        assertTrue(mKeyEvent.dispatch(callback));
        // Note that even though we didn't reset our mock callback, we have a brand new
        // instance of KeyEvent in mKeyEvent. This is why we're expecting the relevant
        // onKeyXXX() methods on the mock callback to be called once with that new KeyEvent
        // instance.
        verify(callback, times(1)).onKeyDown(KeyEvent.KEYCODE_0, mKeyEvent);
        verify(callback, times(1)).onKeyMultiple(KeyEvent.KEYCODE_0, count, mKeyEvent);
        verify(callback, times(1)).onKeyUp(KeyEvent.KEYCODE_0, mKeyEvent);
        verifyNoMoreInteractions(callback);
    }

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

    @Test
    public void testGetEventTime() {
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN,
                KeyEvent.KEYCODE_0, 5);
        assertEquals(mEventTime, mKeyEvent.getEventTime());
    }

    @Test
    public void testGetDownTime() {
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN,
                KeyEvent.KEYCODE_0, 5);
        assertEquals(mDownTime, mKeyEvent.getDownTime());
    }

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

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

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

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

    @Test
    public void testToString() {
        // make sure it does not throw any exception.
        mKeyEvent.toString();
    }

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

    @Test
    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;

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

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

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

    @Test
    public void testHasNoModifiers() {
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN,
                KeyEvent.KEYCODE_A, 0, KeyEvent.META_CAPS_LOCK_ON);
        assertTrue(mKeyEvent.hasNoModifiers());

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

    @Test
    public void testHasModifiers() {
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN,
                KeyEvent.KEYCODE_A, 0, KeyEvent.META_CAPS_LOCK_ON);
        assertTrue(mKeyEvent.hasModifiers(0));

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

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

    @Test
    public void testGetDisplayLabel() {
        assertTrue(mKeyEvent.getDisplayLabel() > 0);
    }

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

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

    @Test
    public void testGetMatch() {
        // Our default key event is down + 0, so we expect getMatch to return our '0' character
        assertEquals('0', mKeyEvent.getMatch(new char[] { '0', '1', '2' }));

        // Our default key event is down + 0, so we expect getMatch to return the default 0
        assertEquals('\0', mKeyEvent.getMatch(new char[] { 'A', 'B', 'C' }));

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

    @Test
    public void testGetMatchWithMeta() {
        mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A);
        // With no meta state, we're expecting our key event to match the lowercase 'a' since
        // it's the first good match in the passed array
        assertEquals('a', mKeyEvent.getMatch(new char[] { 'a', 'A' }, 0));
        // With SHIFT_ON meta state, we're expecting the same key event to match the uppercase
        // 'a' since it's a better match now
        assertEquals('A', mKeyEvent.getMatch(new char[] { 'a', 'A' }, KeyEvent.META_SHIFT_ON));
    }

    @Test
    public void testGetAction() {
        assertEquals(KeyEvent.ACTION_DOWN, mKeyEvent.getAction());
    }

    @Test
    public void testGetRepeatCount() {
        int repeatCount = 1;
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_MULTIPLE,
                KeyEvent.KEYCODE_0, repeatCount);
        assertEquals(repeatCount, mKeyEvent.getRepeatCount());
    }

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

    @Test
    public void testDescribeContents() {
        // make sure it never shrow any exception.
        mKeyEvent.describeContents();
    }

    @Test
    public void testGetKeyCode() {
        assertEquals(KeyEvent.KEYCODE_0, mKeyEvent.getKeyCode());
    }

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

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

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

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

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

    @Test
    public void testAccessSource() {
        mKeyEvent.setSource(InputDevice.SOURCE_KEYBOARD);
        assertEquals(InputDevice.SOURCE_KEYBOARD, mKeyEvent.getSource());

        mKeyEvent.setSource(InputDevice.SOURCE_HDMI);
        assertEquals(InputDevice.SOURCE_HDMI, mKeyEvent.getSource());
    }

    @Test
    public void testMetaOn() {
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN,
                KeyEvent.KEYCODE_A, 0, KeyEvent.META_CAPS_LOCK_ON | KeyEvent.META_SHIFT_ON);
        assertTrue(mKeyEvent.isCapsLockOn());
        assertFalse(mKeyEvent.isNumLockOn());
        assertFalse(mKeyEvent.isScrollLockOn());

        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN,
                KeyEvent.KEYCODE_B, 1, KeyEvent.META_NUM_LOCK_ON | KeyEvent.META_SHIFT_ON);
        assertFalse(mKeyEvent.isCapsLockOn());
        assertTrue(mKeyEvent.isNumLockOn());
        assertFalse(mKeyEvent.isScrollLockOn());

        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN,
                KeyEvent.KEYCODE_C, 2, KeyEvent.META_SCROLL_LOCK_ON | KeyEvent.META_SHIFT_ON);
        assertFalse(mKeyEvent.isCapsLockOn());
        assertFalse(mKeyEvent.isNumLockOn());
        assertTrue(mKeyEvent.isScrollLockOn());
    }

    @Test
    public void testIsLongPress() {
        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A,
                1, 0, KeyCharacterMap.VIRTUAL_KEYBOARD, 0, KeyEvent.FLAG_LONG_PRESS,
                InputDevice.SOURCE_TOUCHSCREEN);
        assertTrue(mKeyEvent.isLongPress());

        mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A,
                1, 0, KeyCharacterMap.VIRTUAL_KEYBOARD, 0, 0, InputDevice.SOURCE_TOUCHSCREEN);
        assertFalse(mKeyEvent.isLongPress());
    }
}