Home | History | Annotate | Download | only in lang 
      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 
     17 package org.apache.harmony.luni.tests.java.lang;
     18 
     19 import java.util.Arrays;
     20 
     21 import junit.framework.TestCase;
     22 
     23 public 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