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