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 @Test testToString()312 public void testToString() { 313 // make sure it does not throw any exception. 314 mKeyEvent.toString(); 315 } 316 317 @Test testGetModifierMetaStateMask()318 public void testGetModifierMetaStateMask() { 319 int mask = KeyEvent.getModifierMetaStateMask(); 320 assertTrue((mask & KeyEvent.META_SHIFT_ON) != 0); 321 assertTrue((mask & KeyEvent.META_SHIFT_LEFT_ON) != 0); 322 assertTrue((mask & KeyEvent.META_SHIFT_RIGHT_ON) != 0); 323 assertTrue((mask & KeyEvent.META_ALT_ON) != 0); 324 assertTrue((mask & KeyEvent.META_ALT_LEFT_ON) != 0); 325 assertTrue((mask & KeyEvent.META_ALT_RIGHT_ON) != 0); 326 assertTrue((mask & KeyEvent.META_CTRL_ON) != 0); 327 assertTrue((mask & KeyEvent.META_CTRL_LEFT_ON) != 0); 328 assertTrue((mask & KeyEvent.META_CTRL_RIGHT_ON) != 0); 329 assertTrue((mask & KeyEvent.META_META_ON) != 0); 330 assertTrue((mask & KeyEvent.META_META_LEFT_ON) != 0); 331 assertTrue((mask & KeyEvent.META_META_RIGHT_ON) != 0); 332 assertTrue((mask & KeyEvent.META_SYM_ON) != 0); 333 assertTrue((mask & KeyEvent.META_FUNCTION_ON) != 0); 334 335 assertFalse((mask & KeyEvent.META_CAPS_LOCK_ON) != 0); 336 assertFalse((mask & KeyEvent.META_NUM_LOCK_ON) != 0); 337 assertFalse((mask & KeyEvent.META_SCROLL_LOCK_ON) != 0); 338 } 339 340 @Test testIsModifierKey()341 public void testIsModifierKey() { 342 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_SHIFT_LEFT)); 343 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_SHIFT_RIGHT)); 344 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_ALT_LEFT)); 345 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_ALT_RIGHT)); 346 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_CTRL_LEFT)); 347 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_CTRL_RIGHT)); 348 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_META_LEFT)); 349 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_META_RIGHT)); 350 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_SYM)); 351 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_NUM)); 352 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_FUNCTION)); 353 354 assertFalse(KeyEvent.isModifierKey(KeyEvent.KEYCODE_0)); 355 } 356 357 private static final int UNDEFINED_META_STATE = 0x80000000; 358 359 @Test testNormalizeMetaState()360 public void testNormalizeMetaState() { 361 // Already normalized values. 362 assertEquals(0, KeyEvent.normalizeMetaState(0)); 363 assertEquals(KeyEvent.getModifierMetaStateMask(), 364 KeyEvent.normalizeMetaState(KeyEvent.getModifierMetaStateMask())); 365 366 // Values that require normalization. 367 assertEquals(KeyEvent.META_SHIFT_LEFT_ON | KeyEvent.META_SHIFT_ON, 368 KeyEvent.normalizeMetaState(KeyEvent.META_SHIFT_LEFT_ON)); 369 assertEquals(KeyEvent.META_SHIFT_RIGHT_ON | KeyEvent.META_SHIFT_ON, 370 KeyEvent.normalizeMetaState(KeyEvent.META_SHIFT_RIGHT_ON)); 371 assertEquals(KeyEvent.META_ALT_LEFT_ON | KeyEvent.META_ALT_ON, 372 KeyEvent.normalizeMetaState(KeyEvent.META_ALT_LEFT_ON)); 373 assertEquals(KeyEvent.META_ALT_RIGHT_ON | KeyEvent.META_ALT_ON, 374 KeyEvent.normalizeMetaState(KeyEvent.META_ALT_RIGHT_ON)); 375 assertEquals(KeyEvent.META_CTRL_LEFT_ON | KeyEvent.META_CTRL_ON, 376 KeyEvent.normalizeMetaState(KeyEvent.META_CTRL_LEFT_ON)); 377 assertEquals(KeyEvent.META_CTRL_RIGHT_ON | KeyEvent.META_CTRL_ON, 378 KeyEvent.normalizeMetaState(KeyEvent.META_CTRL_RIGHT_ON)); 379 assertEquals(KeyEvent.META_META_LEFT_ON | KeyEvent.META_META_ON, 380 KeyEvent.normalizeMetaState(KeyEvent.META_META_LEFT_ON)); 381 assertEquals(KeyEvent.META_META_RIGHT_ON | KeyEvent.META_META_ON, 382 KeyEvent.normalizeMetaState(KeyEvent.META_META_RIGHT_ON)); 383 assertEquals(KeyEvent.META_CAPS_LOCK_ON, 384 KeyEvent.normalizeMetaState(MetaKeyKeyListener.META_CAP_LOCKED)); 385 assertEquals(KeyEvent.META_ALT_ON, 386 KeyEvent.normalizeMetaState(MetaKeyKeyListener.META_ALT_LOCKED)); 387 assertEquals(KeyEvent.META_SYM_ON, 388 KeyEvent.normalizeMetaState(MetaKeyKeyListener.META_SYM_LOCKED)); 389 assertEquals(KeyEvent.META_SHIFT_ON, 390 KeyEvent.normalizeMetaState(KeyEvent.META_SHIFT_ON | UNDEFINED_META_STATE)); 391 } 392 393 @Test testMetaStateHasNoModifiers()394 public void testMetaStateHasNoModifiers() { 395 assertTrue(KeyEvent.metaStateHasNoModifiers(0)); 396 assertTrue(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_CAPS_LOCK_ON)); 397 assertTrue(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_NUM_LOCK_ON)); 398 assertTrue(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_SCROLL_LOCK_ON)); 399 400 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_SHIFT_ON)); 401 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_SHIFT_LEFT_ON)); 402 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_SHIFT_RIGHT_ON)); 403 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_ALT_ON)); 404 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_ALT_LEFT_ON)); 405 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_ALT_RIGHT_ON)); 406 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_CTRL_ON)); 407 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_CTRL_LEFT_ON)); 408 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_CTRL_RIGHT_ON)); 409 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_META_ON)); 410 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_META_LEFT_ON)); 411 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_META_RIGHT_ON)); 412 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_SYM_ON)); 413 assertFalse(KeyEvent.metaStateHasNoModifiers(KeyEvent.META_FUNCTION_ON)); 414 } 415 416 @Test testMetaStateHasModifiers()417 public void testMetaStateHasModifiers() { 418 assertTrue(KeyEvent.metaStateHasModifiers(0, 0)); 419 assertTrue(KeyEvent.metaStateHasModifiers( 420 KeyEvent.META_NUM_LOCK_ON | KeyEvent.META_CAPS_LOCK_ON 421 | KeyEvent.META_SCROLL_LOCK_ON, 0)); 422 assertTrue(KeyEvent.metaStateHasModifiers( 423 KeyEvent.META_SHIFT_ON | KeyEvent.META_SHIFT_LEFT_ON, 424 KeyEvent.META_SHIFT_LEFT_ON)); 425 assertTrue(KeyEvent.metaStateHasModifiers( 426 KeyEvent.META_SHIFT_LEFT_ON | KeyEvent.META_SHIFT_RIGHT_ON, 427 KeyEvent.META_SHIFT_LEFT_ON | KeyEvent.META_SHIFT_RIGHT_ON)); 428 assertTrue(KeyEvent.metaStateHasModifiers( 429 KeyEvent.META_SHIFT_LEFT_ON, 430 KeyEvent.META_SHIFT_LEFT_ON)); 431 assertTrue(KeyEvent.metaStateHasModifiers( 432 KeyEvent.META_NUM_LOCK_ON | KeyEvent.META_CAPS_LOCK_ON 433 | KeyEvent.META_SCROLL_LOCK_ON | KeyEvent.META_SHIFT_LEFT_ON, 434 KeyEvent.META_SHIFT_LEFT_ON)); 435 assertTrue(KeyEvent.metaStateHasModifiers( 436 KeyEvent.META_SHIFT_ON | KeyEvent.META_SHIFT_LEFT_ON, 437 KeyEvent.META_SHIFT_ON)); 438 assertTrue(KeyEvent.metaStateHasModifiers( 439 KeyEvent.META_ALT_ON | KeyEvent.META_ALT_RIGHT_ON, 440 KeyEvent.META_ALT_ON)); 441 assertTrue(KeyEvent.metaStateHasModifiers( 442 KeyEvent.META_ALT_LEFT_ON | KeyEvent.META_SHIFT_LEFT_ON, 443 KeyEvent.META_ALT_ON | KeyEvent.META_SHIFT_ON)); 444 assertTrue(KeyEvent.metaStateHasModifiers( 445 KeyEvent.META_CTRL_RIGHT_ON | KeyEvent.META_META_LEFT_ON, 446 KeyEvent.META_CTRL_RIGHT_ON | KeyEvent.META_META_ON)); 447 assertTrue(KeyEvent.metaStateHasModifiers( 448 KeyEvent.META_SYM_ON | KeyEvent.META_FUNCTION_ON | KeyEvent.META_CAPS_LOCK_ON, 449 KeyEvent.META_SYM_ON | KeyEvent.META_FUNCTION_ON)); 450 451 assertFalse(KeyEvent.metaStateHasModifiers(0, KeyEvent.META_SHIFT_ON)); 452 assertFalse(KeyEvent.metaStateHasModifiers( 453 KeyEvent.META_ALT_ON | KeyEvent.META_SHIFT_LEFT_ON, 454 KeyEvent.META_SHIFT_ON)); 455 assertFalse(KeyEvent.metaStateHasModifiers( 456 KeyEvent.META_ALT_LEFT_ON | KeyEvent.META_SHIFT_LEFT_ON, 457 KeyEvent.META_SHIFT_ON)); 458 assertFalse(KeyEvent.metaStateHasModifiers( 459 KeyEvent.META_ALT_LEFT_ON, 460 KeyEvent.META_ALT_RIGHT_ON)); 461 assertFalse(KeyEvent.metaStateHasModifiers( 462 KeyEvent.META_ALT_LEFT_ON, 463 KeyEvent.META_CTRL_LEFT_ON)); 464 465 final int[] invalidModifiers = new int[] { 466 KeyEvent.META_CAPS_LOCK_ON, 467 KeyEvent.META_NUM_LOCK_ON, 468 KeyEvent.META_SCROLL_LOCK_ON, 469 MetaKeyKeyListener.META_CAP_LOCKED, 470 MetaKeyKeyListener.META_ALT_LOCKED, 471 MetaKeyKeyListener.META_SYM_LOCKED, 472 KeyEvent.META_SHIFT_ON | KeyEvent.META_SHIFT_LEFT_ON, 473 KeyEvent.META_SHIFT_ON | KeyEvent.META_SHIFT_RIGHT_ON, 474 KeyEvent.META_SHIFT_ON | KeyEvent.META_SHIFT_LEFT_ON| KeyEvent.META_SHIFT_RIGHT_ON, 475 KeyEvent.META_ALT_ON | KeyEvent.META_ALT_LEFT_ON, 476 KeyEvent.META_ALT_ON | KeyEvent.META_ALT_RIGHT_ON, 477 KeyEvent.META_ALT_ON | KeyEvent.META_ALT_LEFT_ON| KeyEvent.META_ALT_RIGHT_ON, 478 KeyEvent.META_CTRL_ON | KeyEvent.META_CTRL_LEFT_ON, 479 KeyEvent.META_CTRL_ON | KeyEvent.META_CTRL_RIGHT_ON, 480 KeyEvent.META_CTRL_ON | KeyEvent.META_CTRL_LEFT_ON| KeyEvent.META_CTRL_RIGHT_ON, 481 KeyEvent.META_META_ON | KeyEvent.META_META_LEFT_ON, 482 KeyEvent.META_META_ON | KeyEvent.META_META_RIGHT_ON, 483 KeyEvent.META_META_ON | KeyEvent.META_META_LEFT_ON| KeyEvent.META_META_RIGHT_ON, 484 }; 485 for (int modifiers : invalidModifiers) { 486 try { 487 KeyEvent.metaStateHasModifiers(0, modifiers); 488 Assert.fail("Expected IllegalArgumentException"); 489 } catch (IllegalArgumentException ex) { 490 } 491 } 492 493 assertFalse(KeyEvent.metaStateHasModifiers(0, UNDEFINED_META_STATE)); 494 } 495 496 @Test testHasNoModifiers()497 public void testHasNoModifiers() { 498 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 499 KeyEvent.KEYCODE_A, 0, KeyEvent.META_CAPS_LOCK_ON); 500 assertTrue(mKeyEvent.hasNoModifiers()); 501 502 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 503 KeyEvent.KEYCODE_A, 0, KeyEvent.META_CAPS_LOCK_ON | KeyEvent.META_SHIFT_ON); 504 assertFalse(mKeyEvent.hasNoModifiers()); 505 } 506 507 @Test testHasModifiers()508 public void testHasModifiers() { 509 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 510 KeyEvent.KEYCODE_A, 0, KeyEvent.META_CAPS_LOCK_ON); 511 assertTrue(mKeyEvent.hasModifiers(0)); 512 513 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 514 KeyEvent.KEYCODE_A, 0, KeyEvent.META_CAPS_LOCK_ON | KeyEvent.META_SHIFT_ON); 515 assertTrue(mKeyEvent.hasModifiers(KeyEvent.META_SHIFT_ON)); 516 517 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 518 KeyEvent.KEYCODE_A, 0, 519 KeyEvent.META_CAPS_LOCK_ON | KeyEvent.META_SHIFT_ON | KeyEvent.META_SHIFT_RIGHT_ON); 520 assertFalse(mKeyEvent.hasModifiers(KeyEvent.META_SHIFT_LEFT_ON)); 521 } 522 523 @Test testGetDisplayLabel()524 public void testGetDisplayLabel() { 525 assertTrue(mKeyEvent.getDisplayLabel() > 0); 526 } 527 528 @Test testIsSystem()529 public void testIsSystem() { 530 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_MENU); 531 assertTrue(mKeyEvent.isSystem()); 532 533 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_SOFT_RIGHT); 534 assertTrue(mKeyEvent.isSystem()); 535 536 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_HOME); 537 assertTrue(mKeyEvent.isSystem()); 538 539 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BACK); 540 assertTrue(mKeyEvent.isSystem()); 541 542 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_CALL); 543 assertTrue(mKeyEvent.isSystem()); 544 545 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_ENDCALL); 546 assertTrue(mKeyEvent.isSystem()); 547 548 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_VOLUME_UP); 549 assertTrue(mKeyEvent.isSystem()); 550 551 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_VOLUME_DOWN); 552 assertTrue(mKeyEvent.isSystem()); 553 554 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_POWER); 555 assertTrue(mKeyEvent.isSystem()); 556 557 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_SEARCH); 558 assertTrue(mKeyEvent.isSystem()); 559 560 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_HEADSETHOOK); 561 assertTrue(mKeyEvent.isSystem()); 562 563 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_CAMERA); 564 assertTrue(mKeyEvent.isSystem()); 565 566 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_FOCUS); 567 assertTrue(mKeyEvent.isSystem()); 568 569 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0); 570 assertFalse(mKeyEvent.isSystem()); 571 } 572 573 @Test testIsPrintingKey()574 public void testIsPrintingKey() { 575 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, Character.SPACE_SEPARATOR); 576 assertTrue(mKeyEvent.isPrintingKey()); 577 578 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, Character.LINE_SEPARATOR); 579 assertTrue(mKeyEvent.isPrintingKey()); 580 581 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, Character.PARAGRAPH_SEPARATOR); 582 assertTrue(mKeyEvent.isPrintingKey()); 583 584 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, Character.CONTROL); 585 assertTrue(mKeyEvent.isPrintingKey()); 586 587 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, Character.FORMAT); 588 assertTrue(mKeyEvent.isPrintingKey()); 589 590 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0); 591 assertTrue(mKeyEvent.isPrintingKey()); 592 } 593 594 @Test testIsMediaSessionKey()595 public void testIsMediaSessionKey() { 596 assertTrue(KeyEvent.isMediaSessionKey(KeyEvent.KEYCODE_MEDIA_PLAY)); 597 assertTrue(KeyEvent.isMediaSessionKey(KeyEvent.KEYCODE_MEDIA_PAUSE)); 598 assertTrue(KeyEvent.isMediaSessionKey(KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE)); 599 assertTrue(KeyEvent.isMediaSessionKey(KeyEvent.KEYCODE_MUTE)); 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