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 22 import org.xmlpull.v1.XmlPullParser; 23 24 import android.app.Activity; 25 import android.app.Instrumentation; 26 import android.content.Context; 27 import android.cts.util.PollingCheck; 28 import android.test.ActivityInstrumentationTestCase2; 29 import android.test.UiThreadTest; 30 import android.text.Editable; 31 import android.text.Spannable; 32 import android.text.TextWatcher; 33 import android.util.AttributeSet; 34 import android.util.Log; 35 import android.util.Xml; 36 import android.view.KeyCharacterMap; 37 import android.view.KeyEvent; 38 import android.widget.DialerFilter; 39 import android.widget.EditText; 40 import android.widget.RelativeLayout; 41 42 public class DialerFilterTest extends ActivityInstrumentationTestCase2<DialerFilterStubActivity> { 43 private Activity mActivity; 44 private Instrumentation mInstrumentation; 45 private DialerFilter mDialerFilter; 46 DialerFilterTest()47 public DialerFilterTest() { 48 super("com.android.cts.stub", DialerFilterStubActivity.class); 49 } 50 51 @Override setUp()52 protected void setUp() throws Exception { 53 super.setUp(); 54 55 mActivity = getActivity(); 56 new PollingCheck() { 57 @Override 58 protected boolean check() { 59 return mActivity.hasWindowFocus(); 60 } 61 }.run(); 62 mInstrumentation = getInstrumentation(); 63 64 mDialerFilter = (DialerFilter) mActivity.findViewById(R.id.dialer_filter); 65 } 66 testConstructor()67 public void testConstructor() { 68 final XmlPullParser parser = mActivity.getResources().getXml(R.layout.dialerfilter_layout); 69 final AttributeSet attrs = Xml.asAttributeSet(parser); 70 71 new DialerFilter(mActivity); 72 new DialerFilter(mActivity, attrs); 73 } 74 testIsQwertyKeyboard()75 public void testIsQwertyKeyboard() { 76 // Simply call the method. Return value may depend on the default keyboard. 77 mDialerFilter.isQwertyKeyboard(); 78 } 79 testOnKeyUpDown()80 public void testOnKeyUpDown() { 81 // The exact behavior depends on the implementation of DialerKeyListener and 82 // TextKeyListener, but even that may be changed. Simply assert basic scenarios. 83 84 mInstrumentation.runOnMainSync(new Runnable() { 85 public void run() { 86 mDialerFilter.setMode(DialerFilter.DIGITS_ONLY); 87 mDialerFilter.requestFocus(); 88 } 89 }); 90 mInstrumentation.waitForIdleSync(); 91 92 assertTrue(mDialerFilter.hasFocus()); 93 94 mInstrumentation.sendStringSync("123"); 95 assertEquals("", mDialerFilter.getLetters().toString()); 96 assertEquals("123", mDialerFilter.getDigits().toString()); 97 98 mInstrumentation.runOnMainSync(new Runnable() { 99 public void run() { 100 mDialerFilter.clearText(); 101 mDialerFilter.setMode(DialerFilter.LETTERS_ONLY); 102 } 103 }); 104 mInstrumentation.waitForIdleSync(); 105 106 // 12-key support 107 KeyCharacterMap keymap 108 = KeyCharacterMap.load(KeyCharacterMap.VIRTUAL_KEYBOARD); 109 if (keymap.getKeyboardType() == KeyCharacterMap.NUMERIC) { 110 // "adg" in case of 12-key(NUMERIC) keyboard 111 mInstrumentation.sendStringSync("234"); 112 } 113 else { 114 mInstrumentation.sendStringSync("adg"); 115 } 116 assertEquals("ADG", mDialerFilter.getLetters().toString()); 117 assertEquals("", mDialerFilter.getDigits().toString()); 118 119 mInstrumentation.runOnMainSync(new Runnable() { 120 public void run() { 121 mDialerFilter.clearText(); 122 mDialerFilter.setMode(DialerFilter.DIGITS_AND_LETTERS); 123 } 124 }); 125 mInstrumentation.waitForIdleSync(); 126 127 // 12-key support 128 if (keymap.getKeyboardType() == KeyCharacterMap.NUMERIC) { 129 // "adg" in case of 12-key(NUMERIC) keyboard 130 mInstrumentation.sendStringSync("234"); 131 } 132 else { 133 mInstrumentation.sendStringSync("adg"); 134 } 135 assertEquals("ADG", mDialerFilter.getLetters().toString()); 136 // A, D, K may map to numbers on some keyboards. Don't test. 137 138 mInstrumentation.runOnMainSync(new Runnable() { 139 public void run() { 140 mDialerFilter.clearText(); 141 mDialerFilter.setMode(DialerFilter.DIGITS_AND_LETTERS); 142 } 143 }); 144 mInstrumentation.waitForIdleSync(); 145 146 mInstrumentation.sendStringSync("123"); 147 // 1, 2, 3 may map to letters on some keyboards. Don't test. 148 assertEquals("123", mDialerFilter.getDigits().toString()); 149 } 150 151 @UiThreadTest testAccessMode()152 public void testAccessMode() { 153 mDialerFilter.setMode(DialerFilter.DIGITS_AND_LETTERS_NO_LETTERS); 154 assertEquals(DialerFilter.DIGITS_AND_LETTERS_NO_LETTERS, mDialerFilter.getMode()); 155 156 mDialerFilter.setMode(DialerFilter.DIGITS_AND_LETTERS); 157 assertEquals(DialerFilter.DIGITS_AND_LETTERS, mDialerFilter.getMode()); 158 159 mDialerFilter.setMode(-1); 160 assertEquals(-1, mDialerFilter.getMode()); 161 } 162 163 @UiThreadTest testGetLetters()164 public void testGetLetters() { 165 assertEquals("", mDialerFilter.getLetters().toString()); 166 167 mDialerFilter.setMode(DialerFilter.DIGITS_AND_LETTERS); 168 mDialerFilter.append("ANDROID"); 169 assertEquals("ANDROID", mDialerFilter.getLetters().toString()); 170 } 171 172 @UiThreadTest testGetDigits()173 public void testGetDigits() { 174 assertEquals("", mDialerFilter.getDigits().toString()); 175 176 mDialerFilter.setMode(DialerFilter.DIGITS_AND_LETTERS); 177 mDialerFilter.append("12345"); 178 assertEquals("12345", mDialerFilter.getDigits().toString()); 179 } 180 181 @UiThreadTest testGetFilterText()182 public void testGetFilterText() { 183 assertEquals("", mDialerFilter.getFilterText().toString()); 184 185 mDialerFilter.setMode(DialerFilter.DIGITS_AND_LETTERS); 186 mDialerFilter.append("CTS12345"); 187 assertEquals("CTS12345", mDialerFilter.getFilterText().toString()); 188 189 mDialerFilter.setMode(DialerFilter.DIGITS_ONLY); 190 assertEquals("12345", mDialerFilter.getFilterText().toString()); 191 192 mDialerFilter.setMode(DialerFilter.LETTERS_ONLY); 193 assertEquals("CTS12345", mDialerFilter.getFilterText().toString()); 194 } 195 196 @UiThreadTest testAppend()197 public void testAppend() { 198 mDialerFilter.setMode(DialerFilter.LETTERS_ONLY); 199 mDialerFilter.append("ANDROID"); 200 assertEquals("ANDROID", mDialerFilter.getLetters().toString()); 201 assertEquals("", mDialerFilter.getDigits().toString()); 202 assertEquals("ANDROID", mDialerFilter.getFilterText().toString()); 203 204 mDialerFilter.setMode(DialerFilter.DIGITS_ONLY); 205 mDialerFilter.append("123"); 206 assertEquals("", mDialerFilter.getLetters().toString()); 207 assertEquals("123", mDialerFilter.getDigits().toString()); 208 assertEquals("123", mDialerFilter.getFilterText().toString()); 209 210 mDialerFilter.clearText(); 211 mDialerFilter.setMode(DialerFilter.DIGITS_AND_LETTERS); 212 mDialerFilter.append("ABC123DEF456GHI789"); 213 assertEquals("ABC123DEF456GHI789", mDialerFilter.getLetters().toString()); 214 assertEquals("123456789", mDialerFilter.getDigits().toString()); 215 assertEquals("ABC123DEF456GHI789", mDialerFilter.getFilterText().toString()); 216 217 mDialerFilter.clearText(); 218 mDialerFilter.setMode(DialerFilter.DIGITS_AND_LETTERS_NO_DIGITS); 219 mDialerFilter.append("ABC123DEF456GHI789"); 220 assertEquals("ABC123DEF456GHI789", mDialerFilter.getLetters().toString()); 221 assertEquals("", mDialerFilter.getDigits().toString()); 222 assertEquals("ABC123DEF456GHI789", mDialerFilter.getFilterText().toString()); 223 224 mDialerFilter.clearText(); 225 mDialerFilter.setMode(DialerFilter.DIGITS_AND_LETTERS_NO_LETTERS); 226 mDialerFilter.append("ABC123DEF456GHI789"); 227 assertEquals("", mDialerFilter.getLetters().toString()); 228 assertEquals("123456789", mDialerFilter.getDigits().toString()); 229 assertEquals("", mDialerFilter.getFilterText().toString()); 230 231 mDialerFilter.clearText(); 232 mDialerFilter.setMode(DialerFilter.DIGITS_AND_LETTERS); 233 mDialerFilter.append(""); 234 assertEquals("", mDialerFilter.getLetters().toString()); 235 assertEquals("", mDialerFilter.getDigits().toString()); 236 assertEquals("", mDialerFilter.getFilterText().toString()); 237 238 try { 239 mDialerFilter.append(null); 240 fail("A NullPointerException should be thrown out."); 241 } catch (final NullPointerException e) { 242 // expected, test success. 243 } 244 } 245 246 @UiThreadTest testClearText()247 public void testClearText() { 248 assertEquals("", mDialerFilter.getLetters().toString()); 249 assertEquals("", mDialerFilter.getDigits().toString()); 250 251 mDialerFilter.setMode(DialerFilter.DIGITS_AND_LETTERS); 252 mDialerFilter.append("CTS12345"); 253 assertEquals("CTS12345", mDialerFilter.getLetters().toString()); 254 assertEquals("12345", mDialerFilter.getDigits().toString()); 255 256 mDialerFilter.clearText(); 257 assertEquals("", mDialerFilter.getLetters().toString()); 258 assertEquals("", mDialerFilter.getDigits().toString()); 259 assertEquals(DialerFilter.DIGITS_AND_LETTERS, mDialerFilter.getMode()); 260 } 261 262 @UiThreadTest testSetLettersWatcher()263 public void testSetLettersWatcher() { 264 MockTextWatcher tw = new MockTextWatcher("A"); 265 266 Spannable span = (Spannable) mDialerFilter.getLetters(); 267 assertEquals(-1, span.getSpanStart(tw)); 268 assertEquals(-1, span.getSpanEnd(tw)); 269 270 mDialerFilter.setMode(DialerFilter.LETTERS_ONLY); 271 mDialerFilter.setLettersWatcher(tw); 272 mDialerFilter.append("ANDROID"); 273 assertEquals("ANDROID", tw.getText()); 274 275 span = (Spannable) mDialerFilter.getLetters(); 276 assertEquals(0, span.getSpanStart(tw)); 277 assertEquals(mDialerFilter.getLetters().length(), span.getSpanEnd(tw)); 278 assertEquals("ANDROID", span.toString()); 279 280 tw = new MockTextWatcher(""); 281 mDialerFilter.setLettersWatcher(tw); 282 mDialerFilter.append(""); 283 assertEquals("", tw.getText()); 284 285 try { 286 mDialerFilter.setLettersWatcher(new MockTextWatcher(null)); 287 mDialerFilter.append(null); 288 fail("A NullPointerException should be thrown out."); 289 } catch (final NullPointerException e) { 290 // expected, test success. 291 } 292 } 293 294 @UiThreadTest testSetDigitsWatcher()295 public void testSetDigitsWatcher() { 296 final MockTextWatcher tw = new MockTextWatcher("9"); 297 298 Spannable span = (Spannable) mDialerFilter.getDigits(); 299 assertEquals(-1, span.getSpanStart(tw)); 300 assertEquals(-1, span.getSpanEnd(tw)); 301 302 mDialerFilter.setDigitsWatcher(tw); 303 assertEquals(0, span.getSpanStart(tw)); 304 assertEquals(mDialerFilter.getDigits().length(), span.getSpanEnd(tw)); 305 306 mDialerFilter.setMode(DialerFilter.DIGITS_ONLY); 307 mDialerFilter.append("12345"); 308 assertEquals("12345", tw.getText()); 309 } 310 311 @UiThreadTest testSetFilterWatcher()312 public void testSetFilterWatcher() { 313 final MockTextWatcher tw = new MockTextWatcher("A"); 314 315 Spannable span = (Spannable) mDialerFilter.getLetters(); 316 assertEquals(-1, span.getSpanStart(tw)); 317 assertEquals(-1, span.getSpanEnd(tw)); 318 319 mDialerFilter.setMode(DialerFilter.LETTERS_ONLY); 320 mDialerFilter.setFilterWatcher(tw); 321 mDialerFilter.append("ANDROID"); 322 assertEquals("ANDROID", tw.getText()); 323 span = (Spannable) mDialerFilter.getLetters(); 324 325 assertEquals(0, span.getSpanStart(tw)); 326 assertEquals(mDialerFilter.getLetters().length(), span.getSpanEnd(tw)); 327 328 mDialerFilter.setMode(DialerFilter.DIGITS_ONLY); 329 mDialerFilter.setFilterWatcher(tw); 330 mDialerFilter.append("12345"); 331 assertEquals("12345", tw.getText()); 332 } 333 334 @UiThreadTest testRemoveFilterWatcher()335 public void testRemoveFilterWatcher() { 336 final MockTextWatcher tw = new MockTextWatcher("A"); 337 338 Spannable span = (Spannable) mDialerFilter.getLetters(); 339 assertEquals(-1, span.getSpanStart(tw)); 340 assertEquals(-1, span.getSpanEnd(tw)); 341 342 mDialerFilter.setMode(DialerFilter.LETTERS_ONLY); 343 mDialerFilter.setFilterWatcher(tw); 344 mDialerFilter.append("ANDROID"); 345 assertEquals("ANDROID", tw.getText()); 346 347 span = (Spannable) mDialerFilter.getLetters(); 348 assertEquals(0, span.getSpanStart(tw)); 349 assertEquals(mDialerFilter.getLetters().length(), span.getSpanEnd(tw)); 350 351 mDialerFilter.removeFilterWatcher(tw); 352 mDialerFilter.append("GOLF"); 353 assertEquals("ANDROID", tw.getText()); 354 355 assertEquals(-1, span.getSpanStart(tw)); 356 assertEquals(-1, span.getSpanEnd(tw)); 357 } 358 testOnFinishInflate()359 public void testOnFinishInflate() { 360 // onFinishInflate() is implementation details, do NOT test 361 } 362 testOnFocusChanged()363 public void testOnFocusChanged() { 364 // onFocusChanged() is implementation details, do NOT test 365 } 366 367 @UiThreadTest testOnModechange()368 public void testOnModechange() { 369 final MockDialerFilter dialerFilter = createMyDialerFilter(); 370 dialerFilter.onFinishInflate(); 371 372 assertEquals(0, dialerFilter.getOldMode()); 373 assertEquals(MockDialerFilter.DIGITS_AND_LETTERS, dialerFilter.getNewMode()); 374 375 dialerFilter.setMode(MockDialerFilter.DIGITS_AND_LETTERS_NO_LETTERS); 376 assertEquals(MockDialerFilter.DIGITS_AND_LETTERS, dialerFilter.getOldMode()); 377 assertEquals(MockDialerFilter.DIGITS_AND_LETTERS_NO_LETTERS, dialerFilter.getNewMode()); 378 379 dialerFilter.setMode(MockDialerFilter.DIGITS_AND_LETTERS_NO_DIGITS); 380 assertEquals(MockDialerFilter.DIGITS_AND_LETTERS_NO_LETTERS, dialerFilter.getOldMode()); 381 assertEquals(MockDialerFilter.DIGITS_AND_LETTERS_NO_DIGITS, dialerFilter.getNewMode()); 382 } 383 createMyDialerFilter()384 private MockDialerFilter createMyDialerFilter() { 385 final MockDialerFilter dialerFilter = new MockDialerFilter(mActivity); 386 387 final EditText text1 = new EditText(mActivity); 388 text1.setId(com.android.internal.R.id.hint); 389 final EditText text2 = new EditText(mActivity); 390 text2.setId(com.android.internal.R.id.primary); 391 392 dialerFilter.addView(text1, new RelativeLayout.LayoutParams( 393 RelativeLayout.LayoutParams.WRAP_CONTENT, 394 RelativeLayout.LayoutParams.WRAP_CONTENT)); 395 dialerFilter.addView(text2, new RelativeLayout.LayoutParams( 396 RelativeLayout.LayoutParams.WRAP_CONTENT, 397 RelativeLayout.LayoutParams.WRAP_CONTENT)); 398 399 return dialerFilter; 400 } 401 402 private class MockTextWatcher implements TextWatcher { 403 private String mString; 404 MockTextWatcher(final String s)405 public MockTextWatcher(final String s) { 406 mString = s; 407 } 408 beforeTextChanged(final CharSequence s, final int start, final int count, final int after)409 public void beforeTextChanged(final CharSequence s, final int start, final int count, 410 final int after) { 411 Log.d("DialerFilterTest", "MockTextWatcher beforeTextChanged"); 412 } 413 onTextChanged(final CharSequence s, final int start, final int before, final int count)414 public void onTextChanged(final CharSequence s, final int start, final int before, 415 final int count) { 416 Log.d("DialerFilterTest", "MockTextWatcher onTextChanged"); 417 mString = s.toString(); 418 } 419 afterTextChanged(final Editable s)420 public void afterTextChanged(final Editable s) { 421 Log.d("DialerFilterTest", "MockTextWatcher afterTextChanged"); 422 } 423 getText()424 public String getText() { 425 return mString; 426 } 427 } 428 429 /** 430 * MockDialerFilter for test 431 */ 432 private class MockDialerFilter extends DialerFilter { 433 private int mOldMode = 0; 434 private int mNewMode = 0; 435 MockDialerFilter(Context context)436 public MockDialerFilter(Context context) { 437 super(context); 438 } 439 440 @Override onFinishInflate()441 protected void onFinishInflate() { 442 super.onFinishInflate(); 443 } 444 445 @Override onModeChange(final int oldMode, final int newMode)446 protected void onModeChange(final int oldMode, final int newMode) { 447 super.onModeChange(oldMode, newMode); 448 mOldMode = oldMode; 449 mNewMode = newMode; 450 } 451 getOldMode()452 public int getOldMode() { 453 return mOldMode; 454 } 455 getNewMode()456 public int getNewMode() { 457 return mNewMode; 458 } 459 } 460 } 461