1/* Licensed to the Apache Software Foundation (ASF) under one or more 2 * contributor license agreements. See the NOTICE file distributed with 3 * this work for additional information regarding copyright ownership. 4 * The ASF licenses this file to You under the Apache License, Version 2.0 5 * (the "License"); you may not use this file except in compliance with 6 * the License. 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 17package org.apache.harmony.luni.tests.java.lang; 18 19import java.util.Arrays; 20 21import junit.framework.TestCase; 22 23public class CharacterTest extends TestCase { 24 25 public void test_isValidCodePointI() { 26 assertFalse(Character.isValidCodePoint(-1)); 27 assertTrue(Character.isValidCodePoint(0)); 28 assertTrue(Character.isValidCodePoint(1)); 29 assertFalse(Character.isValidCodePoint(Integer.MAX_VALUE)); 30 31 for (int c = '\u0000'; c <= 0x10FFFF; c++) { 32 assertTrue(Character.isValidCodePoint(c)); 33 } 34 35 assertFalse(Character.isValidCodePoint(0x10FFFF + 1)); 36 } 37 38 public void test_isSupplementaryCodePointI() { 39 assertFalse(Character.isSupplementaryCodePoint(-1)); 40 41 for (int c = '\u0000'; c <= '\uFFFF'; c++) { 42 assertFalse(Character.isSupplementaryCodePoint(c)); 43 } 44 45 for (int c = 0xFFFF + 1; c <= 0x10FFFF; c++) { 46 assertTrue(Character.isSupplementaryCodePoint(c)); 47 } 48 49 assertFalse(Character.isSupplementaryCodePoint(0x10FFFF + 1)); 50 } 51 52 public void test_isHighSurrogateC() { 53 // (\uD800-\uDBFF) 54 assertFalse(Character.isHighSurrogate((char) ('\uD800' - 1))); 55 for (int c = '\uD800'; c <= '\uDBFF'; c++) { 56 assertTrue(Character.isHighSurrogate((char) c)); 57 } 58 assertFalse(Character.isHighSurrogate((char) ('\uDBFF' + 1))); 59 assertFalse(Character.isHighSurrogate('\uFFFF')); 60 } 61 62 public void test_isLowSurrogateC() { 63 // (\uDC00-\uDFFF) 64 assertFalse(Character.isLowSurrogate((char) ('\uDC00' - 1))); 65 for (int c = '\uDC00'; c <= '\uDFFF'; c++) { 66 assertTrue(Character.isLowSurrogate((char) c)); 67 } 68 assertFalse(Character.isLowSurrogate((char) ('\uDFFF' + 1))); 69 } 70 71 public void test_isSurrogatePairCC() { 72 assertFalse(Character.isSurrogatePair('\u0000', '\u0000')); 73 assertFalse(Character.isSurrogatePair('\u0000', '\uDC00')); 74 75 assertTrue(Character.isSurrogatePair('\uD800', '\uDC00')); 76 assertTrue(Character.isSurrogatePair('\uD800', '\uDFFF')); 77 assertTrue(Character.isSurrogatePair('\uDBFF', '\uDFFF')); 78 79 assertFalse(Character.isSurrogatePair('\uDBFF', '\uF000')); 80 } 81 82 public void test_charCountI() { 83 84 for (int c = '\u0000'; c <= '\uFFFF'; c++) { 85 assertEquals(1, Character.charCount(c)); 86 } 87 88 for (int c = 0xFFFF + 1; c <= 0x10FFFF; c++) { 89 assertEquals(2, Character.charCount(c)); 90 } 91 92 // invalid code points work in this method 93 assertEquals(2, Character.charCount(Integer.MAX_VALUE)); 94 } 95 96 public void test_toCodePointCC() { 97 int result = Character.toCodePoint('\uD800', '\uDC00'); 98 assertEquals(0x00010000, result); 99 100 result = Character.toCodePoint('\uD800', '\uDC01'); 101 assertEquals(0x00010001, result); 102 103 result = Character.toCodePoint('\uD801', '\uDC01'); 104 assertEquals(0x00010401, result); 105 106 result = Character.toCodePoint('\uDBFF', '\uDFFF'); 107 assertEquals(0x00010FFFF, result); 108 } 109 110 @SuppressWarnings("cast") 111 public void test_codePointAtLjava_lang_CharSequenceI() { 112 113 assertEquals('a', Character.codePointAt((CharSequence) "abc", 0)); 114 assertEquals('b', Character.codePointAt((CharSequence) "abc", 1)); 115 assertEquals('c', Character.codePointAt((CharSequence) "abc", 2)); 116 assertEquals(0x10000, Character.codePointAt( 117 (CharSequence) "\uD800\uDC00", 0)); 118 assertEquals('\uDC00', Character.codePointAt( 119 (CharSequence) "\uD800\uDC00", 1)); 120 121 try { 122 Character.codePointAt((CharSequence) null, 0); 123 fail("No NPE."); 124 } catch (NullPointerException e) { 125 } 126 127 try { 128 Character.codePointAt((CharSequence) "abc", -1); 129 fail("No IOOBE, negative index."); 130 } catch (IndexOutOfBoundsException e) { 131 } 132 133 try { 134 Character.codePointAt((CharSequence) "abc", 4); 135 fail("No IOOBE, index too large."); 136 } catch (IndexOutOfBoundsException e) { 137 } 138 } 139 140 public void test_codePointAt$CI() { 141 142 assertEquals('a', Character.codePointAt("abc".toCharArray(), 0)); 143 assertEquals('b', Character.codePointAt("abc".toCharArray(), 1)); 144 assertEquals('c', Character.codePointAt("abc".toCharArray(), 2)); 145 assertEquals(0x10000, Character.codePointAt("\uD800\uDC00" 146 .toCharArray(), 0)); 147 assertEquals('\uDC00', Character.codePointAt("\uD800\uDC00" 148 .toCharArray(), 1)); 149 150 try { 151 Character.codePointAt((char[]) null, 0); 152 fail("No NPE."); 153 } catch (NullPointerException e) { 154 } 155 156 try { 157 Character.codePointAt("abc".toCharArray(), -1); 158 fail("No IOOBE, negative index."); 159 } catch (IndexOutOfBoundsException e) { 160 } 161 162 try { 163 Character.codePointAt("abc".toCharArray(), 4); 164 fail("No IOOBE, index too large."); 165 } catch (IndexOutOfBoundsException e) { 166 } 167 } 168 169 public void test_codePointAt$CII() { 170 171 assertEquals('a', Character.codePointAt("abc".toCharArray(), 0, 3)); 172 assertEquals('b', Character.codePointAt("abc".toCharArray(), 1, 3)); 173 assertEquals('c', Character.codePointAt("abc".toCharArray(), 2, 3)); 174 assertEquals(0x10000, Character.codePointAt("\uD800\uDC00" 175 .toCharArray(), 0, 2)); 176 assertEquals('\uDC00', Character.codePointAt("\uD800\uDC00" 177 .toCharArray(), 1, 2)); 178 assertEquals('\uD800', Character.codePointAt("\uD800\uDC00" 179 .toCharArray(), 0, 1)); 180 181 try { 182 Character.codePointAt((char[]) null, 0, 1); 183 fail("No NPE."); 184 } catch (NullPointerException e) { 185 } 186 187 try { 188 Character.codePointAt("abc".toCharArray(), -1, 3); 189 fail("No IOOBE, negative index."); 190 } catch (IndexOutOfBoundsException e) { 191 } 192 193 try { 194 Character.codePointAt("abc".toCharArray(), 4, 3); 195 fail("No IOOBE, index too large."); 196 } catch (IndexOutOfBoundsException e) { 197 } 198 199 try { 200 Character.codePointAt("abc".toCharArray(), 2, 1); 201 fail("No IOOBE, index larger than limit."); 202 } catch (IndexOutOfBoundsException e) { 203 } 204 205 try { 206 Character.codePointAt("abc".toCharArray(), 2, -1); 207 fail("No IOOBE, limit is negative."); 208 } catch (IndexOutOfBoundsException e) { 209 } 210 } 211 212 @SuppressWarnings("cast") 213 public void test_codePointBeforeLjava_lang_CharSequenceI() { 214 215 assertEquals('a', Character.codePointBefore((CharSequence) "abc", 1)); 216 assertEquals('b', Character.codePointBefore((CharSequence) "abc", 2)); 217 assertEquals('c', Character.codePointBefore((CharSequence) "abc", 3)); 218 assertEquals(0x10000, Character.codePointBefore( 219 (CharSequence) "\uD800\uDC00", 2)); 220 assertEquals('\uD800', Character.codePointBefore( 221 (CharSequence) "\uD800\uDC00", 1)); 222 223 try { 224 Character.codePointBefore((CharSequence) null, 0); 225 fail("No NPE."); 226 } catch (NullPointerException e) { 227 } 228 229 try { 230 Character.codePointBefore((CharSequence) "abc", 0); 231 fail("No IOOBE, index below one."); 232 } catch (IndexOutOfBoundsException e) { 233 } 234 235 try { 236 Character.codePointBefore((CharSequence) "abc", 4); 237 fail("No IOOBE, index too large."); 238 } catch (IndexOutOfBoundsException e) { 239 } 240 } 241 242 public void test_codePointBefore$CI() { 243 244 assertEquals('a', Character.codePointBefore("abc".toCharArray(), 1)); 245 assertEquals('b', Character.codePointBefore("abc".toCharArray(), 2)); 246 assertEquals('c', Character.codePointBefore("abc".toCharArray(), 3)); 247 assertEquals(0x10000, Character.codePointBefore("\uD800\uDC00" 248 .toCharArray(), 2)); 249 assertEquals('\uD800', Character.codePointBefore("\uD800\uDC00" 250 .toCharArray(), 1)); 251 252 try { 253 Character.codePointBefore((char[]) null, 0); 254 fail("No NPE."); 255 } catch (NullPointerException e) { 256 } 257 258 try { 259 Character.codePointBefore("abc".toCharArray(), -1); 260 fail("No IOOBE, negative index."); 261 } catch (IndexOutOfBoundsException e) { 262 } 263 264 try { 265 Character.codePointBefore("abc".toCharArray(), 4); 266 fail("No IOOBE, index too large."); 267 } catch (IndexOutOfBoundsException e) { 268 } 269 } 270 271 public void test_codePointBefore$CII() { 272 273 assertEquals('a', Character.codePointBefore("abc".toCharArray(), 1, 0)); 274 assertEquals('b', Character.codePointBefore("abc".toCharArray(), 2, 0)); 275 assertEquals('c', Character.codePointBefore("abc".toCharArray(), 3, 0)); 276 assertEquals(0x10000, Character.codePointBefore("\uD800\uDC00" 277 .toCharArray(), 2, 0)); 278 assertEquals('\uDC00', Character.codePointBefore("\uD800\uDC00" 279 .toCharArray(), 2, 1)); 280 assertEquals('\uD800', Character.codePointBefore("\uD800\uDC00" 281 .toCharArray(), 1, 0)); 282 283 try { 284 Character.codePointBefore((char[]) null, 1, 0); 285 fail("No NPE."); 286 } catch (NullPointerException e) { 287 } 288 289 try { 290 Character.codePointBefore("abc".toCharArray(), 0, 1); 291 fail("No IOOBE, index less than start."); 292 } catch (IndexOutOfBoundsException e) { 293 } 294 295 try { 296 Character.codePointBefore("abc".toCharArray(), 4, 0); 297 fail("No IOOBE, index larger than length."); 298 } catch (IndexOutOfBoundsException e) { 299 } 300 301 try { 302 Character.codePointBefore("abc".toCharArray(), 2, -1); 303 fail("No IOOBE, start is negative."); 304 } catch (IndexOutOfBoundsException e) { 305 } 306 307 try { 308 Character.codePointBefore("abc".toCharArray(), 2, 4); 309 fail("No IOOBE, start larger than length."); 310 } catch (IndexOutOfBoundsException e) { 311 } 312 } 313 314 public void test_toCharsI$CI() { 315 char[] dst = new char[2]; 316 int result = Character.toChars(0x10000, dst, 0); 317 assertEquals(2, result); 318 assertTrue(Arrays.equals(new char[] { '\uD800', '\uDC00' }, dst)); 319 320 result = Character.toChars(0x10001, dst, 0); 321 assertEquals(2, result); 322 assertTrue(Arrays.equals(new char[] { '\uD800', '\uDC01' }, dst)); 323 324 result = Character.toChars(0x10401, dst, 0); 325 assertEquals(2, result); 326 assertTrue(Arrays.equals(new char[] { '\uD801', '\uDC01' }, dst)); 327 328 result = Character.toChars(0x10FFFF, dst, 0); 329 assertEquals(2, result); 330 assertTrue(Arrays.equals(new char[] { '\uDBFF', '\uDFFF' }, dst)); 331 332 try { 333 Character.toChars(Integer.MAX_VALUE, new char[2], 0); 334 fail("No IAE, invalid code point."); 335 } catch (IllegalArgumentException e) { 336 } 337 338 try { 339 Character.toChars('a', null, 0); 340 fail("No NPE, null char[]."); 341 } catch (NullPointerException e) { 342 } 343 344 try { 345 Character.toChars('a', new char[1], -1); 346 fail("No IOOBE, negative index."); 347 } catch (IndexOutOfBoundsException e) { 348 } 349 350 try { 351 Character.toChars('a', new char[1], 1); 352 fail("No IOOBE, index equal to length."); 353 } catch (IndexOutOfBoundsException e) { 354 } 355 } 356 357 public void test_toCharsI() { 358 assertTrue(Arrays.equals(new char[] { '\uD800', '\uDC00' }, Character 359 .toChars(0x10000))); 360 assertTrue(Arrays.equals(new char[] { '\uD800', '\uDC01' }, Character 361 .toChars(0x10001))); 362 assertTrue(Arrays.equals(new char[] { '\uD801', '\uDC01' }, Character 363 .toChars(0x10401))); 364 assertTrue(Arrays.equals(new char[] { '\uDBFF', '\uDFFF' }, Character 365 .toChars(0x10FFFF))); 366 367 try { 368 Character.toChars(Integer.MAX_VALUE); 369 fail("No IAE, invalid code point."); 370 } catch (IllegalArgumentException e) { 371 } 372 } 373 374 public void test_codePointCountLjava_lang_CharSequenceII() { 375 assertEquals(1, Character.codePointCount("\uD800\uDC00", 0, 2)); 376 assertEquals(1, Character.codePointCount("\uD800\uDC01", 0, 2)); 377 assertEquals(1, Character.codePointCount("\uD801\uDC01", 0, 2)); 378 assertEquals(1, Character.codePointCount("\uDBFF\uDFFF", 0, 2)); 379 380 assertEquals(3, Character.codePointCount("a\uD800\uDC00b", 0, 4)); 381 assertEquals(4, Character.codePointCount("a\uD800\uDC00b\uD800", 0, 5)); 382 383 try { 384 Character.codePointCount((CharSequence) null, 0, 1); 385 fail("No NPE, null char sequence."); 386 } catch (NullPointerException e) { 387 } 388 389 try { 390 Character.codePointCount("abc", -1, 1); 391 fail("No IOOBE, negative start."); 392 } catch (IndexOutOfBoundsException e) { 393 } 394 395 try { 396 Character.codePointCount("abc", 0, 4); 397 fail("No IOOBE, end greater than length."); 398 } catch (IndexOutOfBoundsException e) { 399 } 400 401 try { 402 Character.codePointCount("abc", 2, 1); 403 fail("No IOOBE, end greater than start."); 404 } catch (IndexOutOfBoundsException e) { 405 } 406 } 407 408 public void test_offsetByCodePointsLjava_lang_CharSequenceII() { 409 int result = Character.offsetByCodePoints("a\uD800\uDC00b", 0, 2); 410 assertEquals(3, result); 411 412 result = Character.offsetByCodePoints("abcd", 3, -1); 413 assertEquals(2, result); 414 415 result = Character.offsetByCodePoints("a\uD800\uDC00b", 0, 3); 416 assertEquals(4, result); 417 418 result = Character.offsetByCodePoints("a\uD800\uDC00b", 3, -1); 419 assertEquals(1, result); 420 421 result = Character.offsetByCodePoints("a\uD800\uDC00b", 3, 0); 422 assertEquals(3, result); 423 424 result = Character.offsetByCodePoints("\uD800\uDC00bc", 3, 0); 425 assertEquals(3, result); 426 427 result = Character.offsetByCodePoints("a\uDC00bc", 3, -1); 428 assertEquals(2, result); 429 430 result = Character.offsetByCodePoints("a\uD800bc", 3, -1); 431 assertEquals(2, result); 432 433 try { 434 Character.offsetByCodePoints((CharSequence) null, 0, 1); 435 fail(); 436 } catch (NullPointerException e) { 437 } 438 439 try { 440 Character.offsetByCodePoints("abc", -1, 1); 441 fail(); 442 } catch (IndexOutOfBoundsException e) { 443 } 444 445 try { 446 Character.offsetByCodePoints("abc", 4, 1); 447 fail(); 448 } catch (IndexOutOfBoundsException e) { 449 } 450 451 try { 452 Character.offsetByCodePoints("abc", 1, 3); 453 fail(); 454 } catch (IndexOutOfBoundsException e) { 455 } 456 457 try { 458 Character.offsetByCodePoints("abc", 1, -2); 459 fail(); 460 } catch (IndexOutOfBoundsException e) { 461 } 462 } 463 464 public void test_offsetByCodePoints$CIIII() { 465 int result = Character.offsetByCodePoints("a\uD800\uDC00b" 466 .toCharArray(), 0, 4, 0, 2); 467 assertEquals(3, result); 468 469 result = Character.offsetByCodePoints("a\uD800\uDC00b".toCharArray(), 470 0, 4, 0, 3); 471 assertEquals(4, result); 472 473 result = Character.offsetByCodePoints("a\uD800\uDC00b\uD800c" 474 .toCharArray(), 0, 5, 0, 3); 475 assertEquals(4, result); 476 477 result = Character 478 .offsetByCodePoints("abcd".toCharArray(), 0, 4, 3, -1); 479 assertEquals(2, result); 480 481 result = Character 482 .offsetByCodePoints("abcd".toCharArray(), 1, 2, 3, -2); 483 assertEquals(1, result); 484 485 result = Character.offsetByCodePoints("a\uD800\uDC00b".toCharArray(), 486 0, 4, 3, -1); 487 assertEquals(1, result); 488 489 result = Character.offsetByCodePoints("a\uD800\uDC00b".toCharArray(), 490 0, 2, 2, -1); 491 assertEquals(1, result); 492 493 result = Character.offsetByCodePoints("a\uD800\uDC00b".toCharArray(), 494 0, 4, 3, 0); 495 assertEquals(3, result); 496 497 result = Character.offsetByCodePoints("\uD800\uDC00bc".toCharArray(), 498 0, 4, 3, 0); 499 assertEquals(3, result); 500 501 result = Character.offsetByCodePoints("a\uDC00bc".toCharArray(), 0, 4, 502 3, -1); 503 assertEquals(2, result); 504 505 result = Character.offsetByCodePoints("a\uD800bc".toCharArray(), 0, 4, 506 3, -1); 507 assertEquals(2, result); 508 509 try { 510 Character.offsetByCodePoints(null, 0, 4, 1, 1); 511 fail(); 512 } catch (NullPointerException e) { 513 } 514 515 try { 516 Character.offsetByCodePoints("abcd".toCharArray(), -1, 4, 1, 1); 517 fail(); 518 } catch (IndexOutOfBoundsException e) { 519 } 520 521 try { 522 Character.offsetByCodePoints("abcd".toCharArray(), 0, -1, 1, 1); 523 fail(); 524 } catch (IndexOutOfBoundsException e) { 525 } 526 527 try { 528 Character.offsetByCodePoints("abcd".toCharArray(), 2, 4, 1, 1); 529 fail(); 530 } catch (IndexOutOfBoundsException e) { 531 } 532 533 try { 534 Character.offsetByCodePoints("abcd".toCharArray(), 1, 3, 0, 1); 535 fail(); 536 } catch (IndexOutOfBoundsException e) { 537 } 538 539 try { 540 Character.offsetByCodePoints("abcd".toCharArray(), 1, 1, 3, 1); 541 fail(); 542 } catch (IndexOutOfBoundsException e) { 543 } 544 545 try { 546 Character.offsetByCodePoints("abc".toCharArray(), 0, 3, 1, 3); 547 fail(); 548 } catch (IndexOutOfBoundsException e) { 549 } 550 551 try { 552 Character.offsetByCodePoints("abc".toCharArray(), 0, 2, 1, 2); 553 fail(); 554 } catch (IndexOutOfBoundsException e) { 555 } 556 557 try { 558 Character.offsetByCodePoints("abc".toCharArray(), 1, 3, 1, -2); 559 fail(); 560 } catch (IndexOutOfBoundsException e) { 561 } 562 } 563 564 /** 565 * @tests java.lang.Character#compareTo(Character) 566 */ 567 public void test_compareToLjava_lang_Byte() { 568 final Character min = new Character(Character.MIN_VALUE); 569 final Character mid = new Character((char)(Character.MAX_VALUE/2)); 570 final Character max = new Character(Character.MAX_VALUE); 571 572 assertTrue(max.compareTo(max) == 0); 573 assertTrue(min.compareTo(min) == 0); 574 assertTrue(mid.compareTo(mid) == 0); 575 576 assertTrue(max.compareTo(mid) > 0); 577 assertTrue(max.compareTo(min) > 0); 578 579 assertTrue(mid.compareTo(max) < 0); 580 assertTrue(mid.compareTo(min) > 0); 581 582 assertTrue(min.compareTo(mid) < 0); 583 assertTrue(min.compareTo(max) < 0); 584 585 try { 586 min.compareTo(null); 587 fail("No NPE"); 588 } catch (NullPointerException e) { 589 } 590 } 591 592 public void test_codePointAt_Invalid() { 593 594 try { 595 Character.codePointAt(null, 6, 4); 596 fail("Expected IndexOutOfBoundsException"); 597 } catch (IndexOutOfBoundsException e) { 598 // expected 599 } 600 601 try { 602 Character.codePointAt(null, 4, 6); 603 fail("Expected NullPointerException"); 604 } catch (NullPointerException e) { 605 // expected 606 } 607 608 try { 609 Character.codePointAt(null, 0, 0); 610 fail("Expected IndexOutOfBoundsException"); 611 } catch (IndexOutOfBoundsException e) { 612 // expected 613 } 614 } 615 616 /** 617 * @tests java.lang.Character#Character(char) 618 */ 619 public void test_ConstructorC() { 620 assertEquals("Constructor failed", 'T', new Character('T').charValue()); 621 } 622 623 /** 624 * @tests java.lang.Character#charValue() 625 */ 626 public void test_charValue() { 627 assertEquals("Incorrect char value returned", 'T', new Character('T') 628 .charValue()); 629 } 630 631 /** 632 * @tests java.lang.Character#compareTo(java.lang.Character) 633 */ 634 public void test_compareToLjava_lang_Character() { 635 Character c = new Character('c'); 636 Character x = new Character('c'); 637 Character y = new Character('b'); 638 Character z = new Character('d'); 639 640 assertEquals("Returned false for same Character", 0, c.compareTo(c)); 641 assertEquals("Returned false for identical Character", 642 0, c.compareTo(x)); 643 assertTrue("Returned other than less than for lesser char", c 644 .compareTo(y) > 0); 645 assertTrue("Returned other than greater than for greater char", c 646 .compareTo(z) < 0); 647 } 648 649 /** 650 * @tests java.lang.Character#digit(char, int) 651 */ 652 public void test_digitCI() { 653 assertEquals("Returned incorrect digit", 1, Character.digit('1', 10)); 654 assertEquals("Returned incorrect digit", 15, Character.digit('F', 16)); 655 } 656 657 /** 658 * @tests java.lang.Character#digit(int, int) 659 */ 660 public void test_digit_II() { 661 assertEquals(1, Character.digit((int)'1', 10)); 662 assertEquals(15, Character.digit((int)'F', 16)); 663 664 assertEquals(-1, Character.digit(0x0000, 37)); 665 assertEquals(-1, Character.digit(0x0045, 10)); 666 667 assertEquals(10, Character.digit(0x0041, 20)); 668 assertEquals(10, Character.digit(0x0061, 20)); 669 670 assertEquals(-1, Character.digit(0x110000, 20)); 671 } 672 673 /** 674 * @tests java.lang.Character#equals(java.lang.Object) 675 */ 676 public void test_equalsLjava_lang_Object() { 677 // Test for method boolean java.lang.Character.equals(java.lang.Object) 678 assertTrue("Equality test failed", new Character('A') 679 .equals(new Character('A'))); 680 assertTrue("Equality test failed", !(new Character('A') 681 .equals(new Character('a')))); 682 } 683 684 /** 685 * @tests java.lang.Character#forDigit(int, int) 686 */ 687 public void test_forDigitII() { 688 char hexChars[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 689 'a', 'b', 'c', 'd', 'e', 'f' }; 690 for (int i = 0; i < hexChars.length; i++) { 691 assertTrue("Returned incorrect char for " + Integer.toString(i), 692 Character.forDigit(i, hexChars.length) == hexChars[i]); 693 } 694 695 char decimalChars[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', 696 '9' }; 697 for (int i = 0; i < decimalChars.length; i++) { 698 assertTrue( 699 "Returned incorrect char for " + Integer.toString(i), 700 Character.forDigit(i, decimalChars.length) == decimalChars[i]); 701 } 702 703 } 704 705 /** 706 * @tests java.lang.Character#getNumericValue(char) 707 */ 708 public void test_getNumericValueC() { 709 assertEquals("Returned incorrect numeric value 1", 1, Character 710 .getNumericValue('1')); 711 assertEquals("Returned incorrect numeric value 2", 15, Character 712 .getNumericValue('F')); 713 assertEquals("Returned incorrect numeric value 3", -1, Character 714 .getNumericValue('\u221e')); 715 assertEquals("Returned incorrect numeric value 4", -2, Character 716 .getNumericValue('\u00be')); 717 assertEquals("Returned incorrect numeric value 5", 10000, Character 718 .getNumericValue('\u2182')); 719 assertEquals("Returned incorrect numeric value 6", 2, Character 720 .getNumericValue('\uff12')); 721 } 722 723 /** 724 * @tests java.lang.Character#getNumericValue(int) 725 */ 726 public void test_getNumericValue_I() { 727 assertEquals(1, Character.getNumericValue((int)'1')); 728 assertEquals(15, Character.getNumericValue((int)'F')); 729 assertEquals(-1, Character.getNumericValue((int)'\u221e')); 730 assertEquals(-2, Character.getNumericValue((int)'\u00be')); 731 assertEquals(10000, Character.getNumericValue((int)'\u2182')); 732 assertEquals(2, Character.getNumericValue((int)'\uff12')); 733 assertEquals(-1, Character.getNumericValue(0xFFFF)); 734 735 assertEquals(-1, Character.getNumericValue(0xFFFF)); 736 assertEquals(0, Character.getNumericValue(0x1D7CE)); 737 assertEquals(0, Character.getNumericValue(0x1D7D8)); 738 assertEquals(-1, Character.getNumericValue(0x2F800)); 739 assertEquals(-1, Character.getNumericValue(0x10FFFD)); 740 assertEquals(-1, Character.getNumericValue(0x110000)); 741 742 assertEquals(50, Character.getNumericValue(0x216C)); 743 744 assertEquals(10, Character.getNumericValue(0x0041)); 745 assertEquals(35, Character.getNumericValue(0x005A)); 746 assertEquals(10, Character.getNumericValue(0x0061)); 747 assertEquals(35, Character.getNumericValue(0x007A)); 748 assertEquals(10, Character.getNumericValue(0xFF21)); 749 750 //FIXME depends on ICU4J 751 //assertEquals(35, Character.getNumericValue(0xFF3A)); 752 753 assertEquals(10, Character.getNumericValue(0xFF41)); 754 assertEquals(35, Character.getNumericValue(0xFF5A)); 755 } 756 757 /** 758 * @tests java.lang.Character#getType(char) 759 */ 760 public void test_getTypeC() { 761 assertTrue("Returned incorrect type for: \n", 762 Character.getType('\n') == Character.CONTROL); 763 assertTrue("Returned incorrect type for: 1", 764 Character.getType('1') == Character.DECIMAL_DIGIT_NUMBER); 765 assertTrue("Returned incorrect type for: ' '", 766 Character.getType(' ') == Character.SPACE_SEPARATOR); 767 assertTrue("Returned incorrect type for: a", 768 Character.getType('a') == Character.LOWERCASE_LETTER); 769 assertTrue("Returned incorrect type for: A", 770 Character.getType('A') == Character.UPPERCASE_LETTER); 771 assertTrue("Returned incorrect type for: <", 772 Character.getType('<') == Character.MATH_SYMBOL); 773 assertTrue("Returned incorrect type for: ;", 774 Character.getType(';') == Character.OTHER_PUNCTUATION); 775 assertTrue("Returned incorrect type for: _", 776 Character.getType('_') == Character.CONNECTOR_PUNCTUATION); 777 assertTrue("Returned incorrect type for: $", 778 Character.getType('$') == Character.CURRENCY_SYMBOL); 779 assertTrue("Returned incorrect type for: \u2029", Character 780 .getType('\u2029') == Character.PARAGRAPH_SEPARATOR); 781 782 assertEquals("Wrong constant for FORMAT", 16, Character.FORMAT); 783 assertEquals("Wrong constant for PRIVATE_USE", 784 18, Character.PRIVATE_USE); 785 } 786 787 /** 788 * @tests java.lang.Character#getType(int) 789 */ 790 public void test_getType_I() { 791 assertTrue(Character.getType((int) '\n') == Character.CONTROL); 792 assertTrue(Character.getType((int) '1') == Character.DECIMAL_DIGIT_NUMBER); 793 assertTrue(Character.getType((int) ' ') == Character.SPACE_SEPARATOR); 794 assertTrue(Character.getType((int) 'a') == Character.LOWERCASE_LETTER); 795 assertTrue(Character.getType((int) 'A') == Character.UPPERCASE_LETTER); 796 assertTrue(Character.getType((int) '<') == Character.MATH_SYMBOL); 797 assertTrue(Character.getType((int) ';') == Character.OTHER_PUNCTUATION); 798 assertTrue(Character.getType((int) '_') == Character.CONNECTOR_PUNCTUATION); 799 assertTrue(Character.getType((int) '$') == Character.CURRENCY_SYMBOL); 800 assertTrue(Character.getType((int) '\u2029') == Character.PARAGRAPH_SEPARATOR); 801 802 assertTrue(Character.getType(0x9FFF) == Character.UNASSIGNED); 803 assertTrue(Character.getType(0x30000) == Character.UNASSIGNED); 804 assertTrue(Character.getType(0x110000) == Character.UNASSIGNED); 805 806 assertTrue(Character.getType(0x0041) == Character.UPPERCASE_LETTER); 807 assertTrue(Character.getType(0x10400) == Character.UPPERCASE_LETTER); 808 809 assertTrue(Character.getType(0x0061) == Character.LOWERCASE_LETTER); 810 assertTrue(Character.getType(0x10428) == Character.LOWERCASE_LETTER); 811 812 assertTrue(Character.getType(0x01C5) == Character.TITLECASE_LETTER); 813 assertTrue(Character.getType(0x1FFC) == Character.TITLECASE_LETTER); 814 815 assertTrue(Character.getType(0x02B0) == Character.MODIFIER_LETTER); 816 assertTrue(Character.getType(0xFF9F) == Character.MODIFIER_LETTER); 817 818 assertTrue(Character.getType(0x01BB) == Character.OTHER_LETTER); 819 assertTrue(Character.getType(0x2F888) == Character.OTHER_LETTER); 820 821 assertTrue(Character.getType(0x0F82) == Character.NON_SPACING_MARK); 822 assertTrue(Character.getType(0x1D180) == Character.NON_SPACING_MARK); 823 824 assertTrue(Character.getType(0x0488) == Character.ENCLOSING_MARK); 825 assertTrue(Character.getType(0x20DE) == Character.ENCLOSING_MARK); 826 827 assertTrue(Character.getType(0x1938) == Character.COMBINING_SPACING_MARK); 828 assertTrue(Character.getType(0x1D165) == Character.COMBINING_SPACING_MARK); 829 830 assertTrue(Character.getType(0x194D) == Character.DECIMAL_DIGIT_NUMBER); 831 assertTrue(Character.getType(0x1D7CE) == Character.DECIMAL_DIGIT_NUMBER); 832 833 assertTrue(Character.getType(0x2160) == Character.LETTER_NUMBER); 834 assertTrue(Character.getType(0x1034A) == Character.LETTER_NUMBER); 835 836 assertTrue(Character.getType(0x00B2) == Character.OTHER_NUMBER); 837 assertTrue(Character.getType(0x10120) == Character.OTHER_NUMBER); 838 839 assertTrue(Character.getType(0x0020) == Character.SPACE_SEPARATOR); 840 assertTrue(Character.getType(0x3000) == Character.SPACE_SEPARATOR); 841 842 assertTrue(Character.getType(0x2028) == Character.LINE_SEPARATOR); 843 844 assertTrue(Character.getType(0x2029) == Character.PARAGRAPH_SEPARATOR); 845 846 assertTrue(Character.getType(0x0000) == Character.CONTROL); 847 assertTrue(Character.getType(0x009F) == Character.CONTROL); 848 849 assertTrue(Character.getType(0x00AD) == Character.FORMAT); 850 assertTrue(Character.getType(0xE007F) == Character.FORMAT); 851 852 assertTrue(Character.getType(0xE000) == Character.PRIVATE_USE); 853 assertTrue(Character.getType(0x10FFFD) == Character.PRIVATE_USE); 854 855 assertTrue(Character.getType(0xD800) == Character.SURROGATE); 856 assertTrue(Character.getType(0xDFFF) == Character.SURROGATE); 857 858 assertTrue(Character.getType(0xFE31) == Character.DASH_PUNCTUATION); 859 assertTrue(Character.getType(0xFF0D) == Character.DASH_PUNCTUATION); 860 861 assertTrue(Character.getType(0x0028) == Character.START_PUNCTUATION); 862 assertTrue(Character.getType(0xFF62) == Character.START_PUNCTUATION); 863 864 assertTrue(Character.getType(0x0029) == Character.END_PUNCTUATION); 865 assertTrue(Character.getType(0xFF63) == Character.END_PUNCTUATION); 866 867 assertTrue(Character.getType(0x005F) == Character.CONNECTOR_PUNCTUATION); 868 assertTrue(Character.getType(0xFF3F) == Character.CONNECTOR_PUNCTUATION); 869 870 assertTrue(Character.getType(0x2034) == Character.OTHER_PUNCTUATION); 871 assertTrue(Character.getType(0x1039F) == Character.OTHER_PUNCTUATION); 872 873 assertTrue(Character.getType(0x002B) == Character.MATH_SYMBOL); 874 assertTrue(Character.getType(0x1D6C1) == Character.MATH_SYMBOL); 875 876 assertTrue(Character.getType(0x0024) == Character.CURRENCY_SYMBOL); 877 assertTrue(Character.getType(0xFFE6) == Character.CURRENCY_SYMBOL); 878 879 assertTrue(Character.getType(0x005E) == Character.MODIFIER_SYMBOL); 880 assertTrue(Character.getType(0xFFE3) == Character.MODIFIER_SYMBOL); 881 882 assertTrue(Character.getType(0x00A6) == Character.OTHER_SYMBOL); 883 assertTrue(Character.getType(0x1D356) == Character.OTHER_SYMBOL); 884 885 assertTrue(Character.getType(0x00AB) == Character.INITIAL_QUOTE_PUNCTUATION); 886 assertTrue(Character.getType(0x2039) == Character.INITIAL_QUOTE_PUNCTUATION); 887 888 assertTrue(Character.getType(0x00BB) == Character.FINAL_QUOTE_PUNCTUATION); 889 assertTrue(Character.getType(0x203A) == Character.FINAL_QUOTE_PUNCTUATION); 890 } 891 892 /** 893 * @tests java.lang.Character#hashCode() 894 */ 895 public void test_hashCode() { 896 assertEquals("Incorrect hash returned", 897 89, new Character('Y').hashCode()); 898 } 899 900 /** 901 * @tests java.lang.Character#isDefined(char) 902 */ 903 public void test_isDefinedC() { 904 assertTrue("Defined character returned false", Character.isDefined('v')); 905 assertTrue("Defined character returned false", Character 906 .isDefined('\u6039')); 907 } 908 909 /** 910 * @tests java.lang.Character#isDefined(int) 911 */ 912 public void test_isDefined_I(){ 913 assertTrue(Character.isDefined((int)'v')); 914 assertTrue(Character.isDefined((int)'\u6039')); 915 assertTrue(Character.isDefined(0x10300)); 916 917 assertFalse(Character.isDefined(0x30000)); 918 assertFalse(Character.isDefined(0x3FFFF)); 919 assertFalse(Character.isDefined(0x110000)); 920 } 921 922 /** 923 * @tests java.lang.Character#isDigit(char) 924 */ 925 public void test_isDigitC() { 926 assertTrue("Digit returned false", Character.isDigit('1')); 927 assertTrue("Non-Digit returned false", !Character.isDigit('A')); 928 } 929 930 /** 931 * @tests java.lang.Character#isDigit(int) 932 */ 933 public void test_isDigit_I() { 934 assertTrue(Character.isDigit((int) '1')); 935 assertFalse(Character.isDigit((int) 'A')); 936 937 assertTrue(Character.isDigit(0x0030)); 938 assertTrue(Character.isDigit(0x0035)); 939 assertTrue(Character.isDigit(0x0039)); 940 941 assertTrue(Character.isDigit(0x0660)); 942 assertTrue(Character.isDigit(0x0665)); 943 assertTrue(Character.isDigit(0x0669)); 944 945 assertTrue(Character.isDigit(0x06F0)); 946 assertTrue(Character.isDigit(0x06F5)); 947 assertTrue(Character.isDigit(0x06F9)); 948 949 assertTrue(Character.isDigit(0x0966)); 950 assertTrue(Character.isDigit(0x096A)); 951 assertTrue(Character.isDigit(0x096F)); 952 953 assertTrue(Character.isDigit(0xFF10)); 954 assertTrue(Character.isDigit(0xFF15)); 955 assertTrue(Character.isDigit(0xFF19)); 956 957 assertTrue(Character.isDigit(0x1D7CE)); 958 assertTrue(Character.isDigit(0x1D7D8)); 959 960 assertFalse(Character.isDigit(0x2F800)); 961 assertFalse(Character.isDigit(0x10FFFD)); 962 assertFalse(Character.isDigit(0x110000)); 963 } 964 965 /** 966 * @tests java.lang.Character#isIdentifierIgnorable(char) 967 */ 968 public void test_isIdentifierIgnorableC() { 969 assertTrue("Ignorable whitespace returned false", Character 970 .isIdentifierIgnorable('\u0007')); 971 assertTrue("Ignorable non - whitespace control returned false", 972 Character.isIdentifierIgnorable('\u000f')); 973 assertTrue("Ignorable join control returned false", Character 974 .isIdentifierIgnorable('\u200e')); 975 976 // the spec is wrong, and our implementation is correct 977 assertTrue("Ignorable bidi control returned false", Character 978 .isIdentifierIgnorable('\u202b')); 979 980 assertTrue("Ignorable format control returned false", Character 981 .isIdentifierIgnorable('\u206c')); 982 assertTrue("Ignorable zero-width no-break returned false", Character 983 .isIdentifierIgnorable('\ufeff')); 984 985 assertTrue("Non-Ignorable returned true", !Character 986 .isIdentifierIgnorable('\u0065')); 987 } 988 989 /** 990 * @tests java.lang.Character#isIdentifierIgnorable(int) 991 */ 992 public void test_isIdentifierIgnorable_I() { 993 assertTrue(Character.isIdentifierIgnorable(0x0000)); 994 assertTrue(Character.isIdentifierIgnorable(0x0004)); 995 assertTrue(Character.isIdentifierIgnorable(0x0008)); 996 997 assertTrue(Character.isIdentifierIgnorable(0x000E)); 998 assertTrue(Character.isIdentifierIgnorable(0x0013)); 999 assertTrue(Character.isIdentifierIgnorable(0x001B)); 1000 1001 assertTrue(Character.isIdentifierIgnorable(0x007F)); 1002 assertTrue(Character.isIdentifierIgnorable(0x008F)); 1003 assertTrue(Character.isIdentifierIgnorable(0x009F)); 1004 1005 assertTrue(Character.isIdentifierIgnorable(0x202b)); 1006 assertTrue(Character.isIdentifierIgnorable(0x206c)); 1007 assertTrue(Character.isIdentifierIgnorable(0xfeff)); 1008 assertFalse(Character.isIdentifierIgnorable(0x0065)); 1009 1010 assertTrue(Character.isIdentifierIgnorable(0x1D173)); 1011 1012 assertFalse(Character.isIdentifierIgnorable(0x10FFFD)); 1013 assertFalse(Character.isIdentifierIgnorable(0x110000)); 1014 } 1015 1016 /** 1017 * @tests java.lang.Character#isMirrored(char) 1018 */ 1019 public void test_isMirrored_C() { 1020 assertTrue(Character.isMirrored('\u0028')); 1021 assertFalse(Character.isMirrored('\uFFFF')); 1022 } 1023 1024 /** 1025 * @tests java.lang.Character#isMirrored(int) 1026 */ 1027 public void test_isMirrored_I() { 1028 assertTrue(Character.isMirrored(0x0028)); 1029 assertFalse(Character.isMirrored(0xFFFF)); 1030 assertFalse(Character.isMirrored(0x110000)); 1031 } 1032 1033 /** 1034 * @tests java.lang.Character#isISOControl(char) 1035 */ 1036 public void test_isISOControlC() { 1037 // Test for method boolean java.lang.Character.isISOControl(char) 1038 for (int i = 0; i < 32; i++) 1039 assertTrue("ISOConstrol char returned false", Character 1040 .isISOControl((char) i)); 1041 1042 for (int i = 127; i < 160; i++) 1043 assertTrue("ISOConstrol char returned false", Character 1044 .isISOControl((char) i)); 1045 } 1046 1047 /** 1048 * @tests java.lang.Character#isISOControl(int) 1049 */ 1050 public void test_isISOControlI() { 1051 // Test for method boolean java.lang.Character.isISOControl(char) 1052 for (int i = 0; i < 32; i++) 1053 assertTrue("ISOConstrol char returned false", Character 1054 .isISOControl(i)); 1055 1056 for (int i = 127; i < 160; i++) 1057 assertTrue("ISOConstrol char returned false", Character 1058 .isISOControl(i)); 1059 1060 for (int i = 160; i < 260; i++) 1061 assertFalse("Not ISOConstrol char returned true", Character 1062 .isISOControl(i)); 1063 1064 } 1065 1066 1067 /** 1068 * @tests java.lang.Character#isJavaIdentifierPart(char) 1069 */ 1070 public void test_isJavaIdentifierPartC() { 1071 assertTrue("letter returned false", Character.isJavaIdentifierPart('l')); 1072 assertTrue("currency returned false", Character 1073 .isJavaIdentifierPart('$')); 1074 assertTrue("digit returned false", Character.isJavaIdentifierPart('9')); 1075 assertTrue("connecting char returned false", Character 1076 .isJavaIdentifierPart('_')); 1077 assertTrue("ignorable control returned true", !Character 1078 .isJavaIdentifierPart('\u200b')); 1079 assertTrue("semi returned true", !Character.isJavaIdentifierPart(';')); 1080 } 1081 1082 /** 1083 * @tests java.lang.Character#isJavaIdentifierPart(int) 1084 */ 1085 public void test_isJavaIdentifierPart_I() { 1086 assertTrue(Character.isJavaIdentifierPart((int)'l')); 1087 assertTrue(Character.isJavaIdentifierPart((int)'$')); 1088 assertTrue(Character.isJavaIdentifierPart((int)'9')); 1089 assertTrue(Character.isJavaIdentifierPart((int)'_')); 1090 assertFalse(Character.isJavaIdentifierPart((int)';')); 1091 1092 assertTrue(Character.isJavaIdentifierPart(0x0041)); 1093 assertTrue(Character.isJavaIdentifierPart(0x10400)); 1094 assertTrue(Character.isJavaIdentifierPart(0x0061)); 1095 assertTrue(Character.isJavaIdentifierPart(0x10428)); 1096 assertTrue(Character.isJavaIdentifierPart(0x01C5)); 1097 assertTrue(Character.isJavaIdentifierPart(0x1FFC)); 1098 assertTrue(Character.isJavaIdentifierPart(0x02B0)); 1099 assertTrue(Character.isJavaIdentifierPart(0xFF9F)); 1100 assertTrue(Character.isJavaIdentifierPart(0x01BB)); 1101 assertTrue(Character.isJavaIdentifierPart(0x2F888)); 1102 1103 assertTrue(Character.isJavaIdentifierPart(0x0024)); 1104 assertTrue(Character.isJavaIdentifierPart(0xFFE6)); 1105 1106 assertTrue(Character.isJavaIdentifierPart(0x005F)); 1107 assertTrue(Character.isJavaIdentifierPart(0xFF3F)); 1108 1109 assertTrue(Character.isJavaIdentifierPart(0x194D)); 1110 assertTrue(Character.isJavaIdentifierPart(0x1D7CE)); 1111 assertTrue(Character.isJavaIdentifierPart(0x2160)); 1112 assertTrue(Character.isJavaIdentifierPart(0x1034A)); 1113 1114 assertTrue(Character.isJavaIdentifierPart(0x0F82)); 1115 assertTrue(Character.isJavaIdentifierPart(0x1D180)); 1116 1117 assertTrue(Character.isJavaIdentifierPart(0x0000)); 1118 assertTrue(Character.isJavaIdentifierPart(0x0008)); 1119 assertTrue(Character.isJavaIdentifierPart(0x000E)); 1120 assertTrue(Character.isJavaIdentifierPart(0x001B)); 1121 assertTrue(Character.isJavaIdentifierPart(0x007F)); 1122 assertTrue(Character.isJavaIdentifierPart(0x009F)); 1123 assertTrue(Character.isJavaIdentifierPart(0x00AD)); 1124 assertTrue(Character.isJavaIdentifierPart(0xE007F)); 1125 1126 //RI fails because 0x200B changes category in Unicode 4.1 1127 assertTrue(Character.isJavaIdentifierPart(0x200B)); 1128 } 1129 1130 /** 1131 * @tests java.lang.Character#isJavaIdentifierStart(char) 1132 */ 1133 public void test_isJavaIdentifierStartC() { 1134 assertTrue("letter returned false", Character 1135 .isJavaIdentifierStart('l')); 1136 assertTrue("currency returned false", Character 1137 .isJavaIdentifierStart('$')); 1138 assertTrue("connecting char returned false", Character 1139 .isJavaIdentifierStart('_')); 1140 assertTrue("digit returned true", !Character.isJavaIdentifierStart('9')); 1141 assertTrue("ignorable control returned true", !Character 1142 .isJavaIdentifierStart('\u200b')); 1143 assertTrue("semi returned true", !Character.isJavaIdentifierStart(';')); 1144 } 1145 1146 /** 1147 * @tests java.lang.Character#isJavaIdentifierStart(int) 1148 */ 1149 public void test_isJavaIdentifierStart_I() { 1150 assertTrue(Character.isJavaIdentifierStart((int)'l')); 1151 assertTrue(Character.isJavaIdentifierStart((int)'$')); 1152 assertTrue(Character.isJavaIdentifierStart((int)'_')); 1153 assertFalse(Character.isJavaIdentifierStart((int)'9')); 1154 assertFalse(Character.isJavaIdentifierStart((int)'\u200b')); 1155 assertFalse(Character.isJavaIdentifierStart((int)';')); 1156 1157 assertTrue(Character.isJavaIdentifierStart(0x0041)); 1158 assertTrue(Character.isJavaIdentifierStart(0x10400)); 1159 assertTrue(Character.isJavaIdentifierStart(0x0061)); 1160 assertTrue(Character.isJavaIdentifierStart(0x10428)); 1161 assertTrue(Character.isJavaIdentifierStart(0x01C5)); 1162 assertTrue(Character.isJavaIdentifierStart(0x1FFC)); 1163 assertTrue(Character.isJavaIdentifierStart(0x02B0)); 1164 assertTrue(Character.isJavaIdentifierStart(0xFF9F)); 1165 assertTrue(Character.isJavaIdentifierStart(0x01BB)); 1166 assertTrue(Character.isJavaIdentifierStart(0x2F888)); 1167 1168 assertTrue(Character.isJavaIdentifierPart(0x0024)); 1169 assertTrue(Character.isJavaIdentifierPart(0xFFE6)); 1170 1171 assertTrue(Character.isJavaIdentifierPart(0x005F)); 1172 assertTrue(Character.isJavaIdentifierPart(0xFF3F)); 1173 1174 assertTrue(Character.isJavaIdentifierPart(0x2160)); 1175 assertTrue(Character.isJavaIdentifierPart(0x1034A)); 1176 1177 assertFalse(Character.isJavaIdentifierPart(0x110000)); 1178 } 1179 1180 /** 1181 * @tests java.lang.Character#isJavaLetter(char) 1182 */ 1183 @SuppressWarnings("deprecation") 1184 public void test_isJavaLetterC() { 1185 assertTrue("letter returned false", Character.isJavaLetter('l')); 1186 assertTrue("currency returned false", Character.isJavaLetter('$')); 1187 assertTrue("connecting char returned false", Character 1188 .isJavaLetter('_')); 1189 1190 assertTrue("digit returned true", !Character.isJavaLetter('9')); 1191 assertTrue("ignored control returned true", !Character 1192 .isJavaLetter('\u200b')); 1193 assertTrue("semi returned true", !Character.isJavaLetter(';')); 1194 } 1195 1196 /** 1197 * @tests java.lang.Character#isJavaLetterOrDigit(char) 1198 */ 1199 @SuppressWarnings("deprecation") 1200 public void test_isJavaLetterOrDigitC() { 1201 assertTrue("letter returned false", Character.isJavaLetterOrDigit('l')); 1202 assertTrue("currency returned false", Character 1203 .isJavaLetterOrDigit('$')); 1204 assertTrue("digit returned false", Character.isJavaLetterOrDigit('9')); 1205 assertTrue("connecting char returned false", Character 1206 .isJavaLetterOrDigit('_')); 1207 assertTrue("semi returned true", !Character.isJavaLetterOrDigit(';')); 1208 } 1209 1210 /** 1211 * @tests java.lang.Character#isLetter(char) 1212 */ 1213 public void test_isLetterC() { 1214 assertTrue("Letter returned false", Character.isLetter('L')); 1215 assertTrue("Non-Letter returned true", !Character.isLetter('9')); 1216 } 1217 1218 /** 1219 * @tests java.lang.Character#isLetter(int) 1220 */ 1221 public void test_isLetter_I() { 1222 assertTrue(Character.isLetter((int)'L')); 1223 assertFalse(Character.isLetter((int)'9')); 1224 1225 assertTrue(Character.isLetter(0x1FA9)); 1226 assertTrue(Character.isLetter(0x1D400)); 1227 assertTrue(Character.isLetter(0x1D622)); 1228 assertTrue(Character.isLetter(0x10000)); 1229 1230 assertFalse(Character.isLetter(0x1012C)); 1231 assertFalse(Character.isLetter(0x110000)); 1232 } 1233 1234 /** 1235 * @tests java.lang.Character#isLetterOrDigit(char) 1236 */ 1237 public void test_isLetterOrDigitC() { 1238 assertTrue("Digit returned false", Character.isLetterOrDigit('9')); 1239 assertTrue("Letter returned false", Character.isLetterOrDigit('K')); 1240 assertTrue("Control returned true", !Character.isLetterOrDigit('\n')); 1241 assertTrue("Punctuation returned true", !Character.isLetterOrDigit('?')); 1242 } 1243 1244 /** 1245 * @tests java.lang.Character#isLetterOrDigit(int) 1246 */ 1247 public void test_isLetterOrDigit_I() { 1248 assertTrue(Character.isLetterOrDigit((int)'9')); 1249 assertTrue(Character.isLetterOrDigit((int)'K')); 1250 assertFalse(Character.isLetterOrDigit((int)'\n')); 1251 assertFalse(Character.isLetterOrDigit((int)'?')); 1252 1253 assertTrue(Character.isLetterOrDigit(0x1FA9)); 1254 assertTrue(Character.isLetterOrDigit(0x1D400)); 1255 assertTrue(Character.isLetterOrDigit(0x1D622)); 1256 assertTrue(Character.isLetterOrDigit(0x10000)); 1257 1258 assertTrue(Character.isLetterOrDigit(0x1D7CE)); 1259 assertTrue(Character.isLetterOrDigit(0x1D7D8)); 1260 1261 assertFalse(Character.isLetterOrDigit(0x10FFFD)); 1262 assertFalse(Character.isLetterOrDigit(0x1012C)); 1263 assertFalse(Character.isLetterOrDigit(0x110000)); 1264 } 1265 1266 /** 1267 * @tests java.lang.Character#isLowerCase(char) 1268 */ 1269 public void test_isLowerCaseC() { 1270 assertTrue("lower returned false", Character.isLowerCase('a')); 1271 assertTrue("upper returned true", !Character.isLowerCase('T')); 1272 } 1273 1274 /** 1275 * @tests java.lang.Character#isLowerCase(int) 1276 */ 1277 public void test_isLowerCase_I() { 1278 assertTrue(Character.isLowerCase((int)'a')); 1279 assertFalse(Character.isLowerCase((int)'T')); 1280 1281 assertTrue(Character.isLowerCase(0x10428)); 1282 assertTrue(Character.isLowerCase(0x1D4EA)); 1283 1284 assertFalse(Character.isLowerCase(0x1D504)); 1285 assertFalse(Character.isLowerCase(0x30000)); 1286 assertFalse(Character.isLowerCase(0x110000)); 1287 } 1288 1289 /** 1290 * @tests java.lang.Character#isSpace(char) 1291 */ 1292 @SuppressWarnings("deprecation") 1293 public void test_isSpaceC() { 1294 // Test for method boolean java.lang.Character.isSpace(char) 1295 assertTrue("space returned false", Character.isSpace('\n')); 1296 assertTrue("non-space returned true", !Character.isSpace('T')); 1297 } 1298 1299 /** 1300 * @tests java.lang.Character#isSpaceChar(char) 1301 */ 1302 public void test_isSpaceCharC() { 1303 assertTrue("space returned false", Character.isSpaceChar('\u0020')); 1304 assertTrue("non-space returned true", !Character.isSpaceChar('\n')); 1305 } 1306 1307 /** 1308 * @tests java.lang.Character#isSpaceChar(int) 1309 */ 1310 public void test_isSpaceChar_I() { 1311 assertTrue(Character.isSpaceChar((int)'\u0020')); 1312 assertFalse(Character.isSpaceChar((int)'\n')); 1313 1314 assertTrue(Character.isSpaceChar(0x2000)); 1315 assertTrue(Character.isSpaceChar(0x200A)); 1316 1317 assertTrue(Character.isSpaceChar(0x2028)); 1318 assertTrue(Character.isSpaceChar(0x2029)); 1319 1320 assertFalse(Character.isSpaceChar(0x110000)); 1321 } 1322 1323 /** 1324 * @tests java.lang.Character#isTitleCase(char) 1325 */ 1326 public void test_isTitleCaseC() { 1327 char[] tChars = { (char) 0x01c5, (char) 0x01c8, (char) 0x01cb, 1328 (char) 0x01f2, (char) 0x1f88, (char) 0x1f89, (char) 0x1f8a, 1329 (char) 0x1f8b, (char) 0x1f8c, (char) 0x1f8d, (char) 0x1f8e, 1330 (char) 0x1f8f, (char) 0x1f98, (char) 0x1f99, (char) 0x1f9a, 1331 (char) 0x1f9b, (char) 0x1f9c, (char) 0x1f9d, (char) 0x1f9e, 1332 (char) 0x1f9f, (char) 0x1fa8, (char) 0x1fa9, (char) 0x1faa, 1333 (char) 0x1fab, (char) 0x1fac, (char) 0x1fad, (char) 0x1fae, 1334 (char) 0x1faf, (char) 0x1fbc, (char) 0x1fcc, (char) 0x1ffc }; 1335 byte tnum = 0; 1336 for (char c = 0; c < 65535; c++) { 1337 if (Character.isTitleCase(c)) { 1338 tnum++; 1339 int i; 1340 for (i = 0; i < tChars.length; i++) 1341 if (tChars[i] == c) 1342 i = tChars.length + 1; 1343 if (i < tChars.length) { 1344 fail("Non Title Case char returned true"); 1345 } 1346 } 1347 } 1348 assertTrue("Failed to find all Title Case chars", tnum == tChars.length); 1349 } 1350 1351 /** 1352 * @tests java.lang.Character#isTitleCase(int) 1353 */ 1354 public void test_isTitleCase_I() { 1355 //all the titlecase characters 1356 int[] titleCaseCharacters = { 0x01c5, 0x01c8, 0x01cb, 0x01f2, 0x1f88, 1357 0x1f89, 0x1f8a, 0x1f8b, 0x1f8c, 0x1f8d, 0x1f8e, 0x1f8f, 0x1f98, 1358 0x1f99, 0x1f9a, 0x1f9b, 0x1f9c, 0x1f9d, 0x1f9e, 0x1f9f, 0x1fa8, 1359 0x1fa9, 0x1faa, 0x1fab, 0x1fac, 0x1fad, 0x1fae, 0x1faf, 0x1fbc, 1360 0x1fcc, 0x1ffc }; 1361 1362 for (int i = 0; i < titleCaseCharacters.length; i++) { 1363 assertTrue(Character.isTitleCase(titleCaseCharacters[i])); 1364 } 1365 1366 assertFalse(Character.isTitleCase(0x110000)); 1367 } 1368 1369 /** 1370 * @tests java.lang.Character#isUnicodeIdentifierPart(char) 1371 */ 1372 public void test_isUnicodeIdentifierPartC() { 1373 assertTrue("'a' returned false", Character.isUnicodeIdentifierPart('a')); 1374 assertTrue("'2' returned false", Character.isUnicodeIdentifierPart('2')); 1375 assertTrue("'+' returned true", !Character.isUnicodeIdentifierPart('+')); 1376 } 1377 1378 /** 1379 * @tests java.lang.Character#isUnicodeIdentifierPart(int) 1380 */ 1381 public void test_isUnicodeIdentifierPart_I() { 1382 assertTrue(Character.isUnicodeIdentifierPart((int)'a')); 1383 assertTrue(Character.isUnicodeIdentifierPart((int)'2')); 1384 assertFalse(Character.isUnicodeIdentifierPart((int)'+')); 1385 1386 assertTrue(Character.isUnicodeIdentifierPart(0x1FA9)); 1387 assertTrue(Character.isUnicodeIdentifierPart(0x1D400)); 1388 assertTrue(Character.isUnicodeIdentifierPart(0x1D622)); 1389 assertTrue(Character.isUnicodeIdentifierPart(0x10000)); 1390 1391 assertTrue(Character.isUnicodeIdentifierPart(0x0030)); 1392 assertTrue(Character.isUnicodeIdentifierPart(0x0035)); 1393 assertTrue(Character.isUnicodeIdentifierPart(0x0039)); 1394 1395 assertTrue(Character.isUnicodeIdentifierPart(0x0660)); 1396 assertTrue(Character.isUnicodeIdentifierPart(0x0665)); 1397 assertTrue(Character.isUnicodeIdentifierPart(0x0669)); 1398 1399 assertTrue(Character.isUnicodeIdentifierPart(0x06F0)); 1400 assertTrue(Character.isUnicodeIdentifierPart(0x06F5)); 1401 assertTrue(Character.isUnicodeIdentifierPart(0x06F9)); 1402 1403 assertTrue(Character.isUnicodeIdentifierPart(0x0966)); 1404 assertTrue(Character.isUnicodeIdentifierPart(0x096A)); 1405 assertTrue(Character.isUnicodeIdentifierPart(0x096F)); 1406 1407 assertTrue(Character.isUnicodeIdentifierPart(0xFF10)); 1408 assertTrue(Character.isUnicodeIdentifierPart(0xFF15)); 1409 assertTrue(Character.isUnicodeIdentifierPart(0xFF19)); 1410 1411 assertTrue(Character.isUnicodeIdentifierPart(0x1D7CE)); 1412 assertTrue(Character.isUnicodeIdentifierPart(0x1D7D8)); 1413 1414 assertTrue(Character.isUnicodeIdentifierPart(0x16EE)); 1415 assertTrue(Character.isUnicodeIdentifierPart(0xFE33)); 1416 assertTrue(Character.isUnicodeIdentifierPart(0xFF10)); 1417 assertTrue(Character.isUnicodeIdentifierPart(0x1D165)); 1418 assertTrue(Character.isUnicodeIdentifierPart(0x1D167)); 1419 assertTrue(Character.isUnicodeIdentifierPart(0x1D173)); 1420 1421 assertFalse(Character.isUnicodeIdentifierPart(0x10FFFF)); 1422 assertFalse(Character.isUnicodeIdentifierPart(0x110000)); 1423 } 1424 1425 /** 1426 * @tests java.lang.Character#isUnicodeIdentifierStart(char) 1427 */ 1428 public void test_isUnicodeIdentifierStartC() { 1429 assertTrue("'a' returned false", Character 1430 .isUnicodeIdentifierStart('a')); 1431 assertTrue("'2' returned true", !Character 1432 .isUnicodeIdentifierStart('2')); 1433 assertTrue("'+' returned true", !Character 1434 .isUnicodeIdentifierStart('+')); 1435 } 1436 1437 /** 1438 * @tests java.lang.Character#isUnicodeIdentifierStart(int) 1439 */ 1440 public void test_isUnicodeIdentifierStart_I() { 1441 1442 assertTrue(Character.isUnicodeIdentifierStart((int) 'a')); 1443 assertFalse(Character.isUnicodeIdentifierStart((int) '2')); 1444 assertFalse(Character.isUnicodeIdentifierStart((int) '+')); 1445 1446 assertTrue(Character.isUnicodeIdentifierStart(0x1FA9)); 1447 assertTrue(Character.isUnicodeIdentifierStart(0x1D400)); 1448 assertTrue(Character.isUnicodeIdentifierStart(0x1D622)); 1449 assertTrue(Character.isUnicodeIdentifierStart(0x10000)); 1450 1451 assertTrue(Character.isUnicodeIdentifierStart(0x16EE)); 1452 1453 // number is not a valid start of a Unicode identifier 1454 assertFalse(Character.isUnicodeIdentifierStart(0x0030)); 1455 assertFalse(Character.isUnicodeIdentifierStart(0x0039)); 1456 assertFalse(Character.isUnicodeIdentifierStart(0x0660)); 1457 assertFalse(Character.isUnicodeIdentifierStart(0x0669)); 1458 assertFalse(Character.isUnicodeIdentifierStart(0x06F0)); 1459 assertFalse(Character.isUnicodeIdentifierStart(0x06F9)); 1460 1461 assertFalse(Character.isUnicodeIdentifierPart(0x10FFFF)); 1462 assertFalse(Character.isUnicodeIdentifierPart(0x110000)); 1463 } 1464 1465 /** 1466 * @tests java.lang.Character#isUpperCase(char) 1467 */ 1468 public void test_isUpperCaseC() { 1469 assertTrue("Incorrect case value", !Character.isUpperCase('t')); 1470 assertTrue("Incorrect case value", Character.isUpperCase('T')); 1471 } 1472 1473 /** 1474 * @tests java.lang.Character#isUpperCase(int) 1475 */ 1476 public void test_isUpperCase_I() { 1477 assertFalse(Character.isUpperCase((int)'t')); 1478 assertTrue(Character.isUpperCase((int)'T')); 1479 1480 assertTrue(Character.isUpperCase(0x1D504)); 1481 assertTrue(Character.isUpperCase(0x1D608)); 1482 1483 assertFalse(Character.isUpperCase(0x1D656)); 1484 assertFalse(Character.isUpperCase(0x10FFFD)); 1485 assertFalse(Character.isUpperCase(0x110000)); 1486 } 1487 1488 /** 1489 * @tests java.lang.Character#isWhitespace(char) 1490 */ 1491 public void test_isWhitespaceC() { 1492 assertTrue("space returned false", Character.isWhitespace('\n')); 1493 assertTrue("non-space returned true", !Character.isWhitespace('T')); 1494 } 1495 1496 /** 1497 * @tests java.lang.Character#isWhitespace(int) 1498 */ 1499 public void test_isWhitespace_I() { 1500 assertTrue(Character.isWhitespace((int)'\n')); 1501 assertFalse(Character.isWhitespace((int)'T')); 1502 1503 assertTrue(Character.isWhitespace(0x0009)); 1504 assertTrue(Character.isWhitespace(0x000A)); 1505 assertTrue(Character.isWhitespace(0x000B)); 1506 assertTrue(Character.isWhitespace(0x000C)); 1507 assertTrue(Character.isWhitespace(0x000D)); 1508 assertTrue(Character.isWhitespace(0x001C)); 1509 assertTrue(Character.isWhitespace(0x001D)); 1510 assertTrue(Character.isWhitespace(0x001F)); 1511 assertTrue(Character.isWhitespace(0x001E)); 1512 1513 assertTrue(Character.isWhitespace(0x2000)); 1514 assertTrue(Character.isWhitespace(0x200A)); 1515 1516 assertTrue(Character.isWhitespace(0x2028)); 1517 assertTrue(Character.isWhitespace(0x2029)); 1518 1519 assertFalse(Character.isWhitespace(0x00A0)); 1520 assertFalse(Character.isWhitespace(0x202F)); 1521 assertFalse(Character.isWhitespace(0x110000)); 1522 1523 assertFalse(Character.isWhitespace(0xFEFF)); 1524 1525 //FIXME depend on ICU4J 1526 //assertFalse(Character.isWhitespace(0x2007)); 1527 1528 } 1529 1530 /** 1531 * @tests java.lang.Character#reverseBytes(char) 1532 */ 1533 public void test_reverseBytesC() { 1534 char original[] = new char[]{0x0000, 0x0010, 0x00AA, 0xB000, 0xCC00, 0xABCD, 0xFFAA}; 1535 char reversed[] = new char[]{0x0000, 0x1000, 0xAA00, 0x00B0, 0x00CC, 0xCDAB, 0xAAFF}; 1536 assertTrue("Test self check", original.length==reversed.length); 1537 1538 for (int i=0; i<original.length; i++) { 1539 char origChar = original[i]; 1540 char reversedChar = reversed[i]; 1541 char origReversed= Character.reverseBytes(origChar); 1542 1543 assertTrue("java.lang.Character.reverseBytes failed: orig char=" 1544 +Integer.toHexString(origChar)+", reversed char=" 1545 +Integer.toHexString(origReversed), reversedChar==origReversed); 1546 } 1547 } 1548 1549 /** 1550 * @tests java.lang.Character#toLowerCase(char) 1551 */ 1552 public void test_toLowerCaseC() { 1553 assertEquals("Failed to change case", 't', Character.toLowerCase('T')); 1554 } 1555 1556 /** 1557 * @tests java.lang.Character#toLowerCase(int) 1558 */ 1559 public void test_toLowerCase_I() { 1560 assertEquals('t', Character.toLowerCase((int)'T')); 1561 1562 assertEquals(0x10428, Character.toLowerCase(0x10400)); 1563 assertEquals(0x10428, Character.toLowerCase(0x10428)); 1564 1565 assertEquals(0x1D504, Character.toLowerCase(0x1D504)); 1566 assertEquals(0x10FFFD, Character.toLowerCase(0x10FFFD)); 1567 assertEquals(0x110000, Character.toLowerCase(0x110000)); 1568 } 1569 1570 /** 1571 * @tests java.lang.Character#toString() 1572 */ 1573 public void test_toString() { 1574 assertEquals("Incorrect String returned", "T", new Character('T').toString()); 1575 } 1576 1577 /** 1578 * @tests java.lang.Character#toTitleCase(char) 1579 */ 1580 public void test_toTitleCaseC() { 1581 assertEquals("Incorrect title case for a", 1582 'A', Character.toTitleCase('a')); 1583 assertEquals("Incorrect title case for A", 1584 'A', Character.toTitleCase('A')); 1585 assertEquals("Incorrect title case for 1", 1586 '1', Character.toTitleCase('1')); 1587 } 1588 1589 /** 1590 * @tests java.lang.Character#toTitleCase(int) 1591 */ 1592 public void test_toTitleCase_I() { 1593 assertEquals('A', Character.toTitleCase((int)'a')); 1594 assertEquals('A', Character.toTitleCase((int)'A')); 1595 assertEquals('1', Character.toTitleCase((int)'1')); 1596 1597 assertEquals(0x10400, Character.toTitleCase(0x10428)); 1598 assertEquals(0x10400, Character.toTitleCase(0x10400)); 1599 1600 assertEquals(0x10FFFF, Character.toTitleCase(0x10FFFF)); 1601 assertEquals(0x110000, Character.toTitleCase(0x110000)); 1602 } 1603 1604 /** 1605 * @tests java.lang.Character#toUpperCase(char) 1606 */ 1607 public void test_toUpperCaseC() { 1608 // Test for method char java.lang.Character.toUpperCase(char) 1609 assertEquals("Incorrect upper case for a", 1610 'A', Character.toUpperCase('a')); 1611 assertEquals("Incorrect upper case for A", 1612 'A', Character.toUpperCase('A')); 1613 assertEquals("Incorrect upper case for 1", 1614 '1', Character.toUpperCase('1')); 1615 } 1616 1617 /** 1618 * @tests java.lang.Character#toUpperCase(int) 1619 */ 1620 public void test_toUpperCase_I() { 1621 assertEquals('A', Character.toUpperCase((int)'a')); 1622 assertEquals('A', Character.toUpperCase((int)'A')); 1623 assertEquals('1', Character.toUpperCase((int)'1')); 1624 1625 assertEquals(0x10400, Character.toUpperCase(0x10428)); 1626 assertEquals(0x10400, Character.toUpperCase(0x10400)); 1627 1628 assertEquals(0x10FFFF, Character.toUpperCase(0x10FFFF)); 1629 assertEquals(0x110000, Character.toUpperCase(0x110000)); 1630 } 1631 1632 /** 1633 * @tests java.lang.Character#getDirectionality(int) 1634 */ 1635 public void test_isDirectionaliy_I(){ 1636 assertEquals(Character.DIRECTIONALITY_UNDEFINED, Character 1637 .getDirectionality(0xFFFE)); 1638 assertEquals(Character.DIRECTIONALITY_UNDEFINED, Character 1639 .getDirectionality(0x30000)); 1640 assertEquals(Character.DIRECTIONALITY_UNDEFINED, Character 1641 .getDirectionality(0x110000)); 1642 assertEquals(Character.DIRECTIONALITY_UNDEFINED, Character 1643 .getDirectionality(-1)); 1644 1645 assertEquals(Character.DIRECTIONALITY_LEFT_TO_RIGHT, Character 1646 .getDirectionality(0x0041)); 1647 assertEquals(Character.DIRECTIONALITY_LEFT_TO_RIGHT, Character 1648 .getDirectionality(0x10000)); 1649 assertEquals(Character.DIRECTIONALITY_LEFT_TO_RIGHT, Character 1650 .getDirectionality(0x104A9)); 1651 1652 assertEquals(Character.DIRECTIONALITY_RIGHT_TO_LEFT, Character 1653 .getDirectionality(0xFB4F)); 1654 assertEquals(Character.DIRECTIONALITY_RIGHT_TO_LEFT, Character 1655 .getDirectionality(0x10838)); 1656 // Unicode standard 5.1 changed category of unicode point 0x0600 from AL to AN 1657 assertEquals(Character.DIRECTIONALITY_ARABIC_NUMBER, Character 1658 .getDirectionality(0x0600)); 1659 assertEquals(Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC, Character 1660 .getDirectionality(0xFEFC)); 1661 1662 assertEquals(Character.DIRECTIONALITY_EUROPEAN_NUMBER, Character 1663 .getDirectionality(0x2070)); 1664 assertEquals(Character.DIRECTIONALITY_EUROPEAN_NUMBER, Character 1665 .getDirectionality(0x1D7FF)); 1666 1667 //RI fails ,this is non-bug difference between Unicode 4.0 and 4.1 1668 assertEquals(Character.DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR, Character 1669 .getDirectionality(0x002B)); 1670 assertEquals(Character.DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR, Character 1671 .getDirectionality(0xFF0B)); 1672 1673 assertEquals(Character.DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR, Character 1674 .getDirectionality(0x0023)); 1675 assertEquals(Character.DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR, Character 1676 .getDirectionality(0x17DB)); 1677 1678 assertEquals(Character.DIRECTIONALITY_ARABIC_NUMBER, Character 1679 .getDirectionality(0x0660)); 1680 assertEquals(Character.DIRECTIONALITY_ARABIC_NUMBER, Character 1681 .getDirectionality(0x066C)); 1682 1683 assertEquals(Character.DIRECTIONALITY_COMMON_NUMBER_SEPARATOR, Character 1684 .getDirectionality(0x002C)); 1685 assertEquals(Character.DIRECTIONALITY_COMMON_NUMBER_SEPARATOR, Character 1686 .getDirectionality(0xFF1A)); 1687 1688 assertEquals(Character.DIRECTIONALITY_NONSPACING_MARK, Character 1689 .getDirectionality(0x17CE)); 1690 assertEquals(Character.DIRECTIONALITY_NONSPACING_MARK, Character 1691 .getDirectionality(0xE01DB)); 1692 1693 assertEquals(Character.DIRECTIONALITY_BOUNDARY_NEUTRAL, Character 1694 .getDirectionality(0x0000)); 1695 assertEquals(Character.DIRECTIONALITY_BOUNDARY_NEUTRAL, Character 1696 .getDirectionality(0xE007F)); 1697 1698 assertEquals(Character.DIRECTIONALITY_PARAGRAPH_SEPARATOR, Character 1699 .getDirectionality(0x000A)); 1700 assertEquals(Character.DIRECTIONALITY_PARAGRAPH_SEPARATOR, Character 1701 .getDirectionality(0x2029)); 1702 1703 assertEquals(Character.DIRECTIONALITY_SEGMENT_SEPARATOR, Character 1704 .getDirectionality(0x0009)); 1705 assertEquals(Character.DIRECTIONALITY_SEGMENT_SEPARATOR, Character 1706 .getDirectionality(0x001F)); 1707 1708 assertEquals(Character.DIRECTIONALITY_WHITESPACE, Character 1709 .getDirectionality(0x0020)); 1710 assertEquals(Character.DIRECTIONALITY_WHITESPACE, Character 1711 .getDirectionality(0x3000)); 1712 1713 assertEquals(Character.DIRECTIONALITY_OTHER_NEUTRALS, Character 1714 .getDirectionality(0x2FF0)); 1715 assertEquals(Character.DIRECTIONALITY_OTHER_NEUTRALS, Character 1716 .getDirectionality(0x1D356)); 1717 1718 assertEquals(Character.DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING, Character 1719 .getDirectionality(0x202A)); 1720 1721 assertEquals(Character.DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE, Character 1722 .getDirectionality(0x202D)); 1723 1724 assertEquals(Character.DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING, Character 1725 .getDirectionality(0x202B)); 1726 1727 assertEquals(Character.DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE, Character 1728 .getDirectionality(0x202E)); 1729 1730 assertEquals(Character.DIRECTIONALITY_POP_DIRECTIONAL_FORMAT, Character 1731 .getDirectionality(0x202C)); 1732 } 1733} 1734