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.widget.cts; 18 19 import com.android.cts.stub.R; 20 21 import dalvik.annotation.TestLevel; 22 import dalvik.annotation.TestTargetClass; 23 import dalvik.annotation.TestTargetNew; 24 import dalvik.annotation.TestTargets; 25 import dalvik.annotation.ToBeFixed; 26 27 import org.xmlpull.v1.XmlPullParser; 28 29 import android.app.Activity; 30 import android.app.Instrumentation; 31 import android.content.Context; 32 import android.test.ActivityInstrumentationTestCase2; 33 import android.test.UiThreadTest; 34 import android.text.Editable; 35 import android.text.Spannable; 36 import android.text.TextWatcher; 37 import android.util.AttributeSet; 38 import android.util.Log; 39 import android.util.Xml; 40 import android.view.KeyEvent; 41 import android.widget.DialerFilter; 42 import android.widget.EditText; 43 import android.widget.RelativeLayout; 44 45 @TestTargetClass(DialerFilter.class) 46 public class DialerFilterTest extends ActivityInstrumentationTestCase2<DialerFilterStubActivity> { 47 private Activity mActivity; 48 private Instrumentation mInstrumentation; 49 private DialerFilter mDialerFilter; 50 DialerFilterTest()51 public DialerFilterTest() { 52 super("com.android.cts.stub", DialerFilterStubActivity.class); 53 } 54 55 @Override setUp()56 protected void setUp() throws Exception { 57 super.setUp(); 58 59 mActivity = getActivity(); 60 mInstrumentation = getInstrumentation(); 61 62 mDialerFilter = (DialerFilter) mActivity.findViewById(R.id.dialer_filter); 63 } 64 65 @TestTargets({ 66 @TestTargetNew( 67 level = TestLevel.COMPLETE, 68 method = "DialerFilter", 69 args = {Context.class} 70 ), 71 @TestTargetNew( 72 level = TestLevel.COMPLETE, 73 method = "DialerFilter", 74 args = {Context.class, AttributeSet.class} 75 ) 76 }) 77 @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete") testConstructor()78 public void testConstructor() { 79 final XmlPullParser parser = mActivity.getResources().getXml(R.layout.dialerfilter_layout); 80 final AttributeSet attrs = Xml.asAttributeSet(parser); 81 82 new DialerFilter(mActivity); 83 new DialerFilter(mActivity, attrs); 84 85 new DialerFilter(null); 86 try { 87 new DialerFilter(null, null); 88 fail("There should be a NullPointerException thrown out."); 89 } catch (final NullPointerException e) { 90 // expected, test success 91 } 92 } 93 94 @TestTargetNew( 95 level = TestLevel.SUFFICIENT, 96 method = "isQwertyKeyboard", 97 args = {} 98 ) 99 @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete") testIsQwertyKeyboard()100 public void testIsQwertyKeyboard() { 101 // Simply call the method. Return value may depend on the default keyboard. 102 mDialerFilter.isQwertyKeyboard(); 103 } 104 105 @TestTargets({ 106 @TestTargetNew( 107 level = TestLevel.SUFFICIENT, 108 method = "onKeyUp", 109 args = {int.class, KeyEvent.class} 110 ), 111 @TestTargetNew( 112 level = TestLevel.SUFFICIENT, 113 method = "onKeyDown", 114 args = {int.class, KeyEvent.class} 115 ) 116 }) testOnKeyUpDown()117 public void testOnKeyUpDown() { 118 // The exact behavior depends on the implementation of DialerKeyListener and 119 // TextKeyListener, but even that may be changed. Simply assert basic scenarios. 120 121 mInstrumentation.runOnMainSync(new Runnable() { 122 public void run() { 123 mDialerFilter.setMode(DialerFilter.DIGITS_ONLY); 124 } 125 }); 126 mInstrumentation.waitForIdleSync(); 127 128 sendKeys(KeyEvent.KEYCODE_1, KeyEvent.KEYCODE_2, KeyEvent.KEYCODE_3); 129 assertEquals("", mDialerFilter.getLetters().toString()); 130 assertEquals("123", mDialerFilter.getDigits().toString()); 131 132 mInstrumentation.runOnMainSync(new Runnable() { 133 public void run() { 134 mDialerFilter.clearText(); 135 mDialerFilter.setMode(DialerFilter.LETTERS_ONLY); 136 } 137 }); 138 mInstrumentation.waitForIdleSync(); 139 140 sendKeys(KeyEvent.KEYCODE_A, KeyEvent.KEYCODE_D, KeyEvent.KEYCODE_G); 141 assertEquals("ADG", mDialerFilter.getLetters().toString()); 142 assertEquals("", mDialerFilter.getDigits().toString()); 143 144 mInstrumentation.runOnMainSync(new Runnable() { 145 public void run() { 146 mDialerFilter.clearText(); 147 mDialerFilter.setMode(DialerFilter.DIGITS_AND_LETTERS); 148 } 149 }); 150 mInstrumentation.waitForIdleSync(); 151 152 sendKeys(KeyEvent.KEYCODE_A, KeyEvent.KEYCODE_D, KeyEvent.KEYCODE_G); 153 assertEquals("ADG", mDialerFilter.getLetters().toString()); 154 // A, D, K may map to numbers on some keyboards. Don't test. 155 156 mInstrumentation.runOnMainSync(new Runnable() { 157 public void run() { 158 mDialerFilter.clearText(); 159 mDialerFilter.setMode(DialerFilter.DIGITS_AND_LETTERS); 160 } 161 }); 162 mInstrumentation.waitForIdleSync(); 163 164 sendKeys(KeyEvent.KEYCODE_1, KeyEvent.KEYCODE_2, KeyEvent.KEYCODE_3); 165 // 1, 2, 3 may map to letters on some keyboards. Don't test. 166 assertEquals("123", mDialerFilter.getDigits().toString()); 167 } 168 169 @TestTargets({ 170 @TestTargetNew( 171 level = TestLevel.COMPLETE, 172 method = "setMode", 173 args = {int.class} 174 ), 175 @TestTargetNew( 176 level = TestLevel.COMPLETE, 177 method = "getMode", 178 args = {} 179 ) 180 }) 181 @UiThreadTest 182 @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete") testAccessMode()183 public void testAccessMode() { 184 mDialerFilter.setMode(DialerFilter.DIGITS_AND_LETTERS_NO_LETTERS); 185 assertEquals(DialerFilter.DIGITS_AND_LETTERS_NO_LETTERS, mDialerFilter.getMode()); 186 187 mDialerFilter.setMode(DialerFilter.DIGITS_AND_LETTERS); 188 assertEquals(DialerFilter.DIGITS_AND_LETTERS, mDialerFilter.getMode()); 189 190 mDialerFilter.setMode(-1); 191 assertEquals(-1, mDialerFilter.getMode()); 192 } 193 194 @TestTargetNew( 195 level = TestLevel.COMPLETE, 196 method = "getLetters", 197 args = {} 198 ) 199 @UiThreadTest 200 @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete") testGetLetters()201 public void testGetLetters() { 202 assertEquals("", mDialerFilter.getLetters().toString()); 203 204 mDialerFilter.setMode(DialerFilter.DIGITS_AND_LETTERS); 205 mDialerFilter.append("ANDROID"); 206 assertEquals("ANDROID", mDialerFilter.getLetters().toString()); 207 } 208 209 @TestTargetNew( 210 level = TestLevel.COMPLETE, 211 method = "getDigits", 212 args = {} 213 ) 214 @UiThreadTest 215 @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete") testGetDigits()216 public void testGetDigits() { 217 assertEquals("", mDialerFilter.getDigits().toString()); 218 219 mDialerFilter.setMode(DialerFilter.DIGITS_AND_LETTERS); 220 mDialerFilter.append("12345"); 221 assertEquals("12345", mDialerFilter.getDigits().toString()); 222 } 223 224 @TestTargetNew( 225 level = TestLevel.COMPLETE, 226 method = "getFilterText", 227 args = {} 228 ) 229 @UiThreadTest 230 @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete") testGetFilterText()231 public void testGetFilterText() { 232 assertEquals("", mDialerFilter.getFilterText().toString()); 233 234 mDialerFilter.setMode(DialerFilter.DIGITS_AND_LETTERS); 235 mDialerFilter.append("CTS12345"); 236 assertEquals("CTS12345", mDialerFilter.getFilterText().toString()); 237 238 mDialerFilter.setMode(DialerFilter.DIGITS_ONLY); 239 assertEquals("12345", mDialerFilter.getFilterText().toString()); 240 241 mDialerFilter.setMode(DialerFilter.LETTERS_ONLY); 242 assertEquals("CTS12345", mDialerFilter.getFilterText().toString()); 243 } 244 245 @TestTargets({ 246 @TestTargetNew( 247 level = TestLevel.COMPLETE, 248 method = "append", 249 args = {java.lang.String.class} 250 ), 251 @TestTargetNew( 252 level = TestLevel.COMPLETE, 253 method = "setMode", 254 args = {int.class} 255 ), 256 @TestTargetNew( 257 level = TestLevel.COMPLETE, 258 method = "getLetters", 259 args = {} 260 ), 261 @TestTargetNew( 262 level = TestLevel.COMPLETE, 263 method = "getDigits", 264 args = {} 265 ), 266 @TestTargetNew( 267 level = TestLevel.COMPLETE, 268 method = "getFilterText", 269 args = {} 270 ), 271 @TestTargetNew( 272 level = TestLevel.COMPLETE, 273 method = "clearText", 274 args = {} 275 ) 276 }) 277 @UiThreadTest 278 @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete") testAppend()279 public void testAppend() { 280 mDialerFilter.setMode(DialerFilter.LETTERS_ONLY); 281 mDialerFilter.append("ANDROID"); 282 assertEquals("ANDROID", mDialerFilter.getLetters().toString()); 283 assertEquals("", mDialerFilter.getDigits().toString()); 284 assertEquals("ANDROID", mDialerFilter.getFilterText().toString()); 285 286 mDialerFilter.setMode(DialerFilter.DIGITS_ONLY); 287 mDialerFilter.append("123"); 288 assertEquals("", mDialerFilter.getLetters().toString()); 289 assertEquals("123", mDialerFilter.getDigits().toString()); 290 assertEquals("123", mDialerFilter.getFilterText().toString()); 291 292 mDialerFilter.clearText(); 293 mDialerFilter.setMode(DialerFilter.DIGITS_AND_LETTERS); 294 mDialerFilter.append("ABC123DEF456GHI789"); 295 assertEquals("ABC123DEF456GHI789", mDialerFilter.getLetters().toString()); 296 assertEquals("123456789", mDialerFilter.getDigits().toString()); 297 assertEquals("ABC123DEF456GHI789", mDialerFilter.getFilterText().toString()); 298 299 mDialerFilter.clearText(); 300 mDialerFilter.setMode(DialerFilter.DIGITS_AND_LETTERS_NO_DIGITS); 301 mDialerFilter.append("ABC123DEF456GHI789"); 302 assertEquals("ABC123DEF456GHI789", mDialerFilter.getLetters().toString()); 303 assertEquals("", mDialerFilter.getDigits().toString()); 304 assertEquals("ABC123DEF456GHI789", mDialerFilter.getFilterText().toString()); 305 306 mDialerFilter.clearText(); 307 mDialerFilter.setMode(DialerFilter.DIGITS_AND_LETTERS_NO_LETTERS); 308 mDialerFilter.append("ABC123DEF456GHI789"); 309 assertEquals("", mDialerFilter.getLetters().toString()); 310 assertEquals("123456789", mDialerFilter.getDigits().toString()); 311 assertEquals("", mDialerFilter.getFilterText().toString()); 312 313 mDialerFilter.clearText(); 314 mDialerFilter.setMode(DialerFilter.DIGITS_AND_LETTERS); 315 mDialerFilter.append(""); 316 assertEquals("", mDialerFilter.getLetters().toString()); 317 assertEquals("", mDialerFilter.getDigits().toString()); 318 assertEquals("", mDialerFilter.getFilterText().toString()); 319 320 try { 321 mDialerFilter.append(null); 322 fail("A NullPointerException should be thrown out."); 323 } catch (final NullPointerException e) { 324 // expected, test success. 325 } 326 } 327 328 @TestTargetNew( 329 level = TestLevel.COMPLETE, 330 method = "clearText", 331 args = {} 332 ) 333 @UiThreadTest testClearText()334 public void testClearText() { 335 assertEquals("", mDialerFilter.getLetters().toString()); 336 assertEquals("", mDialerFilter.getDigits().toString()); 337 338 mDialerFilter.setMode(DialerFilter.DIGITS_AND_LETTERS); 339 mDialerFilter.append("CTS12345"); 340 assertEquals("CTS12345", mDialerFilter.getLetters().toString()); 341 assertEquals("12345", mDialerFilter.getDigits().toString()); 342 343 mDialerFilter.clearText(); 344 assertEquals("", mDialerFilter.getLetters().toString()); 345 assertEquals("", mDialerFilter.getDigits().toString()); 346 assertEquals(DialerFilter.DIGITS_AND_LETTERS, mDialerFilter.getMode()); 347 } 348 349 @TestTargetNew( 350 level = TestLevel.COMPLETE, 351 method = "setLettersWatcher", 352 args = {TextWatcher.class} 353 ) 354 @UiThreadTest 355 @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete") testSetLettersWatcher()356 public void testSetLettersWatcher() { 357 MockTextWatcher tw = new MockTextWatcher("A"); 358 359 Spannable span = (Spannable) mDialerFilter.getLetters(); 360 assertEquals(-1, span.getSpanStart(tw)); 361 assertEquals(-1, span.getSpanEnd(tw)); 362 363 mDialerFilter.setMode(DialerFilter.LETTERS_ONLY); 364 mDialerFilter.setLettersWatcher(tw); 365 mDialerFilter.append("ANDROID"); 366 assertEquals("ANDROID", tw.getText()); 367 368 span = (Spannable) mDialerFilter.getLetters(); 369 assertEquals(0, span.getSpanStart(tw)); 370 assertEquals(mDialerFilter.getLetters().length(), span.getSpanEnd(tw)); 371 assertEquals("ANDROID", span.toString()); 372 373 tw = new MockTextWatcher(""); 374 mDialerFilter.setLettersWatcher(tw); 375 mDialerFilter.append(""); 376 assertEquals("", tw.getText()); 377 378 try { 379 mDialerFilter.setLettersWatcher(new MockTextWatcher(null)); 380 mDialerFilter.append(null); 381 fail("A NullPointerException should be thrown out."); 382 } catch (final NullPointerException e) { 383 // expected, test success. 384 } 385 } 386 387 @TestTargetNew( 388 level = TestLevel.COMPLETE, 389 method = "setDigitsWatcher", 390 args = {TextWatcher.class} 391 ) 392 @UiThreadTest 393 @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete") testSetDigitsWatcher()394 public void testSetDigitsWatcher() { 395 final MockTextWatcher tw = new MockTextWatcher("9"); 396 397 Spannable span = (Spannable) mDialerFilter.getDigits(); 398 assertEquals(-1, span.getSpanStart(tw)); 399 assertEquals(-1, span.getSpanEnd(tw)); 400 401 mDialerFilter.setDigitsWatcher(tw); 402 assertEquals(0, span.getSpanStart(tw)); 403 assertEquals(mDialerFilter.getDigits().length(), span.getSpanEnd(tw)); 404 405 mDialerFilter.setMode(DialerFilter.DIGITS_ONLY); 406 mDialerFilter.append("12345"); 407 assertEquals("12345", tw.getText()); 408 } 409 410 @TestTargetNew( 411 level = TestLevel.COMPLETE, 412 method = "setFilterWatcher", 413 args = {TextWatcher.class} 414 ) 415 @UiThreadTest 416 @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete") testSetFilterWatcher()417 public void testSetFilterWatcher() { 418 final MockTextWatcher tw = new MockTextWatcher("A"); 419 420 Spannable span = (Spannable) mDialerFilter.getLetters(); 421 assertEquals(-1, span.getSpanStart(tw)); 422 assertEquals(-1, span.getSpanEnd(tw)); 423 424 mDialerFilter.setMode(DialerFilter.LETTERS_ONLY); 425 mDialerFilter.setFilterWatcher(tw); 426 mDialerFilter.append("ANDROID"); 427 assertEquals("ANDROID", tw.getText()); 428 span = (Spannable) mDialerFilter.getLetters(); 429 430 assertEquals(0, span.getSpanStart(tw)); 431 assertEquals(mDialerFilter.getLetters().length(), span.getSpanEnd(tw)); 432 433 mDialerFilter.setMode(DialerFilter.DIGITS_ONLY); 434 mDialerFilter.setFilterWatcher(tw); 435 mDialerFilter.append("12345"); 436 assertEquals("12345", tw.getText()); 437 } 438 439 @TestTargetNew( 440 level = TestLevel.COMPLETE, 441 method = "removeFilterWatcher", 442 args = {TextWatcher.class} 443 ) 444 @UiThreadTest 445 @ToBeFixed(bug = "1695243", explanation = "Android API javadocs are incomplete") testRemoveFilterWatcher()446 public void testRemoveFilterWatcher() { 447 final MockTextWatcher tw = new MockTextWatcher("A"); 448 449 Spannable span = (Spannable) mDialerFilter.getLetters(); 450 assertEquals(-1, span.getSpanStart(tw)); 451 assertEquals(-1, span.getSpanEnd(tw)); 452 453 mDialerFilter.setMode(DialerFilter.LETTERS_ONLY); 454 mDialerFilter.setFilterWatcher(tw); 455 mDialerFilter.append("ANDROID"); 456 assertEquals("ANDROID", tw.getText()); 457 458 span = (Spannable) mDialerFilter.getLetters(); 459 assertEquals(0, span.getSpanStart(tw)); 460 assertEquals(mDialerFilter.getLetters().length(), span.getSpanEnd(tw)); 461 462 mDialerFilter.removeFilterWatcher(tw); 463 mDialerFilter.append("GOLF"); 464 assertEquals("ANDROID", tw.getText()); 465 466 assertEquals(-1, span.getSpanStart(tw)); 467 assertEquals(-1, span.getSpanEnd(tw)); 468 } 469 470 @TestTargetNew( 471 level = TestLevel.NOT_NECESSARY, 472 method = "onFinishInflate", 473 args = {} 474 ) testOnFinishInflate()475 public void testOnFinishInflate() { 476 // onFinishInflate() is implementation details, do NOT test 477 } 478 479 @TestTargetNew( 480 level = TestLevel.NOT_NECESSARY, 481 method = "onFocusChanged", 482 args = {boolean.class, int.class, android.graphics.Rect.class} 483 ) testOnFocusChanged()484 public void testOnFocusChanged() { 485 // onFocusChanged() is implementation details, do NOT test 486 } 487 488 @TestTargetNew( 489 level = TestLevel.COMPLETE, 490 method = "onModeChange", 491 args = {int.class, int.class} 492 ) 493 @UiThreadTest testOnModechange()494 public void testOnModechange() { 495 final MockDialerFilter dialerFilter = createMyDialerFilter(); 496 dialerFilter.onFinishInflate(); 497 498 assertEquals(0, dialerFilter.getOldMode()); 499 assertEquals(MockDialerFilter.DIGITS_AND_LETTERS, dialerFilter.getNewMode()); 500 501 dialerFilter.setMode(MockDialerFilter.DIGITS_AND_LETTERS_NO_LETTERS); 502 assertEquals(MockDialerFilter.DIGITS_AND_LETTERS, dialerFilter.getOldMode()); 503 assertEquals(MockDialerFilter.DIGITS_AND_LETTERS_NO_LETTERS, dialerFilter.getNewMode()); 504 505 dialerFilter.setMode(MockDialerFilter.DIGITS_AND_LETTERS_NO_DIGITS); 506 assertEquals(MockDialerFilter.DIGITS_AND_LETTERS_NO_LETTERS, dialerFilter.getOldMode()); 507 assertEquals(MockDialerFilter.DIGITS_AND_LETTERS_NO_DIGITS, dialerFilter.getNewMode()); 508 } 509 createMyDialerFilter()510 private MockDialerFilter createMyDialerFilter() { 511 final MockDialerFilter dialerFilter = new MockDialerFilter(mActivity); 512 513 final EditText text1 = new EditText(mActivity); 514 text1.setId(com.android.internal.R.id.hint); 515 final EditText text2 = new EditText(mActivity); 516 text2.setId(com.android.internal.R.id.primary); 517 518 dialerFilter.addView(text1, new RelativeLayout.LayoutParams( 519 RelativeLayout.LayoutParams.WRAP_CONTENT, 520 RelativeLayout.LayoutParams.WRAP_CONTENT)); 521 dialerFilter.addView(text2, new RelativeLayout.LayoutParams( 522 RelativeLayout.LayoutParams.WRAP_CONTENT, 523 RelativeLayout.LayoutParams.WRAP_CONTENT)); 524 525 return dialerFilter; 526 } 527 528 private class MockTextWatcher implements TextWatcher { 529 private String mString; 530 MockTextWatcher(final String s)531 public MockTextWatcher(final String s) { 532 mString = s; 533 } 534 beforeTextChanged(final CharSequence s, final int start, final int count, final int after)535 public void beforeTextChanged(final CharSequence s, final int start, final int count, 536 final int after) { 537 Log.d("DialerFilterTest", "MockTextWatcher beforeTextChanged"); 538 } 539 onTextChanged(final CharSequence s, final int start, final int before, final int count)540 public void onTextChanged(final CharSequence s, final int start, final int before, 541 final int count) { 542 Log.d("DialerFilterTest", "MockTextWatcher onTextChanged"); 543 mString = s.toString(); 544 } 545 afterTextChanged(final Editable s)546 public void afterTextChanged(final Editable s) { 547 Log.d("DialerFilterTest", "MockTextWatcher afterTextChanged"); 548 } 549 getText()550 public String getText() { 551 return mString; 552 } 553 } 554 555 /** 556 * MockDialerFilter for test 557 */ 558 private class MockDialerFilter extends DialerFilter { 559 private int mOldMode = 0; 560 private int mNewMode = 0; 561 MockDialerFilter(Context context)562 public MockDialerFilter(Context context) { 563 super(context); 564 } 565 566 @Override onFinishInflate()567 protected void onFinishInflate() { 568 super.onFinishInflate(); 569 } 570 571 @Override onModeChange(final int oldMode, final int newMode)572 protected void onModeChange(final int oldMode, final int newMode) { 573 super.onModeChange(oldMode, newMode); 574 mOldMode = oldMode; 575 mNewMode = newMode; 576 } 577 getOldMode()578 public int getOldMode() { 579 return mOldMode; 580 } 581 getNewMode()582 public int getNewMode() { 583 return mNewMode; 584 } 585 } 586 } 587