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