1 /* 2 * Copyright (C) 2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.view.cts; 18 19 import static org.junit.Assert.assertEquals; 20 import static org.junit.Assert.assertFalse; 21 import static org.junit.Assert.assertNull; 22 import static org.junit.Assert.assertTrue; 23 import static org.mockito.Matchers.any; 24 import static org.mockito.Matchers.anyInt; 25 import static org.mockito.Mockito.doAnswer; 26 import static org.mockito.Mockito.doReturn; 27 import static org.mockito.Mockito.mock; 28 import static org.mockito.Mockito.never; 29 import static org.mockito.Mockito.times; 30 import static org.mockito.Mockito.verify; 31 import static org.mockito.Mockito.verifyNoMoreInteractions; 32 33 import android.os.Parcel; 34 import android.os.Parcelable; 35 import android.os.SystemClock; 36 import android.text.method.MetaKeyKeyListener; 37 import android.view.InputDevice; 38 import android.view.KeyCharacterMap; 39 import android.view.KeyCharacterMap.KeyData; 40 import android.view.KeyEvent; 41 42 import androidx.test.filters.SmallTest; 43 import androidx.test.runner.AndroidJUnit4; 44 45 import junit.framework.Assert; 46 47 import org.junit.Before; 48 import org.junit.Test; 49 import org.junit.runner.RunWith; 50 import org.mockito.invocation.InvocationOnMock; 51 52 /** 53 * Test {@link KeyEvent}. 54 */ 55 @SmallTest 56 @RunWith(AndroidJUnit4.class) 57 public class KeyEventTest { 58 private KeyEvent mKeyEvent; 59 private long mDownTime; 60 private long mEventTime; 61 nativeKeyEventTest(KeyEvent event)62 private static native void nativeKeyEventTest(KeyEvent event); 63 64 static { 65 System.loadLibrary("ctsview_jni"); 66 } 67 68 @Before setup()69 public void setup() { 70 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0); 71 72 mDownTime = SystemClock.uptimeMillis(); 73 mEventTime = SystemClock.uptimeMillis(); 74 } 75 76 @Test testConstructor()77 public void testConstructor() { 78 new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0); 79 80 new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5); 81 82 new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5, 83 KeyEvent.META_SHIFT_ON); 84 85 new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5, 86 KeyEvent.META_SHIFT_ON, 1, 1); 87 88 new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5, 89 KeyEvent.META_SHIFT_ON, 1, 1, KeyEvent.FLAG_SOFT_KEYBOARD); 90 91 KeyEvent keyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0); 92 new KeyEvent(keyEvent); 93 new KeyEvent(keyEvent, mEventTime, 1); 94 95 new KeyEvent(mDownTime, "test", 0, KeyEvent.FLAG_SOFT_KEYBOARD); 96 } 97 98 @Test testGetCharacters()99 public void testGetCharacters() { 100 String characters = "android_test"; 101 mKeyEvent = new KeyEvent(mDownTime, characters, 0, KeyEvent.FLAG_SOFT_KEYBOARD); 102 assertEquals(KeyEvent.ACTION_MULTIPLE, mKeyEvent.getAction()); 103 assertEquals(KeyEvent.KEYCODE_UNKNOWN, mKeyEvent.getKeyCode()); 104 assertEquals(characters, mKeyEvent.getCharacters()); 105 106 // Make sure mCharacters survives after serialization / deserialization 107 KeyEvent keyEvent = parcelUnparcel(mKeyEvent); 108 assertEquals(mKeyEvent.getCharacters(), keyEvent.getCharacters()); 109 110 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0); 111 assertNull(mKeyEvent.getCharacters()); 112 } 113 114 @Test testGetMaxKeyCode()115 public void testGetMaxKeyCode() { 116 assertTrue(KeyEvent.getMaxKeyCode() > 0); 117 } 118 119 @Test testMetaKeyStates()120 public void testMetaKeyStates() { 121 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5, 122 KeyEvent.META_ALT_ON); 123 assertTrue(mKeyEvent.isAltPressed()); 124 assertFalse(mKeyEvent.isCtrlPressed()); 125 assertFalse(mKeyEvent.isFunctionPressed()); 126 assertFalse(mKeyEvent.isMetaPressed()); 127 assertFalse(mKeyEvent.isShiftPressed()); 128 assertFalse(mKeyEvent.isSymPressed()); 129 130 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_1, 4, 131 KeyEvent.META_CTRL_ON); 132 assertFalse(mKeyEvent.isAltPressed()); 133 assertTrue(mKeyEvent.isCtrlPressed()); 134 assertFalse(mKeyEvent.isFunctionPressed()); 135 assertFalse(mKeyEvent.isMetaPressed()); 136 assertFalse(mKeyEvent.isShiftPressed()); 137 assertFalse(mKeyEvent.isSymPressed()); 138 139 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_2, 3, 140 KeyEvent.META_FUNCTION_ON); 141 assertFalse(mKeyEvent.isAltPressed()); 142 assertFalse(mKeyEvent.isCtrlPressed()); 143 assertTrue(mKeyEvent.isFunctionPressed()); 144 assertFalse(mKeyEvent.isMetaPressed()); 145 assertFalse(mKeyEvent.isShiftPressed()); 146 assertFalse(mKeyEvent.isSymPressed()); 147 148 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_3, 2, 149 KeyEvent.META_META_ON); 150 assertFalse(mKeyEvent.isAltPressed()); 151 assertFalse(mKeyEvent.isCtrlPressed()); 152 assertFalse(mKeyEvent.isFunctionPressed()); 153 assertTrue(mKeyEvent.isMetaPressed()); 154 assertFalse(mKeyEvent.isShiftPressed()); 155 assertFalse(mKeyEvent.isSymPressed()); 156 157 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_4, 1, 158 KeyEvent.META_SHIFT_ON); 159 assertFalse(mKeyEvent.isAltPressed()); 160 assertFalse(mKeyEvent.isCtrlPressed()); 161 assertFalse(mKeyEvent.isFunctionPressed()); 162 assertFalse(mKeyEvent.isMetaPressed()); 163 assertTrue(mKeyEvent.isShiftPressed()); 164 assertFalse(mKeyEvent.isSymPressed()); 165 166 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_5, 0, 167 KeyEvent.META_SYM_ON); 168 assertFalse(mKeyEvent.isAltPressed()); 169 assertFalse(mKeyEvent.isCtrlPressed()); 170 assertFalse(mKeyEvent.isFunctionPressed()); 171 assertFalse(mKeyEvent.isMetaPressed()); 172 assertFalse(mKeyEvent.isShiftPressed()); 173 assertTrue(mKeyEvent.isSymPressed()); 174 } 175 176 @Test testGetDeadChar()177 public void testGetDeadChar() { 178 // decimal number of è is 232. 179 assertEquals(232, KeyEvent.getDeadChar('`', 'e')); 180 } 181 182 @Test testGetKeyData()183 public void testGetKeyData() { 184 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_Z); 185 KeyData keyData = new KeyData(); 186 assertTrue(mKeyEvent.getKeyData(keyData)); 187 188 assertEquals('Z', keyData.displayLabel); 189 assertEquals(0, keyData.number); 190 assertEquals('z', keyData.meta[0]); 191 assertEquals('Z', keyData.meta[1]); 192 assertEquals(0, keyData.meta[3]); 193 } 194 195 @Test testDispatch()196 public void testDispatch() { 197 final KeyEvent.Callback callback = mock(KeyEvent.Callback.class); 198 doReturn(true).when(callback).onKeyDown(anyInt(), any(KeyEvent.class)); 199 doReturn(true).when(callback).onKeyUp(anyInt(), any(KeyEvent.class)); 200 doAnswer((InvocationOnMock invocation) -> { 201 final int count = (Integer) invocation.getArguments()[1]; 202 return (count < 1) ? false : true; 203 }).when(callback).onKeyMultiple(anyInt(), anyInt(), any(KeyEvent.class)); 204 205 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0); 206 verify(callback, never()).onKeyDown(anyInt(), any(KeyEvent.class)); 207 assertTrue(mKeyEvent.dispatch(callback)); 208 verify(callback, times(1)).onKeyDown(KeyEvent.KEYCODE_0, mKeyEvent); 209 verifyNoMoreInteractions(callback); 210 211 mKeyEvent = new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_0); 212 verify(callback, never()).onKeyUp(anyInt(), any(KeyEvent.class)); 213 assertTrue(mKeyEvent.dispatch(callback)); 214 verify(callback, times(1)).onKeyUp(KeyEvent.KEYCODE_0, mKeyEvent); 215 verifyNoMoreInteractions(callback); 216 217 int count = 2; 218 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_MULTIPLE, 219 KeyEvent.KEYCODE_0, count); 220 verify(callback, never()).onKeyMultiple(anyInt(), anyInt(), any(KeyEvent.class)); 221 assertTrue(mKeyEvent.dispatch(callback)); 222 verify(callback, times(1)).onKeyMultiple(KeyEvent.KEYCODE_0, count, mKeyEvent); 223 verifyNoMoreInteractions(callback); 224 225 count = 0; 226 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_MULTIPLE, 227 KeyEvent.KEYCODE_0, count); 228 assertTrue(mKeyEvent.dispatch(callback)); 229 // Note that even though we didn't reset our mock callback, we have a brand new 230 // instance of KeyEvent in mKeyEvent. This is why we're expecting the relevant 231 // onKeyXXX() methods on the mock callback to be called once with that new KeyEvent 232 // instance. 233 verify(callback, times(1)).onKeyDown(KeyEvent.KEYCODE_0, mKeyEvent); 234 verify(callback, times(1)).onKeyMultiple(KeyEvent.KEYCODE_0, count, mKeyEvent); 235 verify(callback, times(1)).onKeyUp(KeyEvent.KEYCODE_0, mKeyEvent); 236 verifyNoMoreInteractions(callback); 237 } 238 239 @Test testGetMetaState()240 public void testGetMetaState() { 241 int metaState = KeyEvent.META_ALT_ON; 242 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_MULTIPLE, 243 KeyEvent.KEYCODE_1, 1, metaState); 244 assertEquals(metaState, mKeyEvent.getMetaState()); 245 } 246 247 @Test testGetEventTime()248 public void testGetEventTime() { 249 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 250 KeyEvent.KEYCODE_0, 5); 251 assertEquals(mEventTime, mKeyEvent.getEventTime()); 252 } 253 254 @Test testGetDownTime()255 public void testGetDownTime() { 256 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 257 KeyEvent.KEYCODE_0, 5); 258 assertEquals(mDownTime, mKeyEvent.getDownTime()); 259 } 260 261 @Test testGetUnicodeChar1()262 public void testGetUnicodeChar1() { 263 // 48 is Unicode character of '0' 264 assertEquals(48, mKeyEvent.getUnicodeChar()); 265 266 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 267 KeyEvent.KEYCODE_9, 5, 0); 268 // 57 is Unicode character of '9' 269 assertEquals(57, mKeyEvent.getUnicodeChar()); 270 271 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 272 KeyEvent.KEYCODE_ALT_LEFT, 5, KeyEvent.META_SHIFT_ON); 273 // 'ALT' key is not a type Unicode character. 274 assertEquals(0, mKeyEvent.getUnicodeChar()); 275 } 276 277 @Test testGetUnicodeChar2()278 public void testGetUnicodeChar2() { 279 // 48 is Unicode character of '0' 280 assertEquals(48, mKeyEvent.getUnicodeChar(MetaKeyKeyListener.META_CAP_LOCKED)); 281 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 282 KeyEvent.KEYCODE_9, 5, 0); 283 284 // 57 is Unicode character of '9' 285 assertEquals(57, mKeyEvent.getUnicodeChar(0)); 286 287 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 288 KeyEvent.KEYCODE_ALT_LEFT, 5, KeyEvent.META_SHIFT_ON); 289 // 'ALT' key is not a type Unicode character. 290 assertEquals(0, mKeyEvent.getUnicodeChar(0)); 291 } 292 293 @Test testGetNumber()294 public void testGetNumber() { 295 // 48 is associated with key '0' 296 assertEquals(48, mKeyEvent.getNumber()); 297 298 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_3); 299 // 51 is associated with key '3' 300 assertEquals(51, mKeyEvent.getNumber()); 301 } 302 303 @Test testGetDeviceId()304 public void testGetDeviceId() { 305 int deviceId = 1; 306 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5, 307 KeyEvent.META_SHIFT_ON, deviceId, 1); 308 assertEquals(deviceId, mKeyEvent.getDeviceId()); 309 } 310 311 @SuppressWarnings("ReturnValueIgnored") 312 @Test testToString()313 public void testToString() { 314 // make sure it does not throw any exception. 315 mKeyEvent.toString(); 316 } 317 318 @Test testGetModifierMetaStateMask()319 public void testGetModifierMetaStateMask() { 320 int mask = KeyEvent.getModifierMetaStateMask(); 321 assertTrue((mask & KeyEvent.META_SHIFT_ON) != 0); 322 assertTrue((mask & KeyEvent.META_SHIFT_LEFT_ON) != 0); 323 assertTrue((mask & KeyEvent.META_SHIFT_RIGHT_ON) != 0); 324 assertTrue((mask & KeyEvent.META_ALT_ON) != 0); 325 assertTrue((mask & KeyEvent.META_ALT_LEFT_ON) != 0); 326 assertTrue((mask & KeyEvent.META_ALT_RIGHT_ON) != 0); 327 assertTrue((mask & KeyEvent.META_CTRL_ON) != 0); 328 assertTrue((mask & KeyEvent.META_CTRL_LEFT_ON) != 0); 329 assertTrue((mask & KeyEvent.META_CTRL_RIGHT_ON) != 0); 330 assertTrue((mask & KeyEvent.META_META_ON) != 0); 331 assertTrue((mask & KeyEvent.META_META_LEFT_ON) != 0); 332 assertTrue((mask & KeyEvent.META_META_RIGHT_ON) != 0); 333 assertTrue((mask & KeyEvent.META_SYM_ON) != 0); 334 assertTrue((mask & KeyEvent.META_FUNCTION_ON) != 0); 335 336 assertFalse((mask & KeyEvent.META_CAPS_LOCK_ON) != 0); 337 assertFalse((mask & KeyEvent.META_NUM_LOCK_ON) != 0); 338 assertFalse((mask & KeyEvent.META_SCROLL_LOCK_ON) != 0); 339 } 340 341 @Test testIsModifierKey()342 public void testIsModifierKey() { 343 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_SHIFT_LEFT)); 344 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_SHIFT_RIGHT)); 345 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_ALT_LEFT)); 346 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_ALT_RIGHT)); 347 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_CTRL_LEFT)); 348 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_CTRL_RIGHT)); 349 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_META_LEFT)); 350 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_META_RIGHT)); 351 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_SYM)); 352 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_NUM)); 353 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_FUNCTION)); 354 355 assertFalse(KeyEvent.isModifierKey(KeyEvent.KEYCODE_0)); 356 } 357 358 private static final int UNDEFINED_META_STATE = 0x80000000; 359 360 @Test testNormalizeMetaState()361 public void testNormalizeMetaState() { 362 // Already normalized values. 363 assertEquals(0, KeyEvent.normalizeMetaState(0)); 364 assertEquals(KeyEvent.getModifierMetaStateMask(), 365 KeyEvent.normalizeMetaState(KeyEvent.getModifierMetaStateMask())); 366 367 // Values that require normalization. 368 assertEquals(KeyEvent.META_SHIFT_LEFT_ON | KeyEvent.META_SHIFT_ON, 369 KeyEvent.normalizeMetaState(KeyEvent.META_SHIFT_LEFT_ON)); 370 assertEquals(KeyEvent.META_SHIFT_RIGHT_ON | KeyEvent.META_SHIFT_ON, 371 KeyEvent.normalizeMetaState(KeyEvent.META_SHIFT_RIGHT_ON)); 372 assertEquals(KeyEvent.META_ALT_LEFT_ON | KeyEvent.META_ALT_ON, 373 KeyEvent.normalizeMetaState(KeyEvent.META_ALT_LEFT_ON)); 374 assertEquals(KeyEvent.META_ALT_RIGHT_ON | KeyEvent.META_ALT_ON, 375 KeyEvent.normalizeMetaState(KeyEvent.META_ALT_RIGHT_ON)); 376 assertEquals(KeyEvent.META_CTRL_LEFT_ON | KeyEvent.META_CTRL_ON, 377 KeyEvent.normalizeMetaState(KeyEvent.META_CTRL_LEFT_ON)); 378 assertEquals(KeyEvent.META_CTRL_RIGHT_ON | KeyEvent.META_CTRL_ON, 379 KeyEvent.normalizeMetaState(KeyEvent.META_CTRL_RIGHT_ON)); 380 assertEquals(KeyEvent.META_META_LEFT_ON | KeyEvent.META_META_ON, 381 KeyEvent.normalizeMetaState(KeyEvent.META_META_LEFT_ON)); 382 assertEquals(KeyEvent.META_META_RIGHT_ON | KeyEvent.META_META_ON, 383 KeyEvent.normalizeMetaState(KeyEvent.META_META_RIGHT_ON)); 384 assertEquals(KeyEvent.META_CAPS_LOCK_ON, 385 KeyEvent.normalizeMetaState(MetaKeyKeyListener.META_CAP_LOCKED)); 386 assertEquals(KeyEvent.META_ALT_ON, 387 KeyEvent.normalizeMetaState(MetaKeyKeyListener.META_ALT_LOCKED)); 388 assertEquals(KeyEvent.META_SYM_ON, 389 KeyEvent.normalizeMetaState(MetaKeyKeyListener.META_SYM_LOCKED)); 390 assertEquals(KeyEvent.META_SHIFT_ON, 391 KeyEvent.normalizeMetaState(KeyEvent.META_SHIFT_ON | UNDEFINED_META_STATE)); 392 } 393 394 @Test testMetaStateHasNoModifiers()395 public void testMetaStateHasNoModifiers() { 396 assertTrue(KeyEvent.metaStateHasNoModifiers(0)); 397 assertTrue(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_CAPS_LOCK_ON)); 398 assertTrue(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_NUM_LOCK_ON)); 399 assertTrue(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_SCROLL_LOCK_ON)); 400 401 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_SHIFT_ON)); 402 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_SHIFT_LEFT_ON)); 403 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_SHIFT_RIGHT_ON)); 404 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_ALT_ON)); 405 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_ALT_LEFT_ON)); 406 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_ALT_RIGHT_ON)); 407 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_CTRL_ON)); 408 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_CTRL_LEFT_ON)); 409 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_CTRL_RIGHT_ON)); 410 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_META_ON)); 411 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_META_LEFT_ON)); 412 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_META_RIGHT_ON)); 413 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_SYM_ON)); 414 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_FUNCTION_ON)); 415 } 416 417 @Test testMetaStateHasModifiers()418 public void testMetaStateHasModifiers() { 419 assertTrue(KeyEvent.metaStateHasModifiers(0, 0)); 420 assertTrue(KeyEvent.metaStateHasModifiers( 421 KeyEvent.META_NUM_LOCK_ON | KeyEvent.META_CAPS_LOCK_ON 422 | KeyEvent.META_SCROLL_LOCK_ON, 0)); 423 assertTrue(KeyEvent.metaStateHasModifiers( 424 KeyEvent.META_SHIFT_ON | KeyEvent.META_SHIFT_LEFT_ON, 425 KeyEvent.META_SHIFT_LEFT_ON)); 426 assertTrue(KeyEvent.metaStateHasModifiers( 427 KeyEvent.META_SHIFT_LEFT_ON | KeyEvent.META_SHIFT_RIGHT_ON, 428 KeyEvent.META_SHIFT_LEFT_ON | KeyEvent.META_SHIFT_RIGHT_ON)); 429 assertTrue(KeyEvent.metaStateHasModifiers( 430 KeyEvent.META_SHIFT_LEFT_ON, 431 KeyEvent.META_SHIFT_LEFT_ON)); 432 assertTrue(KeyEvent.metaStateHasModifiers( 433 KeyEvent.META_NUM_LOCK_ON | KeyEvent.META_CAPS_LOCK_ON 434 | KeyEvent.META_SCROLL_LOCK_ON | KeyEvent.META_SHIFT_LEFT_ON, 435 KeyEvent.META_SHIFT_LEFT_ON)); 436 assertTrue(KeyEvent.metaStateHasModifiers( 437 KeyEvent.META_SHIFT_ON | KeyEvent.META_SHIFT_LEFT_ON, 438 KeyEvent.META_SHIFT_ON)); 439 assertTrue(KeyEvent.metaStateHasModifiers( 440 KeyEvent.META_ALT_ON | KeyEvent.META_ALT_RIGHT_ON, 441 KeyEvent.META_ALT_ON)); 442 assertTrue(KeyEvent.metaStateHasModifiers( 443 KeyEvent.META_ALT_LEFT_ON | KeyEvent.META_SHIFT_LEFT_ON, 444 KeyEvent.META_ALT_ON | KeyEvent.META_SHIFT_ON)); 445 assertTrue(KeyEvent.metaStateHasModifiers( 446 KeyEvent.META_CTRL_RIGHT_ON | KeyEvent.META_META_LEFT_ON, 447 KeyEvent.META_CTRL_RIGHT_ON | KeyEvent.META_META_ON)); 448 assertTrue(KeyEvent.metaStateHasModifiers( 449 KeyEvent.META_SYM_ON | KeyEvent.META_FUNCTION_ON | KeyEvent.META_CAPS_LOCK_ON, 450 KeyEvent.META_SYM_ON | KeyEvent.META_FUNCTION_ON)); 451 452 assertFalse(KeyEvent.metaStateHasModifiers(0, KeyEvent.META_SHIFT_ON)); 453 assertFalse(KeyEvent.metaStateHasModifiers( 454 KeyEvent.META_ALT_ON | KeyEvent.META_SHIFT_LEFT_ON, 455 KeyEvent.META_SHIFT_ON)); 456 assertFalse(KeyEvent.metaStateHasModifiers( 457 KeyEvent.META_ALT_LEFT_ON | KeyEvent.META_SHIFT_LEFT_ON, 458 KeyEvent.META_SHIFT_ON)); 459 assertFalse(KeyEvent.metaStateHasModifiers( 460 KeyEvent.META_ALT_LEFT_ON, 461 KeyEvent.META_ALT_RIGHT_ON)); 462 assertFalse(KeyEvent.metaStateHasModifiers( 463 KeyEvent.META_ALT_LEFT_ON, 464 KeyEvent.META_CTRL_LEFT_ON)); 465 466 final int[] invalidModifiers = new int[] { 467 KeyEvent.META_CAPS_LOCK_ON, 468 KeyEvent.META_NUM_LOCK_ON, 469 KeyEvent.META_SCROLL_LOCK_ON, 470 MetaKeyKeyListener.META_CAP_LOCKED, 471 MetaKeyKeyListener.META_ALT_LOCKED, 472 MetaKeyKeyListener.META_SYM_LOCKED, 473 KeyEvent.META_SHIFT_ON | KeyEvent.META_SHIFT_LEFT_ON, 474 KeyEvent.META_SHIFT_ON | KeyEvent.META_SHIFT_RIGHT_ON, 475 KeyEvent.META_SHIFT_ON | KeyEvent.META_SHIFT_LEFT_ON| KeyEvent.META_SHIFT_RIGHT_ON, 476 KeyEvent.META_ALT_ON | KeyEvent.META_ALT_LEFT_ON, 477 KeyEvent.META_ALT_ON | KeyEvent.META_ALT_RIGHT_ON, 478 KeyEvent.META_ALT_ON | KeyEvent.META_ALT_LEFT_ON| KeyEvent.META_ALT_RIGHT_ON, 479 KeyEvent.META_CTRL_ON | KeyEvent.META_CTRL_LEFT_ON, 480 KeyEvent.META_CTRL_ON | KeyEvent.META_CTRL_RIGHT_ON, 481 KeyEvent.META_CTRL_ON | KeyEvent.META_CTRL_LEFT_ON| KeyEvent.META_CTRL_RIGHT_ON, 482 KeyEvent.META_META_ON | KeyEvent.META_META_LEFT_ON, 483 KeyEvent.META_META_ON | KeyEvent.META_META_RIGHT_ON, 484 KeyEvent.META_META_ON | KeyEvent.META_META_LEFT_ON| KeyEvent.META_META_RIGHT_ON, 485 }; 486 for (int modifiers : invalidModifiers) { 487 try { 488 KeyEvent.metaStateHasModifiers(0, modifiers); 489 Assert.fail("Expected IllegalArgumentException"); 490 } catch (IllegalArgumentException ex) { 491 } 492 } 493 494 assertFalse(KeyEvent.metaStateHasModifiers(0, UNDEFINED_META_STATE)); 495 } 496 497 @Test testHasNoModifiers()498 public void testHasNoModifiers() { 499 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 500 KeyEvent.KEYCODE_A, 0, KeyEvent.META_CAPS_LOCK_ON); 501 assertTrue(mKeyEvent.hasNoModifiers()); 502 503 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 504 KeyEvent.KEYCODE_A, 0, KeyEvent.META_CAPS_LOCK_ON | KeyEvent.META_SHIFT_ON); 505 assertFalse(mKeyEvent.hasNoModifiers()); 506 } 507 508 @Test testHasModifiers()509 public void testHasModifiers() { 510 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 511 KeyEvent.KEYCODE_A, 0, KeyEvent.META_CAPS_LOCK_ON); 512 assertTrue(mKeyEvent.hasModifiers(0)); 513 514 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 515 KeyEvent.KEYCODE_A, 0, KeyEvent.META_CAPS_LOCK_ON | KeyEvent.META_SHIFT_ON); 516 assertTrue(mKeyEvent.hasModifiers(KeyEvent.META_SHIFT_ON)); 517 518 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 519 KeyEvent.KEYCODE_A, 0, 520 KeyEvent.META_CAPS_LOCK_ON | KeyEvent.META_SHIFT_ON | KeyEvent.META_SHIFT_RIGHT_ON); 521 assertFalse(mKeyEvent.hasModifiers(KeyEvent.META_SHIFT_LEFT_ON)); 522 } 523 524 @Test testGetDisplayLabel()525 public void testGetDisplayLabel() { 526 assertTrue(mKeyEvent.getDisplayLabel() > 0); 527 } 528 529 @Test testIsSystem()530 public void testIsSystem() { 531 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_MENU); 532 assertTrue(mKeyEvent.isSystem()); 533 534 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_SOFT_RIGHT); 535 assertTrue(mKeyEvent.isSystem()); 536 537 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_HOME); 538 assertTrue(mKeyEvent.isSystem()); 539 540 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BACK); 541 assertTrue(mKeyEvent.isSystem()); 542 543 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_CALL); 544 assertTrue(mKeyEvent.isSystem()); 545 546 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_ENDCALL); 547 assertTrue(mKeyEvent.isSystem()); 548 549 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_VOLUME_UP); 550 assertTrue(mKeyEvent.isSystem()); 551 552 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_VOLUME_DOWN); 553 assertTrue(mKeyEvent.isSystem()); 554 555 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_POWER); 556 assertTrue(mKeyEvent.isSystem()); 557 558 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_SEARCH); 559 assertTrue(mKeyEvent.isSystem()); 560 561 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_HEADSETHOOK); 562 assertTrue(mKeyEvent.isSystem()); 563 564 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_CAMERA); 565 assertTrue(mKeyEvent.isSystem()); 566 567 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_FOCUS); 568 assertTrue(mKeyEvent.isSystem()); 569 570 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0); 571 assertFalse(mKeyEvent.isSystem()); 572 } 573 574 @Test testIsPrintingKey()575 public void testIsPrintingKey() { 576 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, Character.SPACE_SEPARATOR); 577 assertTrue(mKeyEvent.isPrintingKey()); 578 579 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, Character.LINE_SEPARATOR); 580 assertTrue(mKeyEvent.isPrintingKey()); 581 582 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, Character.PARAGRAPH_SEPARATOR); 583 assertTrue(mKeyEvent.isPrintingKey()); 584 585 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, Character.CONTROL); 586 assertTrue(mKeyEvent.isPrintingKey()); 587 588 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, Character.FORMAT); 589 assertTrue(mKeyEvent.isPrintingKey()); 590 591 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0); 592 assertTrue(mKeyEvent.isPrintingKey()); 593 } 594 595 @Test testIsMediaSessionKey()596 public void testIsMediaSessionKey() { 597 assertTrue(KeyEvent.isMediaSessionKey(KeyEvent.KEYCODE_MEDIA_PLAY)); 598 assertTrue(KeyEvent.isMediaSessionKey(KeyEvent.KEYCODE_MEDIA_PAUSE)); 599 assertTrue(KeyEvent.isMediaSessionKey(KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE)); 600 assertTrue(KeyEvent.isMediaSessionKey(KeyEvent.KEYCODE_HEADSETHOOK)); 601 assertTrue(KeyEvent.isMediaSessionKey(KeyEvent.KEYCODE_MEDIA_STOP)); 602 assertTrue(KeyEvent.isMediaSessionKey(KeyEvent.KEYCODE_MEDIA_NEXT)); 603 assertTrue(KeyEvent.isMediaSessionKey(KeyEvent.KEYCODE_MEDIA_PREVIOUS)); 604 assertTrue(KeyEvent.isMediaSessionKey(KeyEvent.KEYCODE_MEDIA_REWIND)); 605 assertTrue(KeyEvent.isMediaSessionKey(KeyEvent.KEYCODE_MEDIA_RECORD)); 606 assertTrue(KeyEvent.isMediaSessionKey(KeyEvent.KEYCODE_MEDIA_FAST_FORWARD)); 607 608 assertFalse(KeyEvent.isMediaSessionKey(KeyEvent.KEYCODE_0)); 609 } 610 611 @Test testGetMatch()612 public void testGetMatch() { 613 // Our default key event is down + 0, so we expect getMatch to return our '0' character 614 assertEquals('0', mKeyEvent.getMatch(new char[] { '0', '1', '2' })); 615 616 // Our default key event is down + 0, so we expect getMatch to return the default 0 617 assertEquals('\0', mKeyEvent.getMatch(new char[] { 'A', 'B', 'C' })); 618 619 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_S); 620 assertEquals('S', mKeyEvent.getMatch(new char[] { '2', 'S' })); 621 } 622 623 @Test testGetMatchWithMeta()624 public void testGetMatchWithMeta() { 625 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A); 626 // With no meta state, we're expecting our key event to match the lowercase 'a' since 627 // it's the first good match in the passed array 628 assertEquals('a', mKeyEvent.getMatch(new char[] { 'a', 'A' }, 0)); 629 // With SHIFT_ON meta state, we're expecting the same key event to match the uppercase 630 // 'a' since it's a better match now 631 assertEquals('A', mKeyEvent.getMatch(new char[] { 'a', 'A' }, KeyEvent.META_SHIFT_ON)); 632 } 633 634 @Test testGetAction()635 public void testGetAction() { 636 assertEquals(KeyEvent.ACTION_DOWN, mKeyEvent.getAction()); 637 } 638 639 @Test testGetRepeatCount()640 public void testGetRepeatCount() { 641 int repeatCount = 1; 642 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_MULTIPLE, 643 KeyEvent.KEYCODE_0, repeatCount); 644 assertEquals(repeatCount, mKeyEvent.getRepeatCount()); 645 } 646 647 @Test testWriteToParcel()648 public void testWriteToParcel() { 649 KeyEvent keyEvent = parcelUnparcel(mKeyEvent); 650 651 assertEquals(mKeyEvent.getAction(), keyEvent.getAction()); 652 assertEquals(mKeyEvent.getKeyCode(), keyEvent.getKeyCode()); 653 assertEquals(mKeyEvent.getRepeatCount(), keyEvent.getRepeatCount()); 654 assertEquals(mKeyEvent.getMetaState(), keyEvent.getMetaState()); 655 assertEquals(mKeyEvent.getDeviceId(), keyEvent.getDeviceId()); 656 assertEquals(mKeyEvent.getScanCode(), keyEvent.getScanCode()); 657 assertEquals(mKeyEvent.getFlags(), keyEvent.getFlags()); 658 assertEquals(mKeyEvent.getDownTime(), keyEvent.getDownTime()); 659 assertEquals(mKeyEvent.getEventTime(), keyEvent.getEventTime()); 660 assertEquals(mKeyEvent.getCharacters(), keyEvent.getCharacters()); 661 } 662 663 @Test testDescribeContents()664 public void testDescribeContents() { 665 // make sure it never shrow any exception. 666 mKeyEvent.describeContents(); 667 } 668 669 @Test testGetKeyCode()670 public void testGetKeyCode() { 671 assertEquals(KeyEvent.KEYCODE_0, mKeyEvent.getKeyCode()); 672 } 673 674 @Test testGetFlags()675 public void testGetFlags() { 676 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 677 KeyEvent.KEYCODE_0, 5, KeyEvent.META_SHIFT_ON, 1, 1, KeyEvent.FLAG_WOKE_HERE); 678 assertEquals(KeyEvent.FLAG_WOKE_HERE, mKeyEvent.getFlags()); 679 680 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 681 KeyEvent.KEYCODE_0, 5, KeyEvent.META_SHIFT_ON, 1, 1, KeyEvent.FLAG_SOFT_KEYBOARD); 682 assertEquals(KeyEvent.FLAG_SOFT_KEYBOARD, mKeyEvent.getFlags()); 683 } 684 685 @Test testGetScanCode()686 public void testGetScanCode() { 687 int scanCode = 1; 688 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 689 KeyEvent.KEYCODE_0, 5, KeyEvent.META_SHIFT_ON, 1, scanCode); 690 assertEquals(scanCode, mKeyEvent.getScanCode()); 691 } 692 693 @Test testChangeAction()694 public void testChangeAction() { 695 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 696 KeyEvent.KEYCODE_0, 5, KeyEvent.META_SHIFT_ON, 1, 1, KeyEvent.FLAG_WOKE_HERE); 697 698 KeyEvent newEvent = KeyEvent.changeAction(mKeyEvent, KeyEvent.ACTION_UP); 699 assertEquals(KeyEvent.ACTION_UP, newEvent.getAction()); 700 assertEquals(mKeyEvent.getFlags(), newEvent.getFlags()); 701 assertEquals(mKeyEvent.getCharacters(), newEvent.getCharacters()); 702 assertEquals(mKeyEvent.getDisplayLabel(), newEvent.getDisplayLabel()); 703 assertEquals(mKeyEvent.getDeviceId(), newEvent.getDeviceId()); 704 assertEquals(mKeyEvent.getDownTime(), newEvent.getDownTime()); 705 assertEquals(mKeyEvent.getEventTime(), newEvent.getEventTime()); 706 assertEquals(mKeyEvent.getKeyCode(), newEvent.getKeyCode()); 707 assertEquals(mKeyEvent.getRepeatCount(), newEvent.getRepeatCount()); 708 } 709 710 @Test testChangeFlags()711 public void testChangeFlags() { 712 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 713 KeyEvent.KEYCODE_0, 5, KeyEvent.META_SHIFT_ON, 1, 1, KeyEvent.FLAG_WOKE_HERE); 714 715 KeyEvent newEvent = KeyEvent.changeFlags(mKeyEvent, KeyEvent.FLAG_FROM_SYSTEM); 716 assertEquals(KeyEvent.FLAG_FROM_SYSTEM, newEvent.getFlags()); 717 assertEquals(mKeyEvent.getAction(), newEvent.getAction()); 718 assertEquals(mKeyEvent.getCharacters(), newEvent.getCharacters()); 719 assertEquals(mKeyEvent.getDisplayLabel(), newEvent.getDisplayLabel()); 720 assertEquals(mKeyEvent.getDeviceId(), newEvent.getDeviceId()); 721 assertEquals(mKeyEvent.getDownTime(), newEvent.getDownTime()); 722 assertEquals(mKeyEvent.getEventTime(), newEvent.getEventTime()); 723 assertEquals(mKeyEvent.getKeyCode(), newEvent.getKeyCode()); 724 assertEquals(mKeyEvent.getRepeatCount(), newEvent.getRepeatCount()); 725 } 726 727 @Test testChangeTimeRepeat()728 public void testChangeTimeRepeat() { 729 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 730 KeyEvent.KEYCODE_0, 5, KeyEvent.META_SHIFT_ON, 1, 1, KeyEvent.FLAG_WOKE_HERE); 731 732 long newEventTime = SystemClock.uptimeMillis(); 733 int newRepeat = mKeyEvent.getRepeatCount() + 1; 734 KeyEvent newEvent = KeyEvent.changeTimeRepeat(mKeyEvent, newEventTime, newRepeat); 735 assertEquals(newEventTime, newEvent.getEventTime()); 736 assertEquals(newRepeat, newEvent.getRepeatCount()); 737 assertEquals(mKeyEvent.getFlags(), newEvent.getFlags()); 738 assertEquals(mKeyEvent.getAction(), newEvent.getAction()); 739 assertEquals(mKeyEvent.getCharacters(), newEvent.getCharacters()); 740 assertEquals(mKeyEvent.getDisplayLabel(), newEvent.getDisplayLabel()); 741 assertEquals(mKeyEvent.getDeviceId(), newEvent.getDeviceId()); 742 assertEquals(mKeyEvent.getDownTime(), newEvent.getDownTime()); 743 assertEquals(mKeyEvent.getKeyCode(), newEvent.getKeyCode()); 744 } 745 746 @Test testAccessSource()747 public void testAccessSource() { 748 mKeyEvent.setSource(InputDevice.SOURCE_KEYBOARD); 749 assertEquals(InputDevice.SOURCE_KEYBOARD, mKeyEvent.getSource()); 750 751 mKeyEvent.setSource(InputDevice.SOURCE_HDMI); 752 assertEquals(InputDevice.SOURCE_HDMI, mKeyEvent.getSource()); 753 } 754 755 @Test testMetaOn()756 public void testMetaOn() { 757 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 758 KeyEvent.KEYCODE_A, 0, KeyEvent.META_CAPS_LOCK_ON | KeyEvent.META_SHIFT_ON); 759 assertTrue(mKeyEvent.isCapsLockOn()); 760 assertFalse(mKeyEvent.isNumLockOn()); 761 assertFalse(mKeyEvent.isScrollLockOn()); 762 763 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 764 KeyEvent.KEYCODE_B, 1, KeyEvent.META_NUM_LOCK_ON | KeyEvent.META_SHIFT_ON); 765 assertFalse(mKeyEvent.isCapsLockOn()); 766 assertTrue(mKeyEvent.isNumLockOn()); 767 assertFalse(mKeyEvent.isScrollLockOn()); 768 769 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 770 KeyEvent.KEYCODE_C, 2, KeyEvent.META_SCROLL_LOCK_ON | KeyEvent.META_SHIFT_ON); 771 assertFalse(mKeyEvent.isCapsLockOn()); 772 assertFalse(mKeyEvent.isNumLockOn()); 773 assertTrue(mKeyEvent.isScrollLockOn()); 774 } 775 776 @Test testIsLongPress()777 public void testIsLongPress() { 778 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A, 779 1, 0, KeyCharacterMap.VIRTUAL_KEYBOARD, 0, KeyEvent.FLAG_LONG_PRESS, 780 InputDevice.SOURCE_TOUCHSCREEN); 781 assertTrue(mKeyEvent.isLongPress()); 782 783 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A, 784 1, 0, KeyCharacterMap.VIRTUAL_KEYBOARD, 0, 0, InputDevice.SOURCE_TOUCHSCREEN); 785 assertFalse(mKeyEvent.isLongPress()); 786 } 787 788 @Test testKeyCodeFromString()789 public void testKeyCodeFromString() { 790 assertEquals(KeyEvent.KEYCODE_A, KeyEvent.keyCodeFromString("KEYCODE_A")); 791 assertEquals(KeyEvent.KEYCODE_A, KeyEvent.keyCodeFromString("A")); 792 assertEquals(KeyEvent.KEYCODE_A, 793 KeyEvent.keyCodeFromString(Integer.toString(KeyEvent.KEYCODE_A))); 794 assertEquals(KeyEvent.KEYCODE_UNKNOWN, KeyEvent.keyCodeFromString("keycode_a")); 795 assertEquals(KeyEvent.KEYCODE_UNKNOWN, KeyEvent.keyCodeFromString("a")); 796 assertEquals(0, KeyEvent.keyCodeFromString("0")); 797 assertEquals(1, KeyEvent.keyCodeFromString("1")); 798 assertEquals(KeyEvent.KEYCODE_HOME, KeyEvent.keyCodeFromString("3")); 799 assertEquals(KeyEvent.KEYCODE_POWER, 800 KeyEvent.keyCodeFromString(Integer.toString(KeyEvent.KEYCODE_POWER))); 801 assertEquals(KeyEvent.KEYCODE_MENU, 802 KeyEvent.keyCodeFromString(Integer.toString(KeyEvent.KEYCODE_MENU))); 803 assertEquals(KeyEvent.KEYCODE_BACK, KeyEvent.keyCodeFromString("BACK")); 804 assertEquals(KeyEvent.KEYCODE_UNKNOWN, KeyEvent.keyCodeFromString("back")); 805 806 assertEquals(KeyEvent.KEYCODE_UNKNOWN, 807 KeyEvent.keyCodeFromString("KEYCODE_NOT_A_REAL_KEYCODE")); 808 assertEquals(KeyEvent.KEYCODE_UNKNOWN, KeyEvent.keyCodeFromString("NOT_A_REAL_KEYCODE")); 809 assertEquals(KeyEvent.KEYCODE_UNKNOWN, KeyEvent.keyCodeFromString("-1")); 810 assertEquals(KeyEvent.KEYCODE_UNKNOWN, KeyEvent.keyCodeFromString("1001")); 811 assertEquals(KeyEvent.KEYCODE_UNKNOWN, KeyEvent.keyCodeFromString("KEYCODE_123")); 812 assertEquals(KeyEvent.KEYCODE_UNKNOWN, KeyEvent.keyCodeFromString("KEYCODE")); 813 assertEquals(KeyEvent.KEYCODE_UNKNOWN, KeyEvent.keyCodeFromString("KEYCODE_")); 814 assertEquals(KeyEvent.KEYCODE_UNKNOWN, KeyEvent.keyCodeFromString("")); 815 assertEquals(KeyEvent.LAST_KEYCODE, 816 KeyEvent.keyCodeFromString(Integer.toString(KeyEvent.LAST_KEYCODE))); 817 assertEquals(KeyEvent.KEYCODE_UNKNOWN, 818 KeyEvent.keyCodeFromString(Integer.toString(KeyEvent.LAST_KEYCODE + 1))); 819 } 820 821 @Test testNativeConverter()822 public void testNativeConverter() { 823 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_A, 824 1, 0, KeyCharacterMap.VIRTUAL_KEYBOARD, 0, 0, InputDevice.SOURCE_TOUCHSCREEN); 825 nativeKeyEventTest(mKeyEvent); 826 } 827 828 // Parcel a KeyEvent, then create a new KeyEvent from this parcel. Return the new KeyEvent parcelUnparcel(KeyEvent keyEvent)829 private KeyEvent parcelUnparcel(KeyEvent keyEvent) { 830 Parcel parcel = Parcel.obtain(); 831 keyEvent.writeToParcel(parcel, Parcelable.PARCELABLE_WRITE_RETURN_VALUE); 832 parcel.setDataPosition(0); 833 834 KeyEvent keyEventFromParcel = KeyEvent.CREATOR.createFromParcel(parcel); 835 parcel.recycle(); 836 return keyEventFromParcel; 837 } 838 } 839