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.text.method.cts; 18 19 import static org.junit.Assert.assertArrayEquals; 20 import static org.junit.Assert.assertEquals; 21 import static org.junit.Assert.assertNotEquals; 22 import static org.junit.Assert.assertNotNull; 23 import static org.junit.Assert.assertNotSame; 24 import static org.junit.Assert.assertNull; 25 import static org.junit.Assert.assertSame; 26 27 import android.support.test.filters.MediumTest; 28 import android.support.test.runner.AndroidJUnit4; 29 import android.text.InputType; 30 import android.text.Spannable; 31 import android.text.SpannableString; 32 import android.text.Spanned; 33 import android.text.method.DigitsKeyListener; 34 import android.view.KeyEvent; 35 36 import com.android.compatibility.common.util.CtsKeyEventUtil; 37 38 import org.junit.Test; 39 import org.junit.runner.RunWith; 40 41 import java.util.Locale; 42 43 /** 44 * Test {@link DigitsKeyListener}. 45 */ 46 @MediumTest 47 @RunWith(AndroidJUnit4.class) 48 public class DigitsKeyListenerTest extends KeyListenerTestCase { 49 @Test 50 public void testConstructor() { 51 new DigitsKeyListener(); 52 new DigitsKeyListener(true, true); 53 new DigitsKeyListener(true, false); 54 new DigitsKeyListener(false, true); 55 new DigitsKeyListener(false, false); 56 57 new DigitsKeyListener(Locale.US); 58 new DigitsKeyListener(Locale.US, true, true); 59 new DigitsKeyListener(Locale.US, true, false); 60 new DigitsKeyListener(Locale.US, false, true); 61 new DigitsKeyListener(Locale.US, false, false); 62 63 final Locale ir = Locale.forLanguageTag("fa-IR"); 64 new DigitsKeyListener(ir); 65 new DigitsKeyListener(ir, true, true); 66 new DigitsKeyListener(ir, true, false); 67 new DigitsKeyListener(ir, false, true); 68 new DigitsKeyListener(ir, false, false); 69 } 70 71 /* 72 * Check point: 73 * Current accepted characters are '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'. 74 * 1. filter "123456", return null. 75 * 2. filter "a1b2c3d", return "123" 76 * 3. filter "-a1.b2c3d", return "123" 77 * 4. filter "+a1.b2c3d", return "123" 78 * 5. filter Spanned("-a1.b2c3d"), return Spanned("123") and copy spans. 79 * 6. filter "", return null 80 */ 81 @Test 82 public void testFilter1() { 83 String source = "123456"; 84 String destString = "dest string"; 85 86 DigitsKeyListener digitsKeyListener = DigitsKeyListener.getInstance(); 87 SpannableString dest = new SpannableString(destString); 88 assertNull(digitsKeyListener.filter(source, 0, source.length(), 89 dest, 0, dest.length())); 90 assertEquals(destString, dest.toString()); 91 92 source = "a1b2c3d"; 93 assertEquals("123", (digitsKeyListener.filter(source, 0, source.length(), 94 dest, 0, dest.length())).toString()); 95 assertEquals(destString, dest.toString()); 96 97 source = "-a1.b2c3d"; 98 assertEquals("123", (digitsKeyListener.filter(source, 0, source.length(), 99 dest, 0, dest.length())).toString()); 100 assertEquals(destString, dest.toString()); 101 102 source = "+a1.b2c3d"; 103 assertEquals("123", (digitsKeyListener.filter(source, 0, source.length(), 104 dest, 0, dest.length())).toString()); 105 assertEquals(destString, dest.toString()); 106 107 Object what = new Object(); 108 Spannable spannableSource = new SpannableString(source); 109 spannableSource.setSpan(what, 0, spannableSource.length(), Spanned.SPAN_POINT_POINT); 110 Spanned filtered = (Spanned) digitsKeyListener.filter(spannableSource, 111 0, spannableSource.length(), dest, 0, dest.length()); 112 assertEquals("123", filtered.toString()); 113 assertEquals(Spanned.SPAN_POINT_POINT, filtered.getSpanFlags(what)); 114 assertEquals(0, filtered.getSpanStart(what)); 115 assertEquals("123".length(), filtered.getSpanEnd(what)); 116 117 assertNull(digitsKeyListener.filter("", 0, 0, dest, 0, dest.length())); 118 assertEquals(destString, dest.toString()); 119 } 120 121 /* 122 * Check point: 123 * Current accepted characters are '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '+'. 124 * 1. filter "-123456", return null 125 * 2. filter "+123456", return null 126 * 3. filter "-a1.b2c3d", return "-123" 127 * 4. filter "-a1-b2c3d", return "-123" 128 * 5. filter "+a1-b2c3d", return "+123" 129 * 6. filter "5-a1-b2c3d", return "5123" 130 * 7. filter "5-a1+b2c3d", return "5123" 131 * 8. filter "+5-a1+b2c3d", return "+5123" 132 * 9. filter Spanned("5-a1-b2c3d"), return Spanned("5123") and copy spans. 133 * 10. filter "", return null 134 * 11. filter "-123456" but dest has '-' after dend, return "" 135 * 12. filter "-123456" but dest has '+' after dend, return "" 136 * 13. filter "-123456" but dest has '-' before dstart, return "123456" 137 * 14. filter "+123456" but dest has '-' before dstart, return "123456" 138 */ 139 @Test 140 public void testFilter2() { 141 String source = "-123456"; 142 String destString = "dest string without sign and decimal"; 143 144 DigitsKeyListener digitsKeyListener = DigitsKeyListener.getInstance(true, false); 145 SpannableString dest = new SpannableString(destString); 146 assertNull(digitsKeyListener.filter(source, 0, source.length(), 147 dest, 0, dest.length())); 148 assertEquals(destString, dest.toString()); 149 150 source = "+123456"; 151 assertNull(digitsKeyListener.filter(source, 0, source.length(), 152 dest, 0, dest.length())); 153 assertEquals(destString, dest.toString()); 154 155 source = "-a1.b2c3d"; 156 assertEquals("-123", (digitsKeyListener.filter(source, 0, source.length(), 157 dest, 0, dest.length())).toString()); 158 assertEquals(destString, dest.toString()); 159 160 source = "-a1-b2c3d"; 161 assertEquals("-123", (digitsKeyListener.filter(source, 0, source.length(), 162 dest, 0, dest.length())).toString()); 163 assertEquals(destString, dest.toString()); 164 165 source = "+a1-b2c3d"; 166 assertEquals("+123", (digitsKeyListener.filter(source, 0, source.length(), 167 dest, 0, dest.length())).toString()); 168 assertEquals(destString, dest.toString()); 169 170 source = "5-a1-b2c3d"; 171 assertEquals("5123", (digitsKeyListener.filter(source, 0, source.length(), 172 dest, 0, dest.length())).toString()); 173 assertEquals(destString, dest.toString()); 174 175 source = "5-a1+b2c3d"; 176 assertEquals("5123", (digitsKeyListener.filter(source, 0, source.length(), 177 dest, 0, dest.length())).toString()); 178 assertEquals(destString, dest.toString()); 179 180 source = "+5-a1+b2c3d"; 181 assertEquals("+5123", (digitsKeyListener.filter(source, 0, source.length(), 182 dest, 0, dest.length())).toString()); 183 assertEquals(destString, dest.toString()); 184 185 source = "5-a1+b2c3d"; 186 Object what = new Object(); 187 Spannable spannableSource = new SpannableString(source); 188 spannableSource.setSpan(what, 0, spannableSource.length(), Spanned.SPAN_POINT_POINT); 189 Spanned filtered = (Spanned) digitsKeyListener.filter(spannableSource, 190 0, spannableSource.length(), dest, 0, dest.length()); 191 assertEquals("5123", filtered.toString()); 192 assertEquals(Spanned.SPAN_POINT_POINT, filtered.getSpanFlags(what)); 193 assertEquals(0, filtered.getSpanStart(what)); 194 assertEquals("5123".length(), filtered.getSpanEnd(what)); 195 196 assertNull(digitsKeyListener.filter("", 0, 0, dest, 0, dest.length())); 197 assertEquals(destString, dest.toString()); 198 199 source = "-123456"; 200 String endSign = "789-"; 201 dest = new SpannableString(endSign); 202 assertEquals("", (digitsKeyListener.filter(source, 0, source.length(), 203 dest, 0, dest.length() - 1)).toString()); 204 assertEquals(endSign, dest.toString()); 205 206 endSign = "789+"; 207 dest = new SpannableString(endSign); 208 assertEquals("", (digitsKeyListener.filter(source, 0, source.length(), 209 dest, 0, dest.length() - 1)).toString()); 210 assertEquals(endSign, dest.toString()); 211 212 String startSign = "-789"; 213 dest = new SpannableString(startSign); 214 assertEquals("123456", (digitsKeyListener.filter(source, 0, source.length(), 215 dest, 1, dest.length())).toString()); 216 assertEquals(startSign, dest.toString()); 217 218 source = "+123456"; 219 dest = new SpannableString(startSign); 220 assertEquals("123456", (digitsKeyListener.filter(source, 0, source.length(), 221 dest, 1, dest.length())).toString()); 222 assertEquals(startSign, dest.toString()); 223 } 224 225 /* 226 * Check point: 227 * Current accepted characters are '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.'. 228 * 1. filter "123.456", return null 229 * 2. filter "-a1.b2c3d", return "1.23" 230 * 3. filter "+a1.b2c3d", return "1.23" 231 * 4. filter "a1.b2c3d.", return "123." 232 * 5. filter "5.a1.b2c3d", return "51.23" 233 * 6. filter Spanned("5.a1.b2c3d"), return Spanned("51.23") and copy spans. 234 * 7. filter "", return null 235 * 8. filter "123.456" but dest has '.' after dend, return "123456" 236 * 9. filter "123.456" but dest has '.' before dstart, return "123456" 237 */ 238 @Test 239 public void testFilter3() { 240 String source = "123.456"; 241 String destString = "dest string without sign and decimal"; 242 243 DigitsKeyListener digitsKeyListener = DigitsKeyListener.getInstance(false, true); 244 SpannableString dest = new SpannableString(destString); 245 assertNull(digitsKeyListener.filter(source, 0, source.length(), 246 dest, 0, dest.length())); 247 assertEquals(destString, dest.toString()); 248 249 source = "-a1.b2c3d"; 250 assertEquals("1.23", (digitsKeyListener.filter(source, 0, source.length(), 251 dest, 0, dest.length())).toString()); 252 assertEquals(destString, dest.toString()); 253 254 source = "+a1.b2c3d"; 255 assertEquals("1.23", (digitsKeyListener.filter(source, 0, source.length(), 256 dest, 0, dest.length())).toString()); 257 assertEquals(destString, dest.toString()); 258 259 source = "a1.b2c3d."; 260 assertEquals("123.", (digitsKeyListener.filter(source, 0, source.length(), 261 dest, 0, dest.length())).toString()); 262 assertEquals(destString, dest.toString()); 263 264 source = "5.a1.b2c3d"; 265 assertEquals("51.23", (digitsKeyListener.filter(source, 0, source.length(), 266 dest, 0, dest.length())).toString()); 267 assertEquals(destString, dest.toString()); 268 269 Object what = new Object(); 270 Spannable spannableSource = new SpannableString(source); 271 spannableSource.setSpan(what, 0, spannableSource.length(), Spanned.SPAN_POINT_POINT); 272 Spanned filtered = (Spanned) digitsKeyListener.filter(spannableSource, 273 0, spannableSource.length(), dest, 0, dest.length()); 274 assertEquals("51.23", filtered.toString()); 275 assertEquals(Spanned.SPAN_POINT_POINT, filtered.getSpanFlags(what)); 276 assertEquals(0, filtered.getSpanStart(what)); 277 assertEquals("51.23".length(), filtered.getSpanEnd(what)); 278 279 assertNull(digitsKeyListener.filter("", 0, 0, dest, 0, dest.length())); 280 assertEquals(destString, dest.toString()); 281 282 source = "123.456"; 283 String endDecimal = "789."; 284 dest = new SpannableString(endDecimal); 285 assertEquals("123456", (digitsKeyListener.filter(source, 0, source.length(), 286 dest, 0, dest.length() - 1)).toString()); 287 assertEquals(endDecimal, dest.toString()); 288 289 String startDecimal = ".789"; 290 dest = new SpannableString(startDecimal); 291 assertEquals("123456", (digitsKeyListener.filter(source, 0, source.length(), 292 dest, 1, dest.length())).toString()); 293 assertEquals(startDecimal, dest.toString()); 294 } 295 296 /* 297 * Check point: 298 * Current accepted characters are '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', '-', 299 * '+'. 300 * 1. filter "-123.456", return null 301 * 2. filter "+123.456", return null 302 * 3. filter "-a1.b2c3d", return "-1.23" 303 * 4. filter "+a1.b2c3d", return "+1.23" 304 * 5. filter "a1.b-2c+3d.", return "123." 305 * 6. filter "-5.a1.b2c+3d", return "-51.23" 306 * 7. filter "+5.a1.b2c-3d", return "+51.23" 307 * 8. filter Spanned("-5.a1.b2c3d"), return Spanned("-51.23") and copy spans. 308 * 9. filter "", return null 309 * 10. filter "-123.456" but dest has '.' after dend, return "-123456" 310 * 11. filter "-123.456" but dest has '.' before dstart, return "123456" 311 * 12. filter "+123.456" but dest has '.' after dend, return "+123456" 312 * 13. filter "+123.456" but dest has '.' before dstart, return "123456" 313 * 14. filter "-123.456" but dest has '-' after dend, return "" 314 * 15. filter "-123.456" but dest has '+' after dend, return "" 315 * 16. filter "-123.456" but dest has '-' before dstart, return "123.456" 316 * 17. filter "+123.456" but dest has '-' before dstart, return "123.456" 317 */ 318 @Test 319 public void testFilter4() { 320 String source = "-123.456"; 321 String destString = "dest string without sign and decimal"; 322 323 DigitsKeyListener digitsKeyListener = DigitsKeyListener.getInstance(true, true); 324 SpannableString dest = new SpannableString(destString); 325 assertNull(digitsKeyListener.filter(source, 0, source.length(), 326 dest, 0, dest.length())); 327 assertEquals(destString, dest.toString()); 328 329 source = "+123.456"; 330 assertNull(digitsKeyListener.filter(source, 0, source.length(), 331 dest, 0, dest.length())); 332 assertEquals(destString, dest.toString()); 333 334 source = "-a1.b2c3d"; 335 assertEquals("-1.23", (digitsKeyListener.filter(source, 0, source.length(), 336 dest, 0, dest.length())).toString()); 337 assertEquals(destString, dest.toString()); 338 339 source = "a1.b-2c+3d."; 340 assertEquals("123.", (digitsKeyListener.filter(source, 0, source.length(), 341 dest, 0, dest.length())).toString()); 342 assertEquals(destString, dest.toString()); 343 344 source = "-5.a1.b2c+3d"; 345 assertEquals("-51.23", (digitsKeyListener.filter(source, 0, source.length(), 346 dest, 0, dest.length())).toString()); 347 assertEquals(destString, dest.toString()); 348 349 source = "+5.a1.b2c-3d"; 350 assertEquals("+51.23", (digitsKeyListener.filter(source, 0, source.length(), 351 dest, 0, dest.length())).toString()); 352 assertEquals(destString, dest.toString()); 353 354 source = "-5.a1.b2c+3d"; 355 Object what = new Object(); 356 Spannable spannableSource = new SpannableString(source); 357 spannableSource.setSpan(what, 0, spannableSource.length(), Spanned.SPAN_POINT_POINT); 358 Spanned filtered = (Spanned) digitsKeyListener.filter(spannableSource, 359 0, spannableSource.length(), dest, 0, dest.length()); 360 assertEquals("-51.23", filtered.toString()); 361 assertEquals(Spanned.SPAN_POINT_POINT, filtered.getSpanFlags(what)); 362 assertEquals(0, filtered.getSpanStart(what)); 363 assertEquals("-51.23".length(), filtered.getSpanEnd(what)); 364 365 assertNull(digitsKeyListener.filter("", 0, 0, dest, 0, dest.length())); 366 assertEquals(destString, dest.toString()); 367 368 source = "-123.456"; 369 String endDecimal = "789."; 370 dest = new SpannableString(endDecimal); 371 assertEquals("-123456", (digitsKeyListener.filter(source, 0, source.length(), 372 dest, 0, dest.length() - 1)).toString()); 373 assertEquals(endDecimal, dest.toString()); 374 375 String startDecimal = ".789"; 376 dest = new SpannableString(startDecimal); 377 assertEquals("123456", (digitsKeyListener.filter(source, 0, source.length(), 378 dest, 1, dest.length())).toString()); 379 assertEquals(startDecimal, dest.toString()); 380 381 source = "+123.456"; 382 endDecimal = "789."; 383 dest = new SpannableString(endDecimal); 384 assertEquals("+123456", (digitsKeyListener.filter(source, 0, source.length(), 385 dest, 0, dest.length() - 1)).toString()); 386 assertEquals(endDecimal, dest.toString()); 387 388 startDecimal = ".789"; 389 dest = new SpannableString(startDecimal); 390 assertEquals("123456", (digitsKeyListener.filter(source, 0, source.length(), 391 dest, 1, dest.length())).toString()); 392 assertEquals(startDecimal, dest.toString()); 393 394 source = "-123.456"; 395 String endSign = "789-"; 396 dest = new SpannableString(endSign); 397 assertEquals("", (digitsKeyListener.filter(source, 0, source.length(), 398 dest, 0, dest.length() - 1)).toString()); 399 assertEquals(endSign, dest.toString()); 400 401 endSign = "789+"; 402 dest = new SpannableString(endSign); 403 assertEquals("", (digitsKeyListener.filter(source, 0, source.length(), 404 dest, 0, dest.length() - 1)).toString()); 405 assertEquals(endSign, dest.toString()); 406 407 String startSign = "-789"; 408 dest = new SpannableString(startSign); 409 assertEquals("123.456", (digitsKeyListener.filter(source, 0, source.length(), 410 dest, 1, dest.length())).toString()); 411 assertEquals(startSign, dest.toString()); 412 413 source = "+123.456"; 414 dest = new SpannableString(startSign); 415 assertEquals("123.456", (digitsKeyListener.filter(source, 0, source.length(), 416 dest, 1, dest.length())).toString()); 417 assertEquals(startSign, dest.toString()); 418 } 419 420 /* 421 * Check point: 422 * Current accepted characters are U+06F0..U+06F9 for digits, U+066B as decimal separator, '-', 423 * '+'. 424 * 425 * Tests are otherwise identical to the tests in testFilter4(). 426 */ 427 @Test 428 public void testFilter4_internationalized() { 429 String source = "-\u06F1\u06F2\u06F3\u066B\u06F4\u06F5\u06F6"; 430 String destString = "dest string without sign and decimal"; 431 432 DigitsKeyListener digitsKeyListener = 433 DigitsKeyListener.getInstance(Locale.forLanguageTag("fa-IR"), true, true); 434 SpannableString dest = new SpannableString(destString); 435 assertNull(digitsKeyListener.filter(source, 0, source.length(), 436 dest, 0, dest.length())); 437 assertEquals(destString, dest.toString()); 438 439 source = "+\u06F1\u06F2\u06F3\u066B\u06F4\u06F5\u06F6"; 440 assertNull(digitsKeyListener.filter(source, 0, source.length(), 441 dest, 0, dest.length())); 442 assertEquals(destString, dest.toString()); 443 444 source = "-a\u06F1\u066Bb\u06F2c\u06F3d"; 445 assertEquals("-\u06F1\u066B\u06F2\u06F3", (digitsKeyListener.filter( 446 source, 0, source.length(), 447 dest, 0, dest.length())).toString()); 448 assertEquals(destString, dest.toString()); 449 450 source = "a\u06F1\u066Bb-\u06F2c+\u06F3d\u066B"; 451 assertEquals("\u06F1\u06F2\u06F3\u066B", (digitsKeyListener.filter( 452 source, 0, source.length(), 453 dest, 0, dest.length())).toString()); 454 assertEquals(destString, dest.toString()); 455 456 source = "-\u06F5\u066Ba\u06F1\u066Bb\u06F2c+\u06F3d"; 457 assertEquals("-\u06F5\u06F1\u066B\u06F2\u06F3", (digitsKeyListener.filter( 458 source, 0, source.length(), 459 dest, 0, dest.length())).toString()); 460 assertEquals(destString, dest.toString()); 461 462 source = "+\u06F5\u066Ba\u06F1\u066Bb\u06F2c-\u06F3d"; 463 assertEquals("+\u06F5\u06F1\u066B\u06F2\u06F3", (digitsKeyListener.filter( 464 source, 0, source.length(), 465 dest, 0, dest.length())).toString()); 466 assertEquals(destString, dest.toString()); 467 468 source = "-\u06F5\u066Ba\u06F1\u066Bb\u06F2c+\u06F3d"; 469 Object what = new Object(); 470 Spannable spannableSource = new SpannableString(source); 471 spannableSource.setSpan(what, 0, spannableSource.length(), Spanned.SPAN_POINT_POINT); 472 Spanned filtered = (Spanned) digitsKeyListener.filter(spannableSource, 473 0, spannableSource.length(), dest, 0, dest.length()); 474 assertEquals("-\u06F5\u06F1\u066B\u06F2\u06F3", filtered.toString()); 475 assertEquals(Spanned.SPAN_POINT_POINT, filtered.getSpanFlags(what)); 476 assertEquals(0, filtered.getSpanStart(what)); 477 assertEquals("-\u06F5\u06F1\u066B\u06F2\u06F3".length(), filtered.getSpanEnd(what)); 478 479 assertNull(digitsKeyListener.filter("", 0, 0, dest, 0, dest.length())); 480 assertEquals(destString, dest.toString()); 481 482 source = "-\u06F1\u06F2\u06F3\u066B\u06F4\u06F5\u06F6"; 483 String endDecimal = "\u06F7\u06F8\u06F9\u066B"; 484 dest = new SpannableString(endDecimal); 485 assertEquals("-\u06F1\u06F2\u06F3\u06F4\u06F5\u06F6", (digitsKeyListener.filter( 486 source, 0, source.length(), 487 dest, 0, dest.length() - 1)).toString()); 488 assertEquals(endDecimal, dest.toString()); 489 490 String startDecimal = "\u066B\u06F7\u06F8\u06F9"; 491 dest = new SpannableString(startDecimal); 492 assertEquals("\u06F1\u06F2\u06F3\u06F4\u06F5\u06F6", (digitsKeyListener.filter( 493 source, 0, source.length(), 494 dest, 1, dest.length())).toString()); 495 assertEquals(startDecimal, dest.toString()); 496 497 source = "+\u06F1\u06F2\u06F3\u066B\u06F4\u06F5\u06F6"; 498 endDecimal = "\u06F7\u06F8\u06F9\u066B"; 499 dest = new SpannableString(endDecimal); 500 assertEquals("+\u06F1\u06F2\u06F3\u06F4\u06F5\u06F6", (digitsKeyListener.filter( 501 source, 0, source.length(), 502 dest, 0, dest.length() - 1)).toString()); 503 assertEquals(endDecimal, dest.toString()); 504 505 startDecimal = "\u066B\u06F7\u06F8\u06F9"; 506 dest = new SpannableString(startDecimal); 507 assertEquals("\u06F1\u06F2\u06F3\u06F4\u06F5\u06F6", (digitsKeyListener.filter( 508 source, 0, source.length(), 509 dest, 1, dest.length())).toString()); 510 assertEquals(startDecimal, dest.toString()); 511 512 source = "-\u06F1\u06F2\u06F3\u066B\u06F4\u06F5\u06F6"; 513 String endSign = "\u06F7\u06F8\u06F9-"; 514 dest = new SpannableString(endSign); 515 assertEquals("", (digitsKeyListener.filter(source, 0, source.length(), 516 dest, 0, dest.length() - 1)).toString()); 517 assertEquals(endSign, dest.toString()); 518 519 endSign = "\u06F7\u06F8\u06F9+"; 520 dest = new SpannableString(endSign); 521 assertEquals("", (digitsKeyListener.filter(source, 0, source.length(), 522 dest, 0, dest.length() - 1)).toString()); 523 assertEquals(endSign, dest.toString()); 524 525 String startSign = "-\u06F7\u06F8\u06F9"; 526 dest = new SpannableString(startSign); 527 assertEquals("\u06F1\u06F2\u06F3\u066B\u06F4\u06F5\u06F6", (digitsKeyListener.filter( 528 source, 0, source.length(), 529 dest, 1, dest.length())).toString()); 530 assertEquals(startSign, dest.toString()); 531 532 source = "+\u06F1\u06F2\u06F3\u066B\u06F4\u06F5\u06F6"; 533 dest = new SpannableString(startSign); 534 assertEquals("\u06F1\u06F2\u06F3\u066B\u06F4\u06F5\u06F6", (digitsKeyListener.filter( 535 source, 0, source.length(), 536 dest, 1, dest.length())).toString()); 537 assertEquals(startSign, dest.toString()); 538 } 539 540 /* 541 * Scenario description: 542 * Current accepted characters are '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'. 543 * 1. Press '-' key and this key could not be accepted. 544 * 2. Press '1' key and check if the content of TextView becomes "1" 545 * 3. Press '.' key and this key could not be accepted. 546 * 4. Press '2' key and check if the content of TextView becomes "12" 547 */ 548 @Test 549 public void testDigitsKeyListener1() { 550 final DigitsKeyListener digitsKeyListener = DigitsKeyListener.getInstance(); 551 552 setKeyListenerSync(digitsKeyListener); 553 assertEquals("", mTextView.getText().toString()); 554 555 // press '-' key. 556 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_MINUS); 557 assertEquals("", mTextView.getText().toString()); 558 559 // press '1' key. 560 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_1); 561 assertEquals("1", mTextView.getText().toString()); 562 563 // press '.' key. 564 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_PERIOD); 565 assertEquals("1", mTextView.getText().toString()); 566 567 // press '2' key. 568 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_2); 569 assertEquals("12", mTextView.getText().toString()); 570 } 571 572 /* 573 * Scenario description: 574 * Current accepted characters are '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '+'. 575 * 1. Press '-' key and check if the content of TextView becomes "-" 576 * 2. Press '1' key and check if the content of TextView becomes "-1" 577 * 3. Press '.' key and this key could not be accepted. 578 * 4. Press '+' key and this key could not be accepted. 579 * 5. Press '2' key and check if the content of TextView becomes "-12" 580 * 6. Press '-' key and this key could not be accepted, 581 * because text view accepts minus sign iff it at the beginning. 582 */ 583 @Test 584 public void testDigitsKeyListener2() { 585 final DigitsKeyListener digitsKeyListener = DigitsKeyListener.getInstance(true, false); 586 587 setKeyListenerSync(digitsKeyListener); 588 assertEquals("", mTextView.getText().toString()); 589 590 // press '-' key. 591 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_MINUS); 592 assertEquals("-", mTextView.getText().toString()); 593 594 // press '1' key. 595 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_1); 596 assertEquals("-1", mTextView.getText().toString()); 597 598 // press '.' key. 599 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_PERIOD); 600 assertEquals("-1", mTextView.getText().toString()); 601 602 // press '+' key. 603 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_PLUS); 604 assertEquals("-1", mTextView.getText().toString()); 605 606 // press '2' key. 607 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_2); 608 assertEquals("-12", mTextView.getText().toString()); 609 610 // press '-' key. 611 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_MINUS); 612 assertEquals("-12", mTextView.getText().toString()); 613 } 614 615 /* 616 * Scenario description: 617 * Current accepted characters are '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.'. 618 * 1. Press '-' key and check if the content of TextView becomes "" 619 * 2. Press '+' key and check if the content of TextView becomes "" 620 * 3. Press '1' key and check if the content of TextView becomes "1" 621 * 4. Press '.' key and check if the content of TextView becomes "1." 622 * 5. Press '2' key and check if the content of TextView becomes "1.2" 623 * 6. Press '.' key and this key could not be accepted, 624 * because text view accepts only one decimal point per field. 625 */ 626 @Test 627 public void testDigitsKeyListener3() { 628 final DigitsKeyListener digitsKeyListener = DigitsKeyListener.getInstance(false, true); 629 630 setKeyListenerSync(digitsKeyListener); 631 assertEquals("", mTextView.getText().toString()); 632 633 // press '-' key. 634 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_MINUS); 635 assertEquals("", mTextView.getText().toString()); 636 637 // press '+' key. 638 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_PLUS); 639 assertEquals("", mTextView.getText().toString()); 640 641 // press '1' key. 642 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_1); 643 assertEquals("1", mTextView.getText().toString()); 644 645 // press '.' key. 646 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_PERIOD); 647 assertEquals("1.", mTextView.getText().toString()); 648 649 // press '2' key. 650 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_2); 651 assertEquals("1.2", mTextView.getText().toString()); 652 653 // press '.' key. 654 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_PERIOD); 655 assertEquals("1.2", mTextView.getText().toString()); 656 } 657 658 /* 659 * Scenario description: 660 * Current accepted characters are '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '+', 661 * '.'. 662 * 1. Press '+' key and check if the content of TextView becomes "+" 663 * 2. Press '1' key and check if the content of TextView becomes "+1" 664 * 3. Press '.' key and this key could not be accepted. 665 * 4. Press '2' key and check if the content of TextView becomes "+12" 666 * 5. Press '-' key and this key could not be accepted, 667 * because text view accepts minus sign iff it at the beginning. 668 * 6. Press '.' key and this key could not be accepted, 669 * because text view accepts only one decimal point per field. 670 */ 671 @Test 672 public void testDigitsKeyListener4() { 673 final DigitsKeyListener digitsKeyListener = DigitsKeyListener.getInstance(true, true); 674 675 setKeyListenerSync(digitsKeyListener); 676 assertEquals("", mTextView.getText().toString()); 677 678 // press '+' key. 679 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_PLUS); 680 assertEquals("+", mTextView.getText().toString()); 681 682 // press '1' key. 683 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_1); 684 assertEquals("+1", mTextView.getText().toString()); 685 686 // press '.' key. 687 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_PERIOD); 688 assertEquals("+1.", mTextView.getText().toString()); 689 690 // press '2' key. 691 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_2); 692 assertEquals("+1.2", mTextView.getText().toString()); 693 694 // press '-' key. 695 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_MINUS); 696 assertEquals("+1.2", mTextView.getText().toString()); 697 698 // press '.' key. 699 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_PERIOD); 700 assertEquals("+1.2", mTextView.getText().toString()); 701 } 702 703 /* 704 * Scenario description: 705 * Current accepted characters are '5', '6', '7', '8', '9'. 706 * 1. Press '1' key and this key could not be accepted. 707 * 2. Press '5' key and check if the content of TextView becomes "5" 708 * 3. Press '.' key and this key could not be accepted. 709 * 4. Press '-' key and this key could not be accepted. 710 * 5. remove DigitsKeyListener and Press '5' key, this key will not be accepted 711 */ 712 @Test 713 public void testDigitsKeyListener5() throws Throwable { 714 final String accepted = "56789"; 715 final DigitsKeyListener digitsKeyListener = DigitsKeyListener.getInstance(accepted); 716 717 setKeyListenerSync(digitsKeyListener); 718 assertEquals("", mTextView.getText().toString()); 719 720 // press '1' key. 721 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_1); 722 assertEquals("", mTextView.getText().toString()); 723 724 // press '5' key. 725 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_5); 726 assertEquals("5", mTextView.getText().toString()); 727 728 // press '.' key. 729 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_PERIOD); 730 assertEquals("5", mTextView.getText().toString()); 731 732 // press '-' key. 733 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_MINUS); 734 assertEquals("5", mTextView.getText().toString()); 735 736 // remove DigitsKeyListener 737 mActivityRule.runOnUiThread(() -> { 738 mTextView.setKeyListener(null); 739 mTextView.requestFocus(); 740 }); 741 mInstrumentation.waitForIdleSync(); 742 assertEquals("5", mTextView.getText().toString()); 743 744 // press '5' key. 745 CtsKeyEventUtil.sendKeys(mInstrumentation, mTextView, KeyEvent.KEYCODE_5); 746 assertEquals("5", mTextView.getText().toString()); 747 } 748 749 @Test 750 public void testGetInstance1() { 751 DigitsKeyListener listener1 = DigitsKeyListener.getInstance(); 752 DigitsKeyListener listener2 = DigitsKeyListener.getInstance(); 753 DigitsKeyListener listener3 = DigitsKeyListener.getInstance((Locale) null); 754 755 assertNotNull(listener1); 756 assertNotNull(listener2); 757 assertNotNull(listener3); 758 assertSame(listener1, listener2); 759 assertSame(listener1, listener3); 760 } 761 762 @Test 763 public void testGetInstance2() { 764 DigitsKeyListener listener1 = DigitsKeyListener.getInstance(true, true); 765 DigitsKeyListener listener2 = DigitsKeyListener.getInstance(true, true); 766 767 assertNotNull(listener1); 768 assertNotNull(listener2); 769 assertSame(listener1, listener2); 770 771 DigitsKeyListener listener3 = DigitsKeyListener.getInstance(true, false); 772 DigitsKeyListener listener4 = DigitsKeyListener.getInstance(true, false); 773 774 assertNotNull(listener3); 775 assertNotNull(listener4); 776 assertSame(listener3, listener4); 777 778 assertNotSame(listener1, listener3); 779 } 780 781 @Test 782 public void testGetInstance3() { 783 DigitsKeyListener digitsKeyListener = DigitsKeyListener.getInstance("abcdefg"); 784 assertNotNull(digitsKeyListener); 785 786 digitsKeyListener = DigitsKeyListener.getInstance("Android Test"); 787 assertNotNull(digitsKeyListener); 788 } 789 790 @Test 791 public void testGetInstance4() { 792 DigitsKeyListener listener1 = DigitsKeyListener.getInstance(Locale.US); 793 DigitsKeyListener listener2 = DigitsKeyListener.getInstance(Locale.US, false, false); 794 assertNotNull(listener1); 795 assertNotNull(listener2); 796 assertSame(listener1, listener2); 797 } 798 799 @Test 800 public void testGetInstance5() { 801 DigitsKeyListener listener1 = DigitsKeyListener.getInstance(Locale.US, false, false); 802 DigitsKeyListener listener2 = DigitsKeyListener.getInstance(Locale.US, true, false); 803 DigitsKeyListener listener3 = DigitsKeyListener.getInstance(Locale.US, false, true); 804 DigitsKeyListener listener4 = DigitsKeyListener.getInstance(Locale.US, true, true); 805 assertNotNull(listener1); 806 assertNotNull(listener2); 807 assertNotNull(listener3); 808 assertNotNull(listener4); 809 assertNotSame(listener1, listener2); 810 assertNotSame(listener1, listener3); 811 assertNotSame(listener1, listener4); 812 assertNotSame(listener2, listener3); 813 assertNotSame(listener2, listener4); 814 assertNotSame(listener3, listener4); 815 } 816 817 @Test 818 public void testGetAcceptedChars1() { 819 MockDigitsKeyListener mockDigitsKeyListener = new MockDigitsKeyListener(); 820 821 final char[][] expected = new char[][] { 822 new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' }, 823 new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '+' }, 824 new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.' }, 825 new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '+', '.' }, 826 }; 827 828 assertArrayEquals(expected[0], mockDigitsKeyListener.getAcceptedChars()); 829 830 mockDigitsKeyListener = new MockDigitsKeyListener(true, false); 831 assertArrayEquals(expected[1], mockDigitsKeyListener.getAcceptedChars()); 832 833 mockDigitsKeyListener = new MockDigitsKeyListener(false, true); 834 assertArrayEquals(expected[2], mockDigitsKeyListener.getAcceptedChars()); 835 836 mockDigitsKeyListener = new MockDigitsKeyListener(true, true); 837 assertArrayEquals(expected[3], mockDigitsKeyListener.getAcceptedChars()); 838 } 839 840 @Test 841 public void testGetAcceptedChars2() { 842 final Locale irLocale = Locale.forLanguageTag("fa-IR"); 843 final char irDecimalSeparator = '\u066B'; 844 final char usDecimalSeparator = '.'; 845 final char[] irDigits = { 846 '\u06F0', '\u06F1', '\u06F2', '\u06F3', '\u06F4', 847 '\u06F5', '\u06F6', '\u06F7', '\u06F8', '\u06F9' 848 }; 849 final char[] irSigns = { 850 '+', '-', '\u2212', 851 }; 852 final char[] asciiDigits = { 853 '0', '1', '2', '3', '4', 854 '5', '6', '7', '8', '9' 855 }; 856 857 MockDigitsKeyListener mockDigitsKeyListener = new MockDigitsKeyListener(irLocale); 858 String acceptedChars = new String(mockDigitsKeyListener.getAcceptedChars()); 859 for (int i = 0; i < irDigits.length; i++) { 860 assertNotEquals(-1, acceptedChars.indexOf(irDigits[i])); 861 } 862 for (int i = 0; i < irSigns.length; i++) { 863 assertEquals(-1, acceptedChars.indexOf(irSigns[i])); 864 } 865 assertEquals(-1, acceptedChars.indexOf(irDecimalSeparator)); 866 for (int i = 0; i < asciiDigits.length; i++) { 867 assertEquals(-1, acceptedChars.indexOf(asciiDigits[i])); 868 } 869 assertEquals(-1, acceptedChars.indexOf(usDecimalSeparator)); 870 871 mockDigitsKeyListener = new MockDigitsKeyListener( 872 irLocale, false /* sign */, true /* decimal */); 873 acceptedChars = new String(mockDigitsKeyListener.getAcceptedChars()); 874 for (int i = 0; i < irDigits.length; i++) { 875 assertNotEquals(-1, acceptedChars.indexOf(irDigits[i])); 876 } 877 for (int i = 0; i < irSigns.length; i++) { 878 assertEquals(-1, acceptedChars.indexOf(irSigns[i])); 879 } 880 assertNotEquals(-1, acceptedChars.indexOf(irDecimalSeparator)); 881 for (int i = 0; i < asciiDigits.length; i++) { 882 assertEquals(-1, acceptedChars.indexOf(asciiDigits[i])); 883 } 884 assertEquals(-1, acceptedChars.indexOf(usDecimalSeparator)); 885 886 mockDigitsKeyListener = new MockDigitsKeyListener( 887 irLocale, true /* sign */, true /* decimal */); 888 acceptedChars = new String(mockDigitsKeyListener.getAcceptedChars()); 889 for (int i = 0; i < irDigits.length; i++) { 890 assertNotEquals(acceptedChars, -1, acceptedChars.indexOf(irDigits[i])); 891 } 892 for (int i = 0; i < irSigns.length; i++) { 893 assertNotEquals(-1, acceptedChars.indexOf(irSigns[i])); 894 } 895 assertNotEquals(-1, acceptedChars.indexOf(irDecimalSeparator)); 896 for (int i = 0; i < asciiDigits.length; i++) { 897 assertEquals(-1, acceptedChars.indexOf(asciiDigits[i])); 898 } 899 assertEquals(-1, acceptedChars.indexOf(usDecimalSeparator)); 900 } 901 902 // Deprecated constructors that need to preserve pre-existing behavior. 903 @Test 904 public void testGetInputType_deprecatedConstructors() { 905 DigitsKeyListener digitsKeyListener = DigitsKeyListener.getInstance(false, false); 906 int expected = InputType.TYPE_CLASS_NUMBER; 907 assertEquals(expected, digitsKeyListener.getInputType()); 908 909 digitsKeyListener = DigitsKeyListener.getInstance(true, false); 910 expected = InputType.TYPE_CLASS_NUMBER 911 | InputType.TYPE_NUMBER_FLAG_SIGNED; 912 assertEquals(expected, digitsKeyListener.getInputType()); 913 914 digitsKeyListener = DigitsKeyListener.getInstance(false, true); 915 expected = InputType.TYPE_CLASS_NUMBER 916 | InputType.TYPE_NUMBER_FLAG_DECIMAL; 917 assertEquals(expected, digitsKeyListener.getInputType()); 918 919 digitsKeyListener = DigitsKeyListener.getInstance(true, true); 920 expected = InputType.TYPE_CLASS_NUMBER 921 | InputType.TYPE_NUMBER_FLAG_SIGNED 922 | InputType.TYPE_NUMBER_FLAG_DECIMAL; 923 assertEquals(expected, digitsKeyListener.getInputType()); 924 } 925 926 // Deprecated constructors that need to preserve pre-existing behavior. 927 @Test 928 public void testGetInputType_English() { 929 int expected = InputType.TYPE_CLASS_NUMBER; 930 DigitsKeyListener digitsKeyListener = DigitsKeyListener.getInstance( 931 Locale.US, false, false); 932 assertEquals(expected, digitsKeyListener.getInputType()); 933 digitsKeyListener = DigitsKeyListener.getInstance( 934 Locale.UK, false, false); 935 assertEquals(expected, digitsKeyListener.getInputType()); 936 937 expected = InputType.TYPE_CLASS_NUMBER 938 | InputType.TYPE_NUMBER_FLAG_SIGNED; 939 digitsKeyListener = DigitsKeyListener.getInstance(Locale.US, true, false); 940 assertEquals(expected, digitsKeyListener.getInputType()); 941 digitsKeyListener = DigitsKeyListener.getInstance(Locale.UK, true, false); 942 assertEquals(expected, digitsKeyListener.getInputType()); 943 944 expected = InputType.TYPE_CLASS_NUMBER 945 | InputType.TYPE_NUMBER_FLAG_DECIMAL; 946 digitsKeyListener = DigitsKeyListener.getInstance(Locale.US, false, true); 947 assertEquals(expected, digitsKeyListener.getInputType()); 948 digitsKeyListener = DigitsKeyListener.getInstance(Locale.UK, false, true); 949 assertEquals(expected, digitsKeyListener.getInputType()); 950 951 expected = InputType.TYPE_CLASS_NUMBER 952 | InputType.TYPE_NUMBER_FLAG_SIGNED 953 | InputType.TYPE_NUMBER_FLAG_DECIMAL; 954 digitsKeyListener = DigitsKeyListener.getInstance(Locale.US, true, true); 955 assertEquals(expected, digitsKeyListener.getInputType()); 956 digitsKeyListener = DigitsKeyListener.getInstance(Locale.UK, true, true); 957 assertEquals(expected, digitsKeyListener.getInputType()); 958 } 959 960 // Persian needs more characters then typically provided by datetime inputs, so it falls 961 // back on normal text. 962 @Test 963 public void testGetInputType_Persian() { 964 final Locale irLocale = Locale.forLanguageTag("fa-IR"); 965 final int expected = InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_NORMAL; 966 967 DigitsKeyListener digitsKeyListener = DigitsKeyListener.getInstance(irLocale, false, false); 968 assertEquals(expected, digitsKeyListener.getInputType()); 969 970 digitsKeyListener = DigitsKeyListener.getInstance(irLocale, true, false); 971 assertEquals(expected, digitsKeyListener.getInputType()); 972 973 digitsKeyListener = DigitsKeyListener.getInstance(irLocale, false, true); 974 assertEquals(expected, digitsKeyListener.getInputType()); 975 976 digitsKeyListener = DigitsKeyListener.getInstance(irLocale, true, true); 977 assertEquals(expected, digitsKeyListener.getInputType()); 978 } 979 980 /** 981 * A mocked {@link android.text.method.DigitsKeyListener} for testing purposes. 982 * 983 * Allows {@link DigitsKeyListenerTest} to call 984 * {@link android.text.method.DigitsKeyListener#getAcceptedChars()}. 985 */ 986 private class MockDigitsKeyListener extends DigitsKeyListener { 987 MockDigitsKeyListener() { 988 super(); 989 } 990 991 MockDigitsKeyListener(boolean sign, boolean decimal) { 992 super(sign, decimal); 993 } 994 995 MockDigitsKeyListener(Locale locale) { 996 super(locale); 997 } 998 999 MockDigitsKeyListener(Locale locale, boolean sign, boolean decimal) { 1000 super(locale, sign, decimal); 1001 } 1002 1003 @Override 1004 protected char[] getAcceptedChars() { 1005 return super.getAcceptedChars(); 1006 } 1007 } 1008 } 1009
