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 dalvik.annotation.TestLevel; 20 import dalvik.annotation.TestTargetClass; 21 import dalvik.annotation.TestTargetNew; 22 import dalvik.annotation.TestTargets; 23 import dalvik.annotation.ToBeFixed; 24 25 import android.os.Parcel; 26 import android.os.Parcelable; 27 import android.os.SystemClock; 28 import android.test.AndroidTestCase; 29 import android.text.method.MetaKeyKeyListener; 30 import android.view.KeyEvent; 31 import android.view.KeyCharacterMap.KeyData; 32 import android.view.KeyEvent.Callback; 33 34 /** 35 * Test {@link KeyEvent}. 36 */ 37 @TestTargetClass(KeyEvent.class) 38 public class KeyEventTest extends AndroidTestCase { 39 private KeyEvent mKeyEvent; 40 private long mDownTime; 41 private long mEventTime; 42 43 @Override setUp()44 protected void setUp() throws Exception { 45 super.setUp(); 46 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0); 47 48 mDownTime = SystemClock.uptimeMillis(); 49 mEventTime = SystemClock.uptimeMillis(); 50 } 51 52 @TestTargets({ 53 @TestTargetNew( 54 level = TestLevel.COMPLETE, 55 notes = "Test constructor(s) of {@link KeyEvent}", 56 method = "KeyEvent", 57 args = {int.class, int.class} 58 ), 59 @TestTargetNew( 60 level = TestLevel.COMPLETE, 61 notes = "Test constructor(s) of {@link KeyEvent}", 62 method = "KeyEvent", 63 args = {android.view.KeyEvent.class, long.class, int.class} 64 ), 65 @TestTargetNew( 66 level = TestLevel.COMPLETE, 67 notes = "Test constructor(s) of {@link KeyEvent}", 68 method = "KeyEvent", 69 args = {long.class, long.class, int.class, int.class, int.class} 70 ), 71 @TestTargetNew( 72 level = TestLevel.COMPLETE, 73 notes = "Test constructor(s) of {@link KeyEvent}", 74 method = "KeyEvent", 75 args = {long.class, long.class, int.class, int.class, int.class, int.class} 76 ), 77 @TestTargetNew( 78 level = TestLevel.COMPLETE, 79 notes = "Test constructor(s) of {@link KeyEvent}", 80 method = "KeyEvent", 81 args = {long.class, long.class, int.class, int.class, int.class, int.class, 82 int.class, int.class} 83 ), 84 @TestTargetNew( 85 level = TestLevel.COMPLETE, 86 notes = "Test constructor(s) of {@link KeyEvent}", 87 method = "KeyEvent", 88 args = {long.class, long.class, int.class, int.class, int.class, int.class, 89 int.class, int.class, int.class} 90 ), 91 @TestTargetNew( 92 level = TestLevel.COMPLETE, 93 notes = "Test constructor(s) of {@link KeyEvent}", 94 method = "KeyEvent", 95 args = {long.class, String.class, int.class, int.class} 96 ), 97 @TestTargetNew( 98 level = TestLevel.COMPLETE, 99 notes = "Test constructor(s) of {@link KeyEvent}", 100 method = "KeyEvent", 101 args = {android.view.KeyEvent.class} 102 ) 103 }) testConstructor()104 public void testConstructor() { 105 new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0); 106 107 new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5); 108 109 new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5, 110 KeyEvent.META_SHIFT_ON); 111 112 new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5, 113 KeyEvent.META_SHIFT_ON, 1, 1); 114 115 new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5, 116 KeyEvent.META_SHIFT_ON, 1, 1, KeyEvent.FLAG_SOFT_KEYBOARD); 117 118 KeyEvent keyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0); 119 new KeyEvent(keyEvent); 120 new KeyEvent(keyEvent, mEventTime, 1); 121 122 new KeyEvent(mDownTime, "test", 0, KeyEvent.FLAG_SOFT_KEYBOARD); 123 } 124 125 @TestTargetNew( 126 level = TestLevel.COMPLETE, 127 notes = "Test {@link KeyEvent#getCharacters()}", 128 method = "getCharacters", 129 args = {} 130 ) testGetCharacters()131 public void testGetCharacters() { 132 String characters = "android_test"; 133 mKeyEvent = new KeyEvent(mDownTime, characters, 0, KeyEvent.FLAG_SOFT_KEYBOARD); 134 assertEquals(KeyEvent.ACTION_MULTIPLE, mKeyEvent.getAction()); 135 assertEquals(KeyEvent.KEYCODE_UNKNOWN, mKeyEvent.getKeyCode()); 136 assertEquals(characters, mKeyEvent.getCharacters()); 137 138 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0); 139 assertNull(mKeyEvent.getCharacters()); 140 } 141 142 @TestTargetNew( 143 level = TestLevel.COMPLETE, 144 notes = "Test {@link KeyEvent#getMaxKeyCode()}", 145 method = "getMaxKeyCode", 146 args = {} 147 ) testGetMaxKeyCode()148 public void testGetMaxKeyCode() { 149 assertTrue(KeyEvent.getMaxKeyCode() > 0); 150 } 151 152 @TestTargetNew( 153 level = TestLevel.COMPLETE, 154 notes = "Test {@link KeyEvent#isShiftPressed()}", 155 method = "isShiftPressed", 156 args = {} 157 ) testIsShiftPressed()158 public void testIsShiftPressed() { 159 assertFalse(mKeyEvent.isShiftPressed()); 160 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5, 161 KeyEvent.META_SHIFT_ON); 162 assertTrue(mKeyEvent.isShiftPressed()); 163 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5, 164 KeyEvent.META_ALT_ON); 165 assertFalse(mKeyEvent.isShiftPressed()); 166 } 167 168 @TestTargetNew( 169 level = TestLevel.COMPLETE, 170 notes = "Test {@link KeyEvent#getDeadChar(int, int)}", 171 method = "getDeadChar", 172 args = {int.class, int.class} 173 ) testGetDeadChar()174 public void testGetDeadChar() { 175 // decimal number of è is 232. 176 assertEquals(232, KeyEvent.getDeadChar('`', 'e')); 177 } 178 179 @TestTargetNew( 180 level = TestLevel.COMPLETE, 181 notes = "Test {@link KeyEvent#getKeyData(KeyData)}", 182 method = "getKeyData", 183 args = {android.view.KeyCharacterMap.KeyData.class} 184 ) testGetKeyData()185 public void testGetKeyData() { 186 KeyData keyData = new KeyData(); 187 char origDisplayLabel = keyData.displayLabel; 188 char origNumber = keyData.number; 189 char[] origMeta = new char[KeyData.META_LENGTH]; 190 origMeta[0] = keyData.meta[0]; 191 origMeta[1] = keyData.meta[1]; 192 origMeta[2] = keyData.meta[2]; 193 origMeta[3] = keyData.meta[3]; 194 195 assertTrue(mKeyEvent.getKeyData(keyData)); 196 // check whether KeyData has been updated. 197 assertTrue(keyData.displayLabel != origDisplayLabel); 198 assertTrue(keyData.number != origNumber); 199 assertTrue(keyData.meta[0] != origMeta[0]); 200 assertTrue(keyData.meta[1] != origMeta[1]); 201 assertTrue(keyData.meta[2] != origMeta[2]); 202 assertTrue(keyData.meta[3] != origMeta[3]); 203 } 204 205 @TestTargetNew( 206 level = TestLevel.COMPLETE, 207 notes = "Test {@link KeyEvent#dispatch(Callback)}", 208 method = "dispatch", 209 args = {android.view.KeyEvent.Callback.class} 210 ) testDispatch()211 public void testDispatch() { 212 MockCallback callback = new MockCallback(); 213 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0); 214 callback.reset(); 215 assertFalse(callback.isKeyDown()); 216 assertTrue(mKeyEvent.dispatch(callback)); 217 assertTrue(callback.isKeyDown()); 218 assertEquals(KeyEvent.KEYCODE_0, callback.getKeyCode()); 219 assertSame(mKeyEvent, callback.getKeyEvent()); 220 221 mKeyEvent = new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_0); 222 callback.reset(); 223 assertFalse(callback.isKeyUp()); 224 assertTrue(mKeyEvent.dispatch(callback)); 225 assertTrue(callback.isKeyUp()); 226 assertEquals(KeyEvent.KEYCODE_0, callback.getKeyCode()); 227 assertSame(mKeyEvent, callback.getKeyEvent()); 228 229 callback.reset(); 230 int count = 2; 231 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_MULTIPLE, 232 KeyEvent.KEYCODE_0, count); 233 assertFalse(callback.isKeyMultiple()); 234 assertTrue(mKeyEvent.dispatch(callback)); 235 assertTrue(callback.isKeyMultiple()); 236 assertEquals(KeyEvent.KEYCODE_0, callback.getKeyCode()); 237 assertSame(mKeyEvent, callback.getKeyEvent()); 238 assertEquals(count, callback.getCount()); 239 240 callback.reset(); 241 count = 0; 242 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_MULTIPLE, 243 KeyEvent.KEYCODE_0, count); 244 assertTrue(mKeyEvent.dispatch(callback)); 245 assertTrue(callback.isKeyMultiple()); 246 assertTrue(callback.isKeyDown()); 247 assertTrue(callback.isKeyUp()); 248 assertEquals(count, callback.getCount()); 249 assertEquals(KeyEvent.KEYCODE_0, callback.getKeyCode()); 250 } 251 252 @TestTargetNew( 253 level = TestLevel.COMPLETE, 254 notes = "Test {@link KeyEvent#getMetaState()}", 255 method = "getMetaState", 256 args = {} 257 ) testGetMetaState()258 public void testGetMetaState() { 259 int metaState = KeyEvent.META_ALT_ON; 260 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_MULTIPLE, 261 KeyEvent.KEYCODE_1, 1, metaState); 262 assertEquals(metaState, mKeyEvent.getMetaState()); 263 } 264 265 @TestTargetNew( 266 level = TestLevel.COMPLETE, 267 notes = "Test {@link KeyEvent#getEventTime()}", 268 method = "getEventTime", 269 args = {} 270 ) testGetEventTime()271 public void testGetEventTime() { 272 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 273 KeyEvent.KEYCODE_0, 5); 274 assertEquals(mEventTime, mKeyEvent.getEventTime()); 275 } 276 277 @TestTargetNew( 278 level = TestLevel.COMPLETE, 279 notes = "Test {@link KeyEvent#getDownTime()}", 280 method = "getDownTime", 281 args = {} 282 ) testGetDownTime()283 public void testGetDownTime() { 284 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 285 KeyEvent.KEYCODE_0, 5); 286 assertEquals(mDownTime, mKeyEvent.getDownTime()); 287 } 288 289 @TestTargetNew( 290 level = TestLevel.COMPLETE, 291 notes = "Test {@link KeyEvent#getUnicodeChar()}", 292 method = "getUnicodeChar", 293 args = {} 294 ) testGetUnicodeChar1()295 public void testGetUnicodeChar1() { 296 // 48 is Unicode character of '0' 297 assertEquals(48, mKeyEvent.getUnicodeChar()); 298 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 299 KeyEvent.KEYCODE_9, 5, 0); 300 // 57 is Unicode character of '9' 301 assertEquals(57, mKeyEvent.getUnicodeChar()); 302 303 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 304 KeyEvent.KEYCODE_ALT_LEFT, 5, KeyEvent.META_SHIFT_ON); 305 // 'ALT' key is not a type Unicode character. 306 assertEquals(0, mKeyEvent.getUnicodeChar()); 307 } 308 309 @TestTargetNew( 310 level = TestLevel.COMPLETE, 311 notes = "Test {@link KeyEvent#getUnicodeChar(int)}", 312 method = "getUnicodeChar", 313 args = {int.class} 314 ) testGetUnicodeChar2()315 public void testGetUnicodeChar2() { 316 // 48 is Unicode character of '0' 317 assertEquals(48, mKeyEvent.getUnicodeChar(MetaKeyKeyListener.META_CAP_LOCKED)); 318 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 319 KeyEvent.KEYCODE_9, 5, 0); 320 // 57 is Unicode character of '9' 321 assertEquals(57, mKeyEvent.getUnicodeChar(0)); 322 323 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 324 KeyEvent.KEYCODE_ALT_LEFT, 5, KeyEvent.META_SHIFT_ON); 325 // 'ALT' key is not a type Unicode character. 326 assertEquals(0, mKeyEvent.getUnicodeChar(0)); 327 } 328 329 @TestTargetNew( 330 level = TestLevel.COMPLETE, 331 notes = "Test {@link KeyEvent#getNumber()}", 332 method = "getNumber", 333 args = {} 334 ) testGetNumber()335 public void testGetNumber() { 336 // 48 is associated with key '0' 337 assertEquals(48, mKeyEvent.getNumber()); 338 339 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_3); 340 // 51 is associated with key '3' 341 assertEquals(51, mKeyEvent.getNumber()); 342 } 343 344 @TestTargetNew( 345 level = TestLevel.COMPLETE, 346 notes = "Test {@link KeyEvent#isSymPressed()}", 347 method = "isSymPressed", 348 args = {} 349 ) testIsSymPressed()350 public void testIsSymPressed() { 351 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5, 352 KeyEvent.META_SYM_ON); 353 assertTrue(mKeyEvent.isSymPressed()); 354 355 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5, 356 KeyEvent.META_SHIFT_ON); 357 assertFalse(mKeyEvent.isSymPressed()); 358 } 359 360 @TestTargetNew( 361 level = TestLevel.COMPLETE, 362 notes = "Test {@link KeyEvent#getDeviceId()}", 363 method = "getDeviceId", 364 args = {} 365 ) testGetDeviceId()366 public void testGetDeviceId() { 367 int deviceId = 1; 368 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5, 369 KeyEvent.META_SHIFT_ON, deviceId, 1); 370 assertEquals(deviceId, mKeyEvent.getDeviceId()); 371 } 372 373 @TestTargetNew( 374 level = TestLevel.COMPLETE, 375 notes = "Test {@link KeyEvent#toString()}", 376 method = "toString", 377 args = {} 378 ) testToString()379 public void testToString() { 380 // make sure it does not throw any exception. 381 mKeyEvent.toString(); 382 } 383 384 @TestTargetNew( 385 level = TestLevel.COMPLETE, 386 notes = "Test {@link KeyEvent#isAltPressed()}", 387 method = "isAltPressed", 388 args = {} 389 ) testIsAltPressed()390 public void testIsAltPressed() { 391 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5, 392 KeyEvent.META_ALT_ON); 393 assertTrue(mKeyEvent.isAltPressed()); 394 395 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0, 5, 396 KeyEvent.META_SHIFT_ON); 397 assertFalse(mKeyEvent.isAltPressed()); 398 } 399 400 @TestTargetNew( 401 level = TestLevel.COMPLETE, 402 notes = "Test {@link KeyEvent#isModifierKey(int)}", 403 method = "isModifierKey", 404 args = {int.class} 405 ) testIsModifierKey()406 public void testIsModifierKey() { 407 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_SHIFT_LEFT)); 408 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_SHIFT_RIGHT)); 409 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_ALT_LEFT)); 410 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_ALT_RIGHT)); 411 assertTrue(KeyEvent.isModifierKey(KeyEvent.KEYCODE_SYM)); 412 assertFalse(KeyEvent.isModifierKey(KeyEvent.KEYCODE_0)); 413 } 414 415 @TestTargetNew( 416 level = TestLevel.COMPLETE, 417 notes = "Test {@link KeyEvent#getDisplayLabel()}", 418 method = "getDisplayLabel", 419 args = {} 420 ) 421 @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete") testGetDisplayLabel()422 public void testGetDisplayLabel() { 423 assertTrue(mKeyEvent.getDisplayLabel() > 0); 424 } 425 426 @TestTargetNew( 427 level = TestLevel.COMPLETE, 428 notes = "Test {@link KeyEvent#isSystem()}", 429 method = "isSystem", 430 args = {} 431 ) 432 @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete, " + 433 "javadoc does not tell user the system key set.") testIsSystem()434 public void testIsSystem() { 435 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_MENU); 436 assertTrue(mKeyEvent.isSystem()); 437 438 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_SOFT_RIGHT); 439 assertTrue(mKeyEvent.isSystem()); 440 441 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_HOME); 442 assertTrue(mKeyEvent.isSystem()); 443 444 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_BACK); 445 assertTrue(mKeyEvent.isSystem()); 446 447 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_CALL); 448 assertTrue(mKeyEvent.isSystem()); 449 450 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_ENDCALL); 451 assertTrue(mKeyEvent.isSystem()); 452 453 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_VOLUME_UP); 454 assertTrue(mKeyEvent.isSystem()); 455 456 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_VOLUME_DOWN); 457 assertTrue(mKeyEvent.isSystem()); 458 459 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_POWER); 460 assertTrue(mKeyEvent.isSystem()); 461 462 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_SEARCH); 463 assertTrue(mKeyEvent.isSystem()); 464 465 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_HEADSETHOOK); 466 assertTrue(mKeyEvent.isSystem()); 467 468 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_CAMERA); 469 assertTrue(mKeyEvent.isSystem()); 470 471 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_FOCUS); 472 assertTrue(mKeyEvent.isSystem()); 473 474 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0); 475 assertFalse(mKeyEvent.isSystem()); 476 } 477 478 @TestTargetNew( 479 level = TestLevel.COMPLETE, 480 notes = "Test {@link KeyEvent#isPrintingKey()}", 481 method = "isPrintingKey", 482 args = {} 483 ) 484 @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete, " + 485 "javadoc does not tell user the printing key set.") testIsPrintingKey()486 public void testIsPrintingKey() { 487 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, Character.SPACE_SEPARATOR); 488 assertTrue(mKeyEvent.isPrintingKey()); 489 490 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, Character.LINE_SEPARATOR); 491 assertTrue(mKeyEvent.isPrintingKey()); 492 493 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, Character.PARAGRAPH_SEPARATOR); 494 assertTrue(mKeyEvent.isPrintingKey()); 495 496 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, Character.CONTROL); 497 assertTrue(mKeyEvent.isPrintingKey()); 498 499 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, Character.FORMAT); 500 assertTrue(mKeyEvent.isPrintingKey()); 501 502 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_0); 503 assertTrue(mKeyEvent.isPrintingKey()); 504 } 505 506 @TestTargetNew( 507 level = TestLevel.COMPLETE, 508 notes = "Test {@link KeyEvent#getMatch(char[])}", 509 method = "getMatch", 510 args = {char[].class} 511 ) 512 @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete, " + 513 "should add NPE description in javadoc.") testGetMatch1()514 public void testGetMatch1() { 515 char[] codes1 = new char[] { '0', '1', '2' }; 516 assertEquals('0', mKeyEvent.getMatch(codes1)); 517 518 char[] codes2 = new char[] { 'A', 'B', 'C' }; 519 assertEquals('\0', mKeyEvent.getMatch(codes2)); 520 521 char[] codes3 = { '2', 'S' }; 522 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_S); 523 assertEquals('S', mKeyEvent.getMatch(codes3)); 524 525 try { 526 mKeyEvent.getMatch(null); 527 fail("Should throw NullPointerException"); 528 } catch (NullPointerException e) { 529 // empty 530 } 531 } 532 533 @TestTargetNew( 534 level = TestLevel.COMPLETE, 535 notes = "Test {@link KeyEvent#getMatch(char[], int)}", 536 method = "getMatch", 537 args = {char[].class, int.class} 538 ) 539 @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete, " + 540 "should add NPE description in javadoc.") testGetMatch2()541 public void testGetMatch2() { 542 char[] codes1 = { '0', '1', '2' }; 543 assertEquals('\0', mKeyEvent.getMatch(codes1, KeyEvent.KEYCODE_SHIFT_LEFT)); 544 545 char[] codes2 = { 'A', 'B', 'C' }; 546 assertEquals('\0', mKeyEvent.getMatch(codes2, KeyEvent.KEYCODE_SHIFT_LEFT)); 547 assertEquals('\0', mKeyEvent.getMatch(codes2, 0)); 548 549 char[] codes3 = { '2', 's' }; 550 mKeyEvent = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_S); 551 assertEquals('\0', mKeyEvent.getMatch(codes3, KeyEvent.KEYCODE_ALT_LEFT)); 552 assertEquals('s', mKeyEvent.getMatch(codes3, 0)); 553 554 try { 555 mKeyEvent.getMatch(null, 0); 556 fail("Should throw NullPointerException "); 557 } catch (NullPointerException e) { 558 // empty 559 } 560 } 561 562 @TestTargetNew( 563 level = TestLevel.COMPLETE, 564 notes = "Test {@link KeyEvent#getAction()}", 565 method = "getAction", 566 args = {} 567 ) testGetAction()568 public void testGetAction() { 569 assertEquals(KeyEvent.ACTION_DOWN, mKeyEvent.getAction()); 570 } 571 572 @TestTargetNew( 573 level = TestLevel.COMPLETE, 574 notes = "Test {@link KeyEvent#getRepeatCount()}", 575 method = "getRepeatCount", 576 args = {} 577 ) testGetRepeatCount()578 public void testGetRepeatCount() { 579 int repeatCount = 1; 580 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_MULTIPLE, 581 KeyEvent.KEYCODE_0, repeatCount); 582 assertEquals(repeatCount, mKeyEvent.getRepeatCount()); 583 } 584 585 @TestTargetNew( 586 level = TestLevel.COMPLETE, 587 notes = "Test {@link KeyEvent#writeToParcel(Parcel, int)}", 588 method = "writeToParcel", 589 args = {android.os.Parcel.class, int.class} 590 ) testWriteToParcel()591 public void testWriteToParcel() { 592 Parcel parcel = Parcel.obtain(); 593 mKeyEvent.writeToParcel(parcel, Parcelable.PARCELABLE_WRITE_RETURN_VALUE); 594 parcel.setDataPosition(0); 595 596 KeyEvent keyEvent = KeyEvent.CREATOR.createFromParcel(parcel); 597 parcel.recycle(); 598 599 assertEquals(mKeyEvent.getAction(), keyEvent.getAction()); 600 assertEquals(mKeyEvent.getKeyCode(), keyEvent.getKeyCode()); 601 assertEquals(mKeyEvent.getRepeatCount(), keyEvent.getRepeatCount()); 602 assertEquals(mKeyEvent.getMetaState(), keyEvent.getMetaState()); 603 assertEquals(mKeyEvent.getDeviceId(), keyEvent.getDeviceId()); 604 assertEquals(mKeyEvent.getScanCode(), keyEvent.getScanCode()); 605 assertEquals(mKeyEvent.getFlags(), keyEvent.getFlags()); 606 assertEquals(mKeyEvent.getDownTime(), keyEvent.getDownTime()); 607 assertEquals(mKeyEvent.getEventTime(), keyEvent.getEventTime()); 608 } 609 610 @TestTargetNew( 611 level = TestLevel.COMPLETE, 612 notes = "Test {@link KeyEvent#describeContents()}, this function always returns 0", 613 method = "describeContents", 614 args = {} 615 ) 616 @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete.") testDescribeContents()617 public void testDescribeContents() { 618 // make sure it never shrow any exception. 619 mKeyEvent.describeContents(); 620 } 621 622 @TestTargetNew( 623 level = TestLevel.COMPLETE, 624 notes = "Test {@link KeyEvent#getKeyCode()}", 625 method = "getKeyCode", 626 args = {} 627 ) testGetKeyCode()628 public void testGetKeyCode() { 629 assertEquals(KeyEvent.KEYCODE_0, mKeyEvent.getKeyCode()); 630 } 631 632 @TestTargetNew( 633 level = TestLevel.COMPLETE, 634 notes = "Test {@link KeyEvent#getFlags()}", 635 method = "getFlags", 636 args = {} 637 ) testGetFlags()638 public void testGetFlags() { 639 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 640 KeyEvent.KEYCODE_0, 5, KeyEvent.META_SHIFT_ON, 1, 1, KeyEvent.FLAG_WOKE_HERE); 641 assertEquals(KeyEvent.FLAG_WOKE_HERE, mKeyEvent.getFlags()); 642 643 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 644 KeyEvent.KEYCODE_0, 5, KeyEvent.META_SHIFT_ON, 1, 1, KeyEvent.FLAG_SOFT_KEYBOARD); 645 assertEquals(KeyEvent.FLAG_SOFT_KEYBOARD, mKeyEvent.getFlags()); 646 } 647 648 @TestTargetNew( 649 level = TestLevel.COMPLETE, 650 notes = "Test {@link KeyEvent#getScanCode()}", 651 method = "getScanCode", 652 args = {} 653 ) testGetScanCode()654 public void testGetScanCode() { 655 int scanCode = 1; 656 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 657 KeyEvent.KEYCODE_0, 5, KeyEvent.META_SHIFT_ON, 1, scanCode); 658 assertEquals(scanCode, mKeyEvent.getScanCode()); 659 } 660 661 @TestTargetNew( 662 level = TestLevel.COMPLETE, 663 method = "changeAction", 664 args = {android.view.KeyEvent.class, int.class} 665 ) testChangeAction()666 public void testChangeAction() { 667 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 668 KeyEvent.KEYCODE_0, 5, KeyEvent.META_SHIFT_ON, 1, 1, KeyEvent.FLAG_WOKE_HERE); 669 670 KeyEvent newEvent = KeyEvent.changeAction(mKeyEvent, KeyEvent.ACTION_UP); 671 assertEquals(KeyEvent.ACTION_UP, newEvent.getAction()); 672 assertEquals(mKeyEvent.getFlags(), newEvent.getFlags()); 673 assertEquals(mKeyEvent.getCharacters(), newEvent.getCharacters()); 674 assertEquals(mKeyEvent.getDisplayLabel(), newEvent.getDisplayLabel()); 675 assertEquals(mKeyEvent.getDeviceId(), newEvent.getDeviceId()); 676 assertEquals(mKeyEvent.getDownTime(), newEvent.getDownTime()); 677 assertEquals(mKeyEvent.getEventTime(), newEvent.getEventTime()); 678 assertEquals(mKeyEvent.getKeyCode(), newEvent.getKeyCode()); 679 assertEquals(mKeyEvent.getRepeatCount(), newEvent.getRepeatCount()); 680 } 681 682 @TestTargetNew( 683 level = TestLevel.COMPLETE, 684 method = "changeFlags", 685 args = {android.view.KeyEvent.class, int.class} 686 ) testChangeFlags()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 @TestTargetNew( 704 level = TestLevel.COMPLETE, 705 method = "changeTimeRepeat", 706 args = {android.view.KeyEvent.class, long.class, int.class} 707 ) testChangeTimeRepeat()708 public void testChangeTimeRepeat() { 709 mKeyEvent = new KeyEvent(mDownTime, mEventTime, KeyEvent.ACTION_DOWN, 710 KeyEvent.KEYCODE_0, 5, KeyEvent.META_SHIFT_ON, 1, 1, KeyEvent.FLAG_WOKE_HERE); 711 712 long newEventTime = SystemClock.uptimeMillis(); 713 int newRepeat = mKeyEvent.getRepeatCount() + 1; 714 KeyEvent newEvent = KeyEvent.changeTimeRepeat(mKeyEvent, newEventTime, newRepeat); 715 assertEquals(newEventTime, newEvent.getEventTime()); 716 assertEquals(newRepeat, newEvent.getRepeatCount()); 717 assertEquals(mKeyEvent.getFlags(), newEvent.getFlags()); 718 assertEquals(mKeyEvent.getAction(), newEvent.getAction()); 719 assertEquals(mKeyEvent.getCharacters(), newEvent.getCharacters()); 720 assertEquals(mKeyEvent.getDisplayLabel(), newEvent.getDisplayLabel()); 721 assertEquals(mKeyEvent.getDeviceId(), newEvent.getDeviceId()); 722 assertEquals(mKeyEvent.getDownTime(), newEvent.getDownTime()); 723 assertEquals(mKeyEvent.getKeyCode(), newEvent.getKeyCode()); 724 } 725 726 private class MockCallback implements Callback { 727 private boolean mIsKeyDown; 728 private boolean mIsKeyUp; 729 private boolean mIsMultiple; 730 private int mKeyCode; 731 private KeyEvent mKeyEvent; 732 private int mCount; 733 isKeyDown()734 public boolean isKeyDown() { 735 return mIsKeyDown; 736 } 737 isKeyUp()738 public boolean isKeyUp() { 739 return mIsKeyUp; 740 } 741 isKeyMultiple()742 public boolean isKeyMultiple() { 743 return mIsMultiple; 744 } 745 getKeyCode()746 public int getKeyCode() { 747 return mKeyCode; 748 } 749 getKeyEvent()750 public KeyEvent getKeyEvent() { 751 return mKeyEvent; 752 } 753 getCount()754 public int getCount() { 755 return mCount; 756 } 757 reset()758 public void reset() { 759 mIsKeyDown = false; 760 mIsKeyUp = false; 761 mIsMultiple = false; 762 } 763 onKeyDown(int keyCode, KeyEvent event)764 public boolean onKeyDown(int keyCode, KeyEvent event) { 765 mIsKeyDown = true; 766 mKeyCode = keyCode; 767 mKeyEvent = event; 768 return true; 769 } 770 onKeyLongPress(int keyCode, KeyEvent event)771 public boolean onKeyLongPress(int keyCode, KeyEvent event) { 772 return false; 773 } 774 onKeyMultiple(int keyCode, int count, KeyEvent event)775 public boolean onKeyMultiple(int keyCode, int count, KeyEvent event) { 776 mIsMultiple = true; 777 mKeyCode = keyCode; 778 mKeyEvent = event; 779 mCount = count; 780 if (count < 1) { 781 return false; // this key event never repeat. 782 } 783 return true; 784 } 785 onKeyUp(int keyCode, KeyEvent event)786 public boolean onKeyUp(int keyCode, KeyEvent event) { 787 mIsKeyUp = true; 788 mKeyCode = keyCode; 789 mKeyEvent = event; 790 return true; 791 } 792 } 793 } 794