CharacterTest.java revision cc05ad238516f1303687aba4a978e24e57c0c07a 
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 dalvik.annotation.TestTargets;
20import dalvik.annotation.TestLevel;
21import dalvik.annotation.TestTargetNew;
22import dalvik.annotation.TestTargetClass;
23
24import junit.framework.TestCase;
25
26import java.io.FileOutputStream;
27import java.io.PrintWriter;
28import java.util.Arrays;
29
30@TestTargetClass(Character.class)
31public class CharacterTest extends TestCase {
32
33    @TestTargetNew(
34        level = TestLevel.COMPLETE,
35        notes = "",
36        method = "valueOf",
37        args = {char.class}
38    )
39    public void test_valueOfC() {
40        // test the cache range
41        for (char c = '\u0000'; c < 512; c++) {
42            Character e = new Character(c);
43            Character a = Character.valueOf(c);
44            assertEquals(e, a);
45        }
46        // test the rest of the chars
47        for (int c = 512; c <= Character.MAX_VALUE; c++) {
48            assertEquals(new Character((char) c), Character.valueOf((char) c));
49        }
50    }
51    @TestTargetNew(
52        level = TestLevel.COMPLETE,
53        notes = "",
54        method = "isValidCodePoint",
55        args = {int.class}
56    )
57    public void test_isValidCodePointI() {
58        assertFalse(Character.isValidCodePoint(-1));
59        assertTrue(Character.isValidCodePoint(0));
60        assertTrue(Character.isValidCodePoint(1));
61        assertFalse(Character.isValidCodePoint(Integer.MAX_VALUE));
62
63        for (int c = '\u0000'; c <= 0x10FFFF; c++) {
64            assertTrue(Character.isValidCodePoint(c));
65        }
66
67        assertFalse(Character.isValidCodePoint(0x10FFFF + 1));
68    }
69    @TestTargetNew(
70        level = TestLevel.COMPLETE,
71        notes = "",
72        method = "isSupplementaryCodePoint",
73        args = {int.class}
74    )
75    public void test_isSupplementaryCodePointI() {
76        assertFalse(Character.isSupplementaryCodePoint(-1));
77
78        for (int c = '\u0000'; c <= '\uFFFF'; c++) {
79            assertFalse(Character.isSupplementaryCodePoint(c));
80        }
81
82        for (int c = 0xFFFF + 1; c <= 0x10FFFF; c++) {
83            assertTrue(Character.isSupplementaryCodePoint(c));
84        }
85
86        assertFalse(Character.isSupplementaryCodePoint(0x10FFFF + 1));
87    }
88    @TestTargetNew(
89        level = TestLevel.COMPLETE,
90        notes = "",
91        method = "isHighSurrogate",
92        args = {char.class}
93    )
94    public void test_isHighSurrogateC() {
95        // (\uD800-\uDBFF)
96        assertFalse(Character.isHighSurrogate((char) ('\uD800' - 1)));
97        for (int c = '\uD800'; c <= '\uDBFF'; c++) {
98            assertTrue(Character.isHighSurrogate((char) c));
99        }
100        assertFalse(Character.isHighSurrogate((char) ('\uDBFF' + 1)));
101        assertFalse(Character.isHighSurrogate('\uFFFF'));
102    }
103    @TestTargetNew(
104        level = TestLevel.COMPLETE,
105        notes = "",
106        method = "isLowSurrogate",
107        args = {char.class}
108    )
109    public void test_isLowSurrogateC() {
110        // (\uDC00-\uDFFF)
111        assertFalse(Character.isLowSurrogate((char) ('\uDC00' - 1)));
112        for (int c = '\uDC00'; c <= '\uDFFF'; c++) {
113            assertTrue(Character.isLowSurrogate((char) c));
114        }
115        assertFalse(Character.isLowSurrogate((char) ('\uDFFF' + 1)));
116    }
117    @TestTargetNew(
118        level = TestLevel.COMPLETE,
119        notes = "",
120        method = "isSurrogatePair",
121        args = {char.class, char.class}
122    )
123    public void test_isSurrogatePairCC() {
124        assertFalse(Character.isSurrogatePair('\u0000', '\u0000'));
125        assertFalse(Character.isSurrogatePair('\u0000', '\uDC00'));
126
127        assertTrue(Character.isSurrogatePair('\uD800', '\uDC00'));
128        assertTrue(Character.isSurrogatePair('\uD800', '\uDFFF'));
129        assertTrue(Character.isSurrogatePair('\uDBFF', '\uDFFF'));
130
131        assertFalse(Character.isSurrogatePair('\uDBFF', '\uF000'));
132    }
133    @TestTargetNew(
134        level = TestLevel.COMPLETE,
135        notes = "",
136        method = "charCount",
137        args = {int.class}
138    )
139    public void test_charCountI() {
140
141        for (int c = '\u0000'; c <= '\uFFFF'; c++) {
142            assertEquals(1, Character.charCount(c));
143        }
144
145        for (int c = 0xFFFF + 1; c <= 0x10FFFF; c++) {
146            assertEquals(2, Character.charCount(c));
147        }
148
149        // invalid code points work in this method
150        assertEquals(2, Character.charCount(Integer.MAX_VALUE));
151    }
152    @TestTargetNew(
153        level = TestLevel.COMPLETE,
154        notes = "",
155        method = "toCodePoint",
156        args = {char.class, char.class}
157    )
158    public void test_toCodePointCC() {
159        int result = Character.toCodePoint('\uD800', '\uDC00');
160        assertEquals(0x00010000, result);
161
162        result = Character.toCodePoint('\uD800', '\uDC01');
163        assertEquals(0x00010001, result);
164
165        result = Character.toCodePoint('\uD801', '\uDC01');
166        assertEquals(0x00010401, result);
167
168        result = Character.toCodePoint('\uDBFF', '\uDFFF');
169        assertEquals(0x00010FFFF, result);
170    }
171
172    @SuppressWarnings("cast")
173    @TestTargetNew(
174        level = TestLevel.COMPLETE,
175        notes = "",
176        method = "codePointAt",
177        args = {java.lang.CharSequence.class, int.class}
178    )
179    public void test_codePointAtLjava_lang_CharSequenceI() {
180
181        assertEquals('a', Character.codePointAt((CharSequence) "abc", 0));
182        assertEquals('b', Character.codePointAt((CharSequence) "abc", 1));
183        assertEquals('c', Character.codePointAt((CharSequence) "abc", 2));
184        assertEquals(0x10000, Character.codePointAt(
185                (CharSequence) "\uD800\uDC00", 0));
186        assertEquals('\uDC00', Character.codePointAt(
187                (CharSequence) "\uD800\uDC00", 1));
188
189        try {
190            Character.codePointAt((CharSequence) null, 0);
191            fail("No NPE.");
192        } catch (NullPointerException e) {
193        }
194
195        try {
196            Character.codePointAt((CharSequence) "abc", -1);
197            fail("No IOOBE, negative index.");
198        } catch (IndexOutOfBoundsException e) {
199        }
200
201        try {
202            Character.codePointAt((CharSequence) "abc", 4);
203            fail("No IOOBE, index too large.");
204        } catch (IndexOutOfBoundsException e) {
205        }
206    }
207    @TestTargetNew(
208        level = TestLevel.COMPLETE,
209        notes = "",
210        method = "codePointAt",
211        args = {char[].class, int.class}
212    )
213    public void test_codePointAt$CI() {
214
215        assertEquals('a', Character.codePointAt("abc".toCharArray(), 0));
216        assertEquals('b', Character.codePointAt("abc".toCharArray(), 1));
217        assertEquals('c', Character.codePointAt("abc".toCharArray(), 2));
218        assertEquals(0x10000, Character.codePointAt("\uD800\uDC00"
219                .toCharArray(), 0));
220        assertEquals('\uDC00', Character.codePointAt("\uD800\uDC00"
221                .toCharArray(), 1));
222
223        try {
224            Character.codePointAt((char[]) null, 0);
225            fail("No NPE.");
226        } catch (NullPointerException e) {
227        }
228
229        try {
230            Character.codePointAt("abc".toCharArray(), -1);
231            fail("No IOOBE, negative index.");
232        } catch (IndexOutOfBoundsException e) {
233        }
234
235        try {
236            Character.codePointAt("abc".toCharArray(), 4);
237            fail("No IOOBE, index too large.");
238        } catch (IndexOutOfBoundsException e) {
239        }
240    }
241    @TestTargetNew(
242        level = TestLevel.COMPLETE,
243        notes = "",
244        method = "codePointAt",
245        args = {char[].class, int.class, int.class}
246    )
247    public void test_codePointAt$CII() {
248
249        assertEquals('a', Character.codePointAt("abc".toCharArray(), 0, 3));
250        assertEquals('b', Character.codePointAt("abc".toCharArray(), 1, 3));
251        assertEquals('c', Character.codePointAt("abc".toCharArray(), 2, 3));
252        assertEquals(0x10000, Character.codePointAt("\uD800\uDC00"
253                .toCharArray(), 0, 2));
254        assertEquals('\uDC00', Character.codePointAt("\uD800\uDC00"
255                .toCharArray(), 1, 2));
256        assertEquals('\uD800', Character.codePointAt("\uD800\uDC00"
257                .toCharArray(), 0, 1));
258
259        try {
260            Character.codePointAt((char[]) null, 0, 1);
261            fail("No NPE.");
262        } catch (NullPointerException e) {
263        }
264
265        try {
266            Character.codePointAt("abc".toCharArray(), -1, 3);
267            fail("No IOOBE, negative index.");
268        } catch (IndexOutOfBoundsException e) {
269        }
270
271        try {
272            Character.codePointAt("abc".toCharArray(), 4, 3);
273            fail("No IOOBE, index too large.");
274        } catch (IndexOutOfBoundsException e) {
275        }
276
277        try {
278            Character.codePointAt("abc".toCharArray(), 2, 1);
279            fail("No IOOBE, index larger than limit.");
280        } catch (IndexOutOfBoundsException e) {
281        }
282
283        try {
284            Character.codePointAt("abc".toCharArray(), 2, -1);
285            fail("No IOOBE, limit is negative.");
286        } catch (IndexOutOfBoundsException e) {
287        }
288    }
289    @TestTargetNew(
290        level = TestLevel.COMPLETE,
291        notes = "",
292        method = "codePointBefore",
293        args = {java.lang.CharSequence.class, int.class}
294    )
295    @SuppressWarnings("cast")
296    public void test_codePointBeforeLjava_lang_CharSequenceI() {
297
298        assertEquals('a', Character.codePointBefore((CharSequence) "abc", 1));
299        assertEquals('b', Character.codePointBefore((CharSequence) "abc", 2));
300        assertEquals('c', Character.codePointBefore((CharSequence) "abc", 3));
301        assertEquals(0x10000, Character.codePointBefore(
302                (CharSequence) "\uD800\uDC00", 2));
303        assertEquals('\uD800', Character.codePointBefore(
304                (CharSequence) "\uD800\uDC00", 1));
305
306        try {
307            Character.codePointBefore((CharSequence) null, 0);
308            fail("No NPE.");
309        } catch (NullPointerException e) {
310        }
311
312        try {
313            Character.codePointBefore((CharSequence) "abc", 0);
314            fail("No IOOBE, index below one.");
315        } catch (IndexOutOfBoundsException e) {
316        }
317
318        try {
319            Character.codePointBefore((CharSequence) "abc", 4);
320            fail("No IOOBE, index too large.");
321        } catch (IndexOutOfBoundsException e) {
322        }
323    }
324    @TestTargetNew(
325        level = TestLevel.COMPLETE,
326        notes = "",
327        method = "codePointBefore",
328        args = {char[].class, int.class}
329    )
330    public void test_codePointBefore$CI() {
331
332        assertEquals('a', Character.codePointBefore("abc".toCharArray(), 1));
333        assertEquals('b', Character.codePointBefore("abc".toCharArray(), 2));
334        assertEquals('c', Character.codePointBefore("abc".toCharArray(), 3));
335        assertEquals(0x10000, Character.codePointBefore("\uD800\uDC00"
336                .toCharArray(), 2));
337        assertEquals('\uD800', Character.codePointBefore("\uD800\uDC00"
338                .toCharArray(), 1));
339
340        try {
341            Character.codePointBefore((char[]) null, 0);
342            fail("No NPE.");
343        } catch (NullPointerException e) {
344        }
345
346        try {
347            Character.codePointBefore("abc".toCharArray(), -1);
348            fail("No IOOBE, negative index.");
349        } catch (IndexOutOfBoundsException e) {
350        }
351
352        try {
353            Character.codePointBefore("abc".toCharArray(), 4);
354            fail("No IOOBE, index too large.");
355        } catch (IndexOutOfBoundsException e) {
356        }
357    }
358    @TestTargetNew(
359        level = TestLevel.COMPLETE,
360        notes = "",
361        method = "codePointBefore",
362        args = {char[].class, int.class, int.class}
363    )
364    public void test_codePointBefore$CII() {
365
366        assertEquals('a', Character.codePointBefore("abc".toCharArray(), 1, 0));
367        assertEquals('b', Character.codePointBefore("abc".toCharArray(), 2, 0));
368        assertEquals('c', Character.codePointBefore("abc".toCharArray(), 3, 0));
369        assertEquals(0x10000, Character.codePointBefore("\uD800\uDC00"
370                .toCharArray(), 2, 0));
371        assertEquals('\uDC00', Character.codePointBefore("\uD800\uDC00"
372                .toCharArray(), 2, 1));
373        assertEquals('\uD800', Character.codePointBefore("\uD800\uDC00"
374                .toCharArray(), 1, 0));
375
376        try {
377            Character.codePointBefore((char[]) null, 1, 0);
378            fail("No NPE.");
379        } catch (NullPointerException e) {
380        }
381
382        try {
383            Character.codePointBefore("abc".toCharArray(), 0, 1);
384            fail("No IOOBE, index less than start.");
385        } catch (IndexOutOfBoundsException e) {
386        }
387
388        try {
389            Character.codePointBefore("abc".toCharArray(), 4, 0);
390            fail("No IOOBE, index larger than length.");
391        } catch (IndexOutOfBoundsException e) {
392        }
393
394        try {
395            Character.codePointBefore("abc".toCharArray(), 2, -1);
396            fail("No IOOBE, start is negative.");
397        } catch (IndexOutOfBoundsException e) {
398        }
399
400        try {
401            Character.codePointBefore("abc".toCharArray(), 2, 4);
402            fail("No IOOBE, start larger than length.");
403        } catch (IndexOutOfBoundsException e) {
404        }
405    }
406    @TestTargetNew(
407        level = TestLevel.COMPLETE,
408        notes = "",
409        method = "toChars",
410        args = {int.class, char[].class, int.class}
411    )
412    public void test_toCharsI$CI() {
413        char[] dst = new char[2];
414        int result = Character.toChars(0x10000, dst, 0);
415        assertEquals(2, result);
416        assertTrue(Arrays.equals(new char[] { '\uD800', '\uDC00' }, dst));
417
418        result = Character.toChars(0x10001, dst, 0);
419        assertEquals(2, result);
420        assertTrue(Arrays.equals(new char[] { '\uD800', '\uDC01' }, dst));
421
422        result = Character.toChars(0x10401, dst, 0);
423        assertEquals(2, result);
424        assertTrue(Arrays.equals(new char[] { '\uD801', '\uDC01' }, dst));
425
426        result = Character.toChars(0x10FFFF, dst, 0);
427        assertEquals(2, result);
428        assertTrue(Arrays.equals(new char[] { '\uDBFF', '\uDFFF' }, dst));
429
430        try {
431            Character.toChars(Integer.MAX_VALUE, new char[2], 0);
432            fail("No IAE, invalid code point.");
433        } catch (IllegalArgumentException e) {
434        }
435
436        try {
437            Character.toChars('a', null, 0);
438            fail("No NPE, null char[].");
439        } catch (NullPointerException e) {
440        }
441
442        try {
443            Character.toChars('a', new char[1], -1);
444            fail("No IOOBE, negative index.");
445        } catch (IndexOutOfBoundsException e) {
446        }
447
448        try {
449            Character.toChars('a', new char[1], 1);
450            fail("No IOOBE, index equal to length.");
451        } catch (IndexOutOfBoundsException e) {
452        }
453    }
454    @TestTargetNew(
455        level = TestLevel.COMPLETE,
456        notes = "",
457        method = "toChars",
458        args = {int.class}
459    )
460    public void test_toCharsI() {
461        assertTrue(Arrays.equals(new char[] { '\uD800', '\uDC00' }, Character
462                .toChars(0x10000)));
463        assertTrue(Arrays.equals(new char[] { '\uD800', '\uDC01' }, Character
464                .toChars(0x10001)));
465        assertTrue(Arrays.equals(new char[] { '\uD801', '\uDC01' }, Character
466                .toChars(0x10401)));
467        assertTrue(Arrays.equals(new char[] { '\uDBFF', '\uDFFF' }, Character
468                .toChars(0x10FFFF)));
469
470        try {
471            Character.toChars(Integer.MAX_VALUE);
472            fail("No IAE, invalid code point.");
473        } catch (IllegalArgumentException e) {
474        }
475    }
476    @TestTargetNew(
477        level = TestLevel.COMPLETE,
478        notes = "",
479        method = "codePointCount",
480        args = {java.lang.CharSequence.class, int.class, int.class}
481    )
482    public void test_codePointCountLjava_lang_CharSequenceII() {
483        assertEquals(1, Character.codePointCount("\uD800\uDC00", 0, 2));
484        assertEquals(1, Character.codePointCount("\uD800\uDC01", 0, 2));
485        assertEquals(1, Character.codePointCount("\uD801\uDC01", 0, 2));
486        assertEquals(1, Character.codePointCount("\uDBFF\uDFFF", 0, 2));
487
488        assertEquals(3, Character.codePointCount("a\uD800\uDC00b", 0, 4));
489        assertEquals(4, Character.codePointCount("a\uD800\uDC00b\uD800", 0, 5));
490
491        try {
492            Character.codePointCount((CharSequence) null, 0, 1);
493            fail("No NPE, null char sequence.");
494        } catch (NullPointerException e) {
495        }
496
497        try {
498            Character.codePointCount("abc", -1, 1);
499            fail("No IOOBE, negative start.");
500        } catch (IndexOutOfBoundsException e) {
501        }
502
503        try {
504            Character.codePointCount("abc", 0, 4);
505            fail("No IOOBE, end greater than length.");
506        } catch (IndexOutOfBoundsException e) {
507        }
508
509        try {
510            Character.codePointCount("abc", 2, 1);
511            fail("No IOOBE, end greater than start.");
512        } catch (IndexOutOfBoundsException e) {
513        }
514    }
515
516    @TestTargetNew(
517        level = TestLevel.COMPLETE,
518        notes = "",
519        method = "codePointCount",
520        args = {char[].class, int.class, int.class}
521    )
522    public void test_codePointCountLjava_lang_CharArrayII() {
523
524      assertEquals(1, Character.codePointCount("\uD800\uDC00".toCharArray(),
525                                               0, 2));
526      assertEquals(3, Character.codePointCount("a\uD800\uDC00b".toCharArray(),
527                                               0, 4));
528      assertEquals(4, Character.codePointCount("a\uD800\uDC00b\uD800".toCharArray(),
529                                               0, 5));
530      assertEquals(4, Character.codePointCount("ab\uD800\uDC00b\uD800".toCharArray(),
531                                                1, 5));
532
533      try {
534          Character.codePointCount((char[]) null, 0, 1);
535          fail("No NPE, null char sequence.");
536      } catch (NullPointerException e) {
537      }
538
539      try {
540          Character.codePointCount("abc".toCharArray(), -1, 1);
541          fail("No IOOBE, negative start.");
542      } catch (IndexOutOfBoundsException e) {
543      }
544
545      try {
546          Character.codePointCount("abc".toCharArray(), 0, 4);
547          fail("No IOOBE, end greater than length.");
548      } catch (IndexOutOfBoundsException e) {
549      }
550
551      try {
552          Character.codePointCount("abc".toCharArray(), 1, 3);
553          fail("No IOOBE, end greater than start.");
554      } catch (IndexOutOfBoundsException e) {
555      }
556    }
557
558    @TestTargetNew(
559        level = TestLevel.COMPLETE,
560        notes = "",
561        method = "getDirectionality",
562        args = {char.class}
563    )
564    public void test_getDirectionality() throws Exception {
565
566        byte[] directionalities = {
567                Character.DIRECTIONALITY_UNDEFINED,
568                Character.DIRECTIONALITY_LEFT_TO_RIGHT,
569                Character.DIRECTIONALITY_RIGHT_TO_LEFT,
570                Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC,
571                Character.DIRECTIONALITY_EUROPEAN_NUMBER,
572                // Character.DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR,
573                Character.DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR,
574                Character.DIRECTIONALITY_ARABIC_NUMBER,
575                Character.DIRECTIONALITY_COMMON_NUMBER_SEPARATOR,
576                Character.DIRECTIONALITY_NONSPACING_MARK,
577                Character.DIRECTIONALITY_BOUNDARY_NEUTRAL,
578                Character.DIRECTIONALITY_PARAGRAPH_SEPARATOR,
579                Character.DIRECTIONALITY_SEGMENT_SEPARATOR,
580                Character.DIRECTIONALITY_WHITESPACE,
581                Character.DIRECTIONALITY_OTHER_NEUTRALS,
582                Character.DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING,
583                Character.DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE,
584                Character.DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING,
585                Character.DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE,
586                Character.DIRECTIONALITY_POP_DIRECTIONAL_FORMAT
587                };
588
589        char[] characters = {
590                '\u0370', // -1
591                '\u00B5', // 0
592                '\u05BE', // 1
593                '\u0600', // 2
594                '\u00B2', // 3
595                // '', // No common char in this group on android and java.
596                '\u00B1', // 5
597                '\u0660', // 6
598                '\u00A0', // 7
599                '\u0300', // 8
600                '\u009F', // 9
601                '\u0085', // 10
602                '\u001F', // 11
603                '\u0020', // 12
604                '\u00AB', // 13
605                '\u202A', // 14
606                '\u202D', // 15
607                '\u202B', // 16
608                '\u202E', // 17
609                '\u202C' // 18
610                };
611
612        for(int i = 0; i < directionalities.length; i++) {
613            assertEquals(directionalities[i],
614                    Character.getDirectionality(characters[i]));
615        }
616
617
618    }
619
620    @TestTargetNew(
621        level = TestLevel.COMPLETE,
622        notes = "",
623        method = "offsetByCodePoints",
624        args = {java.lang.CharSequence.class, int.class, int.class}
625    )
626    public void test_offsetByCodePointsLjava_lang_CharSequenceII() {
627        int result = Character.offsetByCodePoints("a\uD800\uDC00b", 0, 2);
628        assertEquals(3, result);
629
630        result = Character.offsetByCodePoints("abcd", 3, -1);
631        assertEquals(2, result);
632
633        result = Character.offsetByCodePoints("a\uD800\uDC00b", 0, 3);
634        assertEquals(4, result);
635
636        result = Character.offsetByCodePoints("a\uD800\uDC00b", 3, -1);
637        assertEquals(1, result);
638
639        result = Character.offsetByCodePoints("a\uD800\uDC00b", 3, 0);
640        assertEquals(3, result);
641
642        result = Character.offsetByCodePoints("\uD800\uDC00bc", 3, 0);
643        assertEquals(3, result);
644
645        result = Character.offsetByCodePoints("a\uDC00bc", 3, -1);
646        assertEquals(2, result);
647
648        result = Character.offsetByCodePoints("a\uD800bc", 3, -1);
649        assertEquals(2, result);
650
651        try {
652            Character.offsetByCodePoints((CharSequence) null, 0, 1);
653            fail();
654        } catch (NullPointerException e) {
655        }
656
657        try {
658            Character.offsetByCodePoints("abc", -1, 1);
659            fail();
660        } catch (IndexOutOfBoundsException e) {
661        }
662
663        try {
664            Character.offsetByCodePoints("abc", 4, 1);
665            fail();
666        } catch (IndexOutOfBoundsException e) {
667        }
668
669        try {
670            Character.offsetByCodePoints("abc", 1, 3);
671            fail();
672        } catch (IndexOutOfBoundsException e) {
673        }
674
675        try {
676            Character.offsetByCodePoints("abc", 1, -2);
677            fail();
678        } catch (IndexOutOfBoundsException e) {
679        }
680    }
681    @TestTargetNew(
682        level = TestLevel.COMPLETE,
683        notes = "",
684        method = "offsetByCodePoints",
685        args = {char[].class, int.class, int.class, int.class, int.class}
686    )
687    public void test_offsetByCodePoints$CIIII() {
688        int result = Character.offsetByCodePoints("a\uD800\uDC00b"
689                .toCharArray(), 0, 4, 0, 2);
690        assertEquals(3, result);
691
692        result = Character.offsetByCodePoints("a\uD800\uDC00b".toCharArray(),
693                0, 4, 0, 3);
694        assertEquals(4, result);
695
696        result = Character.offsetByCodePoints("a\uD800\uDC00b\uD800c"
697                .toCharArray(), 0, 5, 0, 3);
698        assertEquals(4, result);
699
700        result = Character
701                .offsetByCodePoints("abcd".toCharArray(), 0, 4, 3, -1);
702        assertEquals(2, result);
703
704        result = Character
705                .offsetByCodePoints("abcd".toCharArray(), 1, 2, 3, -2);
706        assertEquals(1, result);
707
708        result = Character.offsetByCodePoints("a\uD800\uDC00b".toCharArray(),
709                0, 4, 3, -1);
710        assertEquals(1, result);
711
712        result = Character.offsetByCodePoints("a\uD800\uDC00b".toCharArray(),
713                0, 2, 2, -1);
714        assertEquals(1, result);
715
716        result = Character.offsetByCodePoints("a\uD800\uDC00b".toCharArray(),
717                0, 4, 3, 0);
718        assertEquals(3, result);
719
720        result = Character.offsetByCodePoints("\uD800\uDC00bc".toCharArray(),
721                0, 4, 3, 0);
722        assertEquals(3, result);
723
724        result = Character.offsetByCodePoints("a\uDC00bc".toCharArray(), 0, 4,
725                3, -1);
726        assertEquals(2, result);
727
728        result = Character.offsetByCodePoints("a\uD800bc".toCharArray(), 0, 4,
729                3, -1);
730        assertEquals(2, result);
731
732        try {
733            Character.offsetByCodePoints(null, 0, 4, 1, 1);
734            fail();
735        } catch (NullPointerException e) {
736        }
737
738        try {
739            Character.offsetByCodePoints("abcd".toCharArray(), -1, 4, 1, 1);
740            fail();
741        } catch (IndexOutOfBoundsException e) {
742        }
743
744        try {
745            Character.offsetByCodePoints("abcd".toCharArray(), 0, -1, 1, 1);
746            fail();
747        } catch (IndexOutOfBoundsException e) {
748        }
749
750        try {
751            Character.offsetByCodePoints("abcd".toCharArray(), 2, 4, 1, 1);
752            fail();
753        } catch (IndexOutOfBoundsException e) {
754        }
755
756        try {
757            Character.offsetByCodePoints("abcd".toCharArray(), 1, 3, 0, 1);
758            fail();
759        } catch (IndexOutOfBoundsException e) {
760        }
761
762        try {
763            Character.offsetByCodePoints("abcd".toCharArray(), 1, 1, 3, 1);
764            fail();
765        } catch (IndexOutOfBoundsException e) {
766        }
767
768        try {
769            Character.offsetByCodePoints("abc".toCharArray(), 0, 3, 1, 3);
770            fail();
771        } catch (IndexOutOfBoundsException e) {
772        }
773
774        try {
775            Character.offsetByCodePoints("abc".toCharArray(), 0, 2, 1, 2);
776            fail();
777        } catch (IndexOutOfBoundsException e) {
778        }
779
780        try {
781            Character.offsetByCodePoints("abc".toCharArray(), 1, 3, 1, -2);
782            fail();
783        } catch (IndexOutOfBoundsException e) {
784        }
785    }
786
787    /**
788     * @tests java.lang.Character#compareTo(Character)
789     */
790    @TestTargetNew(
791        level = TestLevel.COMPLETE,
792        notes = "",
793        method = "compareTo",
794        args = {java.lang.Character.class}
795    )
796    public void test_compareToLjava_lang_Byte() {
797        final Character min = new Character(Character.MIN_VALUE);
798        final Character mid = new Character((char)(Character.MAX_VALUE/2));
799        final Character max = new Character(Character.MAX_VALUE);
800
801        assertTrue(max.compareTo(max) == 0);
802        assertTrue(min.compareTo(min) == 0);
803        assertTrue(mid.compareTo(mid) == 0);
804
805        assertTrue(max.compareTo(mid) > 0);
806        assertTrue(max.compareTo(min) > 0);
807
808        assertTrue(mid.compareTo(max) < 0);
809        assertTrue(mid.compareTo(min) > 0);
810
811        assertTrue(min.compareTo(mid) < 0);
812        assertTrue(min.compareTo(max) < 0);
813
814        try {
815            min.compareTo(null);
816            fail("No NPE");
817        } catch (NullPointerException e) {
818        }
819    }
820    @TestTargetNew(
821        level = TestLevel.PARTIAL,
822        notes = "Checks exceptions.",
823        method = "codePointAt",
824        args = {char[].class, int.class, int.class}
825    )
826    public void test_codePointAt_Invalid() {
827
828        try {
829            Character.codePointAt(null, 6, 4);
830            fail("Expected IndexOutOfBoundsException");
831        } catch (IndexOutOfBoundsException e) {
832            // expected
833        } catch (Exception e) {
834            fail("Expected IndexOutOfBoundsException");
835        }
836
837        try {
838            Character.codePointAt(null, 4, 6);
839            fail("Expected NullPointerException");
840        } catch (NullPointerException e) {
841            // expected
842        } catch (Exception e) {
843            fail("Expected NullPointerException");
844        }
845
846        try {
847            Character.codePointAt(null, 0, 0);
848            fail("Expected IndexOutOfBoundsException");
849        } catch (IndexOutOfBoundsException e) {
850            // expected
851        } catch (Exception e) {
852            fail("Expected IndexOutOfBoundsException");
853        }
854    }
855
856    /**
857     * @tests java.lang.Character#Character(char)
858     */
859    @TestTargetNew(
860        level = TestLevel.COMPLETE,
861        notes = "",
862        method = "Character",
863        args = {char.class}
864    )
865    public void test_ConstructorC() {
866        assertEquals("Constructor failed", 'T', new Character('T').charValue());
867    }
868
869    /**
870     * @tests java.lang.Character#charValue()
871     */
872    @TestTargetNew(
873        level = TestLevel.COMPLETE,
874        notes = "",
875        method = "charValue",
876        args = {}
877    )
878    public void test_charValue() {
879        assertEquals("Incorrect char value returned", 'T', new Character('T')
880                .charValue());
881    }
882
883    /**
884     * @tests java.lang.Character#compareTo(java.lang.Character)
885     */
886    @TestTargetNew(
887        level = TestLevel.COMPLETE,
888        notes = "",
889        method = "compareTo",
890        args = {java.lang.Character.class}
891    )
892    public void test_compareToLjava_lang_Character() {
893        Character c = new Character('c');
894        Character x = new Character('c');
895        Character y = new Character('b');
896        Character z = new Character('d');
897
898        assertEquals("Returned false for same Character", 0, c.compareTo(c));
899        assertEquals("Returned false for identical Character",
900                0, c.compareTo(x));
901        assertTrue("Returned other than less than for lesser char", c
902                .compareTo(y) > 0);
903        assertTrue("Returned other than greater than for greater char", c
904                .compareTo(z) < 0);
905    }
906
907    /**
908     * @tests java.lang.Character#digit(char, int)
909     */
910    @TestTargetNew(
911        level = TestLevel.COMPLETE,
912        notes = "",
913        method = "digit",
914        args = {char.class, int.class}
915    )
916    public void test_digitCI() {
917        assertEquals("Returned incorrect digit", 1, Character.digit('1', 10));
918        assertEquals("Returned incorrect digit", 15, Character.digit('F', 16));
919        assertEquals(-1, Character.digit('\uFFFF', 1));
920    }
921
922    /**
923     * @tests java.lang.Character#digit(int, int)
924     */
925    @TestTargetNew(
926        level = TestLevel.COMPLETE,
927        notes = "",
928        method = "digit",
929        args = {int.class, int.class}
930    )
931    public void test_digit_II() {
932        assertEquals(1, Character.digit((int)'1', 10));
933        assertEquals(15, Character.digit((int)'F', 16));
934
935        assertEquals(-1, Character.digit(0x0000, 37));
936        assertEquals(-1, Character.digit(0x0045, 10));
937
938        assertEquals(10, Character.digit(0x0041, 20));
939        assertEquals(10, Character.digit(0x0061, 20));
940
941        assertEquals(-1, Character.digit(0x110000, 20));
942    }
943
944    /**
945     * @tests java.lang.Character#equals(java.lang.Object)
946     */
947    @TestTargetNew(
948        level = TestLevel.COMPLETE,
949        notes = "",
950        method = "equals",
951        args = {java.lang.Object.class}
952    )
953    public void test_equalsLjava_lang_Object() {
954        // Test for method boolean java.lang.Character.equals(java.lang.Object)
955        assertTrue("Equality test failed", new Character('A')
956                .equals(new Character('A')));
957        assertTrue("Equality test failed", !(new Character('A')
958                .equals(new Character('a'))));
959    }
960
961    /**
962     * @tests java.lang.Character#forDigit(int, int)
963     */
964    @TestTargetNew(
965        level = TestLevel.COMPLETE,
966        notes = "",
967        method = "forDigit",
968        args = {int.class, int.class}
969    )
970    public void test_forDigitII() {
971        char hexChars[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
972                'a', 'b', 'c', 'd', 'e', 'f' };
973        for (int i = 0; i < hexChars.length; i++) {
974            assertTrue("Returned incorrect char for " + Integer.toString(i),
975                    Character.forDigit(i, hexChars.length) == hexChars[i]);
976        }
977
978        char decimalChars[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8',
979                '9' };
980        for (int i = 0; i < decimalChars.length; i++) {
981            assertTrue(
982                    "Returned incorrect char for " + Integer.toString(i),
983                    Character.forDigit(i, decimalChars.length) == decimalChars[i]);
984        }
985
986    }
987
988    /**
989     * @tests java.lang.Character#getNumericValue(char)
990     */
991    @TestTargetNew(
992        level = TestLevel.COMPLETE,
993        notes = "",
994        method = "getNumericValue",
995        args = {char.class}
996    )
997    public void test_getNumericValueC() {
998        assertEquals("Returned incorrect numeric value 1", 1, Character
999                .getNumericValue('1'));
1000        assertEquals("Returned incorrect numeric value 2", 15, Character
1001                .getNumericValue('F'));
1002        assertEquals("Returned incorrect numeric value 3", -1, Character
1003                .getNumericValue('\u221e'));
1004        assertEquals("Returned incorrect numeric value 4", -2, Character
1005                .getNumericValue('\u00be'));
1006        assertEquals("Returned incorrect numeric value 5", 10000, Character
1007                .getNumericValue('\u2182'));
1008        assertEquals("Returned incorrect numeric value 6", 2, Character
1009                .getNumericValue('\uff12'));
1010    }
1011
1012    /**
1013     * @tests java.lang.Character#getNumericValue(int)
1014     */
1015    @TestTargetNew(
1016        level = TestLevel.COMPLETE,
1017        notes = "",
1018        method = "getNumericValue",
1019        args = {int.class}
1020    )
1021    public void test_getNumericValue_I() {
1022        assertEquals(1, Character.getNumericValue((int)'1'));
1023        assertEquals(15, Character.getNumericValue((int)'F'));
1024        assertEquals(-1, Character.getNumericValue((int)'\u221e'));
1025        assertEquals(-2, Character.getNumericValue((int)'\u00be'));
1026        assertEquals(10000, Character.getNumericValue((int)'\u2182'));
1027        assertEquals(2, Character.getNumericValue((int)'\uff12'));
1028        assertEquals(-1, Character.getNumericValue(0xFFFF));
1029
1030        assertEquals(-1, Character.getNumericValue(0xFFFF));
1031        assertEquals(0, Character.getNumericValue(0x1D7CE));
1032        assertEquals(0, Character.getNumericValue(0x1D7D8));
1033        assertEquals(-1, Character.getNumericValue(0x2F800));
1034        assertEquals(-1, Character.getNumericValue(0x10FFFD));
1035        assertEquals(-1, Character.getNumericValue(0x110000));
1036
1037        assertEquals(50, Character.getNumericValue(0x216C));
1038
1039        assertEquals(10, Character.getNumericValue(0x0041));
1040        assertEquals(35, Character.getNumericValue(0x005A));
1041        assertEquals(10, Character.getNumericValue(0x0061));
1042        assertEquals(35, Character.getNumericValue(0x007A));
1043        assertEquals(10, Character.getNumericValue(0xFF21));
1044
1045        //FIXME depends on ICU4J
1046        //assertEquals(35, Character.getNumericValue(0xFF3A));
1047
1048        assertEquals(10, Character.getNumericValue(0xFF41));
1049        assertEquals(35, Character.getNumericValue(0xFF5A));
1050    }
1051
1052    /**
1053     * @tests java.lang.Character#getType(char)
1054     */
1055    @TestTargetNew(
1056        level = TestLevel.COMPLETE,
1057        notes = "",
1058        method = "getType",
1059        args = {char.class}
1060    )
1061    public void test_getTypeC() {
1062        assertTrue("Returned incorrect type for: \n",
1063                Character.getType('\n') == Character.CONTROL);
1064        assertTrue("Returned incorrect type for: 1",
1065                Character.getType('1') == Character.DECIMAL_DIGIT_NUMBER);
1066        assertTrue("Returned incorrect type for: ' '",
1067                Character.getType(' ') == Character.SPACE_SEPARATOR);
1068        assertTrue("Returned incorrect type for: a",
1069                Character.getType('a') == Character.LOWERCASE_LETTER);
1070        assertTrue("Returned incorrect type for: A",
1071                Character.getType('A') == Character.UPPERCASE_LETTER);
1072        assertTrue("Returned incorrect type for: <",
1073                Character.getType('<') == Character.MATH_SYMBOL);
1074        assertTrue("Returned incorrect type for: ;",
1075                Character.getType(';') == Character.OTHER_PUNCTUATION);
1076        assertTrue("Returned incorrect type for: _",
1077                Character.getType('_') == Character.CONNECTOR_PUNCTUATION);
1078        assertTrue("Returned incorrect type for: $",
1079                Character.getType('$') == Character.CURRENCY_SYMBOL);
1080        assertTrue("Returned incorrect type for: \u2029", Character
1081                .getType('\u2029') == Character.PARAGRAPH_SEPARATOR);
1082
1083        assertEquals("Wrong constant for FORMAT", 16, Character.FORMAT);
1084        assertEquals("Wrong constant for PRIVATE_USE",
1085                18, Character.PRIVATE_USE);
1086    }
1087
1088    /**
1089     * @tests java.lang.Character#getType(int)
1090     */
1091    @TestTargetNew(
1092        level = TestLevel.COMPLETE,
1093        notes = "",
1094        method = "getType",
1095        args = {int.class}
1096    )
1097    public void test_getType_I() {
1098        assertTrue(Character.getType((int) '\n') == Character.CONTROL);
1099        assertTrue(Character.getType((int) '1') == Character.DECIMAL_DIGIT_NUMBER);
1100        assertTrue(Character.getType((int) ' ') == Character.SPACE_SEPARATOR);
1101        assertTrue(Character.getType((int) 'a') == Character.LOWERCASE_LETTER);
1102        assertTrue(Character.getType((int) 'A') == Character.UPPERCASE_LETTER);
1103        assertTrue(Character.getType((int) '<') == Character.MATH_SYMBOL);
1104        assertTrue(Character.getType((int) ';') == Character.OTHER_PUNCTUATION);
1105        assertTrue(Character.getType((int) '_') == Character.CONNECTOR_PUNCTUATION);
1106        assertTrue(Character.getType((int) '$') == Character.CURRENCY_SYMBOL);
1107        assertTrue(Character.getType((int) '\u2029') == Character.PARAGRAPH_SEPARATOR);
1108
1109        assertTrue(Character.getType(0x9FFF) == Character.UNASSIGNED);
1110        assertTrue(Character.getType(0x30000) == Character.UNASSIGNED);
1111        assertTrue(Character.getType(0x110000) == Character.UNASSIGNED);
1112
1113        assertTrue(Character.getType(0x0041) == Character.UPPERCASE_LETTER);
1114        assertTrue(Character.getType(0x10400) == Character.UPPERCASE_LETTER);
1115
1116        assertTrue(Character.getType(0x0061) == Character.LOWERCASE_LETTER);
1117        assertTrue(Character.getType(0x10428) == Character.LOWERCASE_LETTER);
1118
1119        assertTrue(Character.getType(0x01C5) == Character.TITLECASE_LETTER);
1120        assertTrue(Character.getType(0x1FFC) == Character.TITLECASE_LETTER);
1121
1122        assertTrue(Character.getType(0x02B0) == Character.MODIFIER_LETTER);
1123        assertTrue(Character.getType(0xFF9F) == Character.MODIFIER_LETTER);
1124
1125        assertTrue(Character.getType(0x01BB) == Character.OTHER_LETTER);
1126        assertTrue(Character.getType(0x2F888) == Character.OTHER_LETTER);
1127
1128        assertTrue(Character.getType(0x0F82) == Character.NON_SPACING_MARK);
1129        assertTrue(Character.getType(0x1D180) == Character.NON_SPACING_MARK);
1130
1131        assertTrue(Character.getType(0x0488) == Character.ENCLOSING_MARK);
1132        assertTrue(Character.getType(0x20DE) == Character.ENCLOSING_MARK);
1133
1134        assertTrue(Character.getType(0x1938) == Character.COMBINING_SPACING_MARK);
1135        assertTrue(Character.getType(0x1D165) == Character.COMBINING_SPACING_MARK);
1136
1137        assertTrue(Character.getType(0x194D) == Character.DECIMAL_DIGIT_NUMBER);
1138        assertTrue(Character.getType(0x1D7CE) == Character.DECIMAL_DIGIT_NUMBER);
1139
1140        assertTrue(Character.getType(0x2160) == Character.LETTER_NUMBER);
1141        assertTrue(Character.getType(0x1034A) == Character.LETTER_NUMBER);
1142
1143        assertTrue(Character.getType(0x00B2) == Character.OTHER_NUMBER);
1144        assertTrue(Character.getType(0x10120) == Character.OTHER_NUMBER);
1145
1146        assertTrue(Character.getType(0x0020) == Character.SPACE_SEPARATOR);
1147        assertTrue(Character.getType(0x3000) == Character.SPACE_SEPARATOR);
1148
1149        assertTrue(Character.getType(0x2028) == Character.LINE_SEPARATOR);
1150
1151        assertTrue(Character.getType(0x2029) == Character.PARAGRAPH_SEPARATOR);
1152
1153        assertTrue(Character.getType(0x0000) == Character.CONTROL);
1154        assertTrue(Character.getType(0x009F) == Character.CONTROL);
1155
1156        assertTrue(Character.getType(0x00AD) == Character.FORMAT);
1157        assertTrue(Character.getType(0xE007F) == Character.FORMAT);
1158
1159        assertTrue(Character.getType(0xE000) == Character.PRIVATE_USE);
1160        assertTrue(Character.getType(0x10FFFD) == Character.PRIVATE_USE);
1161
1162        assertTrue(Character.getType(0xD800) == Character.SURROGATE);
1163        assertTrue(Character.getType(0xDFFF) == Character.SURROGATE);
1164
1165        assertTrue(Character.getType(0xFE31) == Character.DASH_PUNCTUATION);
1166        assertTrue(Character.getType(0xFF0D) == Character.DASH_PUNCTUATION);
1167
1168        assertTrue(Character.getType(0x0028) == Character.START_PUNCTUATION);
1169        assertTrue(Character.getType(0xFF62) == Character.START_PUNCTUATION);
1170
1171        assertTrue(Character.getType(0x0029) == Character.END_PUNCTUATION);
1172        assertTrue(Character.getType(0xFF63) == Character.END_PUNCTUATION);
1173
1174        assertTrue(Character.getType(0x005F) == Character.CONNECTOR_PUNCTUATION);
1175        assertTrue(Character.getType(0xFF3F) == Character.CONNECTOR_PUNCTUATION);
1176
1177        assertTrue(Character.getType(0x2034) == Character.OTHER_PUNCTUATION);
1178        assertTrue(Character.getType(0x1039F) == Character.OTHER_PUNCTUATION);
1179
1180        assertTrue(Character.getType(0x002B) == Character.MATH_SYMBOL);
1181        assertTrue(Character.getType(0x1D6C1) == Character.MATH_SYMBOL);
1182
1183        assertTrue(Character.getType(0x0024) == Character.CURRENCY_SYMBOL);
1184        assertTrue(Character.getType(0xFFE6) == Character.CURRENCY_SYMBOL);
1185
1186        assertTrue(Character.getType(0x005E) == Character.MODIFIER_SYMBOL);
1187        assertTrue(Character.getType(0xFFE3) == Character.MODIFIER_SYMBOL);
1188
1189        assertTrue(Character.getType(0x00A6) == Character.OTHER_SYMBOL);
1190        assertTrue(Character.getType(0x1D356) == Character.OTHER_SYMBOL);
1191
1192        assertTrue(Character.getType(0x00AB) == Character.INITIAL_QUOTE_PUNCTUATION);
1193        assertTrue(Character.getType(0x2039) == Character.INITIAL_QUOTE_PUNCTUATION);
1194
1195        assertTrue(Character.getType(0x00BB) == Character.FINAL_QUOTE_PUNCTUATION);
1196        assertTrue(Character.getType(0x203A) == Character.FINAL_QUOTE_PUNCTUATION);
1197    }
1198
1199    /**
1200     * @tests java.lang.Character#hashCode()
1201     */
1202    @TestTargetNew(
1203        level = TestLevel.COMPLETE,
1204        notes = "",
1205        method = "hashCode",
1206        args = {}
1207    )
1208    public void test_hashCode() {
1209        assertEquals("Incorrect hash returned",
1210                89, new Character('Y').hashCode());
1211    }
1212
1213    /**
1214     * @tests java.lang.Character#isDefined(char)
1215     */
1216    @TestTargetNew(
1217        level = TestLevel.COMPLETE,
1218        notes = "",
1219        method = "isDefined",
1220        args = {char.class}
1221    )
1222    public void test_isDefinedC() {
1223        assertTrue("Defined character returned false", Character.isDefined('v'));
1224        assertTrue("Defined character returned false", Character
1225                .isDefined('\u6039'));
1226    }
1227
1228    /**
1229     * @tests java.lang.Character#isDefined(int)
1230     */
1231    @TestTargetNew(
1232        level = TestLevel.COMPLETE,
1233        notes = "",
1234        method = "isDefined",
1235        args = {int.class}
1236    )
1237    public void test_isDefined_I(){
1238        assertTrue(Character.isDefined((int)'v'));
1239        assertTrue(Character.isDefined((int)'\u6039'));
1240        assertTrue(Character.isDefined(0x10300));
1241
1242        assertFalse(Character.isDefined(0x30000));
1243        assertFalse(Character.isDefined(0x3FFFF));
1244        assertFalse(Character.isDefined(0x110000));
1245    }
1246
1247    /**
1248     * @tests java.lang.Character#isDigit(char)
1249     */
1250    @TestTargetNew(
1251        level = TestLevel.COMPLETE,
1252        notes = "",
1253        method = "isDigit",
1254        args = {char.class}
1255    )
1256    public void test_isDigitC() {
1257        assertTrue("Digit returned false", Character.isDigit('1'));
1258        assertTrue("Non-Digit returned false", !Character.isDigit('A'));
1259    }
1260
1261    /**
1262     * @tests java.lang.Character#isDigit(int)
1263     */
1264    @TestTargetNew(
1265        level = TestLevel.COMPLETE,
1266        notes = "",
1267        method = "isDigit",
1268        args = {int.class}
1269    )
1270    public void test_isDigit_I() {
1271        assertTrue(Character.isDigit((int) '1'));
1272        assertFalse(Character.isDigit((int) 'A'));
1273
1274        assertTrue(Character.isDigit(0x0030));
1275        assertTrue(Character.isDigit(0x0035));
1276        assertTrue(Character.isDigit(0x0039));
1277
1278        assertTrue(Character.isDigit(0x0660));
1279        assertTrue(Character.isDigit(0x0665));
1280        assertTrue(Character.isDigit(0x0669));
1281
1282        assertTrue(Character.isDigit(0x06F0));
1283        assertTrue(Character.isDigit(0x06F5));
1284        assertTrue(Character.isDigit(0x06F9));
1285
1286        assertTrue(Character.isDigit(0x0966));
1287        assertTrue(Character.isDigit(0x096A));
1288        assertTrue(Character.isDigit(0x096F));
1289
1290        assertTrue(Character.isDigit(0xFF10));
1291        assertTrue(Character.isDigit(0xFF15));
1292        assertTrue(Character.isDigit(0xFF19));
1293
1294        assertTrue(Character.isDigit(0x1D7CE));
1295        assertTrue(Character.isDigit(0x1D7D8));
1296
1297        assertFalse(Character.isDigit(0x2F800));
1298        assertFalse(Character.isDigit(0x10FFFD));
1299        assertFalse(Character.isDigit(0x110000));
1300    }
1301
1302    /**
1303     * @tests java.lang.Character#isIdentifierIgnorable(char)
1304     */
1305    @TestTargetNew(
1306        level = TestLevel.COMPLETE,
1307        notes = "",
1308        method = "isIdentifierIgnorable",
1309        args = {char.class}
1310    )
1311    public void test_isIdentifierIgnorableC() {
1312        assertTrue("Ignorable whitespace returned false", Character
1313                .isIdentifierIgnorable('\u0007'));
1314        assertTrue("Ignorable non - whitespace  control returned false",
1315                Character.isIdentifierIgnorable('\u000f'));
1316        assertTrue("Ignorable join control returned false", Character
1317                .isIdentifierIgnorable('\u200e'));
1318
1319        // the spec is wrong, and our implementation is correct
1320        assertTrue("Ignorable bidi control returned false", Character
1321                .isIdentifierIgnorable('\u202b'));
1322
1323        assertTrue("Ignorable format control returned false", Character
1324                .isIdentifierIgnorable('\u206c'));
1325        assertTrue("Ignorable zero-width no-break returned false", Character
1326                .isIdentifierIgnorable('\ufeff'));
1327
1328        assertTrue("Non-Ignorable returned true", !Character
1329                .isIdentifierIgnorable('\u0065'));
1330    }
1331
1332    /**
1333     * @tests java.lang.Character#isIdentifierIgnorable(int)
1334     */
1335    @TestTargetNew(
1336        level = TestLevel.COMPLETE,
1337        notes = "",
1338        method = "isIdentifierIgnorable",
1339        args = {int.class}
1340    )
1341    public void test_isIdentifierIgnorable_I() {
1342        assertTrue(Character.isIdentifierIgnorable(0x0000));
1343        assertTrue(Character.isIdentifierIgnorable(0x0004));
1344        assertTrue(Character.isIdentifierIgnorable(0x0008));
1345
1346        assertTrue(Character.isIdentifierIgnorable(0x000E));
1347        assertTrue(Character.isIdentifierIgnorable(0x0013));
1348        assertTrue(Character.isIdentifierIgnorable(0x001B));
1349
1350        assertTrue(Character.isIdentifierIgnorable(0x007F));
1351        assertTrue(Character.isIdentifierIgnorable(0x008F));
1352        assertTrue(Character.isIdentifierIgnorable(0x009F));
1353
1354        assertTrue(Character.isIdentifierIgnorable(0x202b));
1355        assertTrue(Character.isIdentifierIgnorable(0x206c));
1356        assertTrue(Character.isIdentifierIgnorable(0xfeff));
1357        assertFalse(Character.isIdentifierIgnorable(0x0065));
1358
1359        assertTrue(Character.isIdentifierIgnorable(0x1D173));
1360
1361        assertFalse(Character.isIdentifierIgnorable(0x10FFFD));
1362        assertFalse(Character.isIdentifierIgnorable(0x110000));
1363    }
1364
1365    /**
1366     * @tests java.lang.Character#isMirrored(char)
1367     */
1368    @TestTargetNew(
1369        level = TestLevel.COMPLETE,
1370        notes = "",
1371        method = "isMirrored",
1372        args = {char.class}
1373    )
1374    public void test_isMirrored_C() {
1375        assertTrue(Character.isMirrored('\u0028'));
1376        assertFalse(Character.isMirrored('\uFFFF'));
1377    }
1378
1379    /**
1380     * @tests java.lang.Character#isMirrored(int)
1381     */
1382    @TestTargetNew(
1383        level = TestLevel.COMPLETE,
1384        notes = "",
1385        method = "isMirrored",
1386        args = {int.class}
1387    )
1388    public void test_isMirrored_I() {
1389        assertTrue(Character.isMirrored(0x0028));
1390        assertFalse(Character.isMirrored(0xFFFF));
1391        assertFalse(Character.isMirrored(0x110000));
1392    }
1393
1394    /**
1395     * @tests java.lang.Character#isISOControl(char)
1396     */
1397    @TestTargetNew(
1398        level = TestLevel.COMPLETE,
1399        notes = "",
1400        method = "isISOControl",
1401        args = {char.class}
1402    )
1403    public void test_isISOControlC() {
1404        // Test for method boolean java.lang.Character.isISOControl(char)
1405        for (int i = 0; i < 32; i++)
1406            assertTrue("ISOConstrol char returned false", Character
1407                    .isISOControl((char) i));
1408
1409        for (int i = 127; i < 160; i++)
1410            assertTrue("ISOConstrol char returned false", Character
1411                    .isISOControl((char) i));
1412
1413        for (int i = 160; i < 260; i++)
1414            assertFalse("Not ISOConstrol char returned true", Character
1415                .isISOControl((char) i));
1416    }
1417
1418    /**
1419     * @tests java.lang.Character#isISOControl(int)
1420     */
1421    @TestTargetNew(
1422        level = TestLevel.COMPLETE,
1423        notes = "",
1424        method = "isISOControl",
1425        args = {int.class}
1426    )
1427    public void test_isISOControlI() {
1428        // Test for method boolean java.lang.Character.isISOControl(char)
1429        for (int i = 0; i < 32; i++)
1430            assertTrue("ISOConstrol char returned false", Character
1431                .isISOControl(i));
1432
1433        for (int i = 127; i < 160; i++)
1434            assertTrue("ISOConstrol char returned false", Character
1435                .isISOControl(i));
1436
1437        for (int i = 160; i < 260; i++)
1438            assertFalse("Not ISOConstrol char returned true", Character
1439                .isISOControl(i));
1440
1441    }
1442
1443
1444    /**
1445     * @tests java.lang.Character#isJavaIdentifierPart(char)
1446     */
1447    @TestTargetNew(
1448        level = TestLevel.COMPLETE,
1449        notes = "",
1450        method = "isJavaIdentifierPart",
1451        args = {char.class}
1452    )
1453    public void test_isJavaIdentifierPartC() {
1454        assertTrue("letter returned false", Character.isJavaIdentifierPart('l'));
1455        assertTrue("currency returned false", Character
1456                .isJavaIdentifierPart('$'));
1457        assertTrue("digit returned false", Character.isJavaIdentifierPart('9'));
1458        assertTrue("connecting char returned false", Character
1459                .isJavaIdentifierPart('_'));
1460        assertTrue("ignorable control returned false", Character
1461                .isJavaIdentifierPart('\u200c'));
1462        assertTrue("semi returned true", !Character.isJavaIdentifierPart(';'));
1463    }
1464
1465    /**
1466     * @tests java.lang.Character#isJavaIdentifierPart(int)
1467     */
1468    @TestTargetNew(
1469        level = TestLevel.COMPLETE,
1470        notes = "",
1471        method = "isJavaIdentifierPart",
1472        args = {int.class}
1473    )
1474    public void test_isJavaIdentifierPart_I() {
1475        assertTrue(Character.isJavaIdentifierPart((int)'l'));
1476        assertTrue(Character.isJavaIdentifierPart((int)'$'));
1477        assertTrue(Character.isJavaIdentifierPart((int)'9'));
1478        assertTrue(Character.isJavaIdentifierPart((int)'_'));
1479        assertFalse(Character.isJavaIdentifierPart((int)';'));
1480
1481        assertTrue(Character.isJavaIdentifierPart(0x0041));
1482        assertTrue(Character.isJavaIdentifierPart(0x10400));
1483        assertTrue(Character.isJavaIdentifierPart(0x0061));
1484        assertTrue(Character.isJavaIdentifierPart(0x10428));
1485        assertTrue(Character.isJavaIdentifierPart(0x01C5));
1486        assertTrue(Character.isJavaIdentifierPart(0x1FFC));
1487        assertTrue(Character.isJavaIdentifierPart(0x02B0));
1488        assertTrue(Character.isJavaIdentifierPart(0xFF9F));
1489        assertTrue(Character.isJavaIdentifierPart(0x01BB));
1490        assertTrue(Character.isJavaIdentifierPart(0x2F888));
1491
1492        assertTrue(Character.isJavaIdentifierPart(0x0024));
1493        assertTrue(Character.isJavaIdentifierPart(0xFFE6));
1494
1495        assertTrue(Character.isJavaIdentifierPart(0x005F));
1496        assertTrue(Character.isJavaIdentifierPart(0xFF3F));
1497
1498        assertTrue(Character.isJavaIdentifierPart(0x194D));
1499        assertTrue(Character.isJavaIdentifierPart(0x1D7CE));
1500        assertTrue(Character.isJavaIdentifierPart(0x2160));
1501        assertTrue(Character.isJavaIdentifierPart(0x1034A));
1502
1503        assertTrue(Character.isJavaIdentifierPart(0x0F82));
1504        assertTrue(Character.isJavaIdentifierPart(0x1D180));
1505
1506        assertTrue(Character.isJavaIdentifierPart(0x0000));
1507        assertTrue(Character.isJavaIdentifierPart(0x0008));
1508        assertTrue(Character.isJavaIdentifierPart(0x000E));
1509        assertTrue(Character.isJavaIdentifierPart(0x001B));
1510        assertTrue(Character.isJavaIdentifierPart(0x007F));
1511        assertTrue(Character.isJavaIdentifierPart(0x009F));
1512        assertTrue(Character.isJavaIdentifierPart(0x00AD));
1513        assertTrue(Character.isJavaIdentifierPart(0xE007F));
1514
1515        assertTrue(Character.isJavaIdentifierPart(0x200C));
1516    }
1517
1518    /**
1519     * @tests java.lang.Character#isJavaIdentifierStart(char)
1520     */
1521    @TestTargetNew(
1522        level = TestLevel.COMPLETE,
1523        notes = "",
1524        method = "isJavaIdentifierStart",
1525        args = {char.class}
1526    )
1527    public void test_isJavaIdentifierStartC() {
1528        assertTrue("letter returned false", Character
1529                .isJavaIdentifierStart('l'));
1530        assertTrue("currency returned false", Character
1531                .isJavaIdentifierStart('$'));
1532        assertTrue("connecting char returned false", Character
1533                .isJavaIdentifierStart('_'));
1534        assertTrue("digit returned true", !Character.isJavaIdentifierStart('9'));
1535        assertTrue("ignorable control returned true", !Character
1536                .isJavaIdentifierStart('\u200b'));
1537        assertTrue("semi returned true", !Character.isJavaIdentifierStart(';'));
1538    }
1539
1540    /**
1541     * @tests java.lang.Character#isJavaIdentifierStart(int)
1542     */
1543    @TestTargetNew(
1544        level = TestLevel.COMPLETE,
1545        notes = "",
1546        method = "isJavaIdentifierStart",
1547        args = {int.class}
1548    )
1549    public void test_isJavaIdentifierStart_I() {
1550        assertTrue(Character.isJavaIdentifierStart((int)'l'));
1551        assertTrue(Character.isJavaIdentifierStart((int)'$'));
1552        assertTrue(Character.isJavaIdentifierStart((int)'_'));
1553        assertFalse(Character.isJavaIdentifierStart((int)'9'));
1554        assertFalse(Character.isJavaIdentifierStart((int)'\u200b'));
1555        assertFalse(Character.isJavaIdentifierStart((int)';'));
1556
1557        assertTrue(Character.isJavaIdentifierStart(0x0041));
1558        assertTrue(Character.isJavaIdentifierStart(0x10400));
1559        assertTrue(Character.isJavaIdentifierStart(0x0061));
1560        assertTrue(Character.isJavaIdentifierStart(0x10428));
1561        assertTrue(Character.isJavaIdentifierStart(0x01C5));
1562        assertTrue(Character.isJavaIdentifierStart(0x1FFC));
1563        assertTrue(Character.isJavaIdentifierStart(0x02B0));
1564        assertTrue(Character.isJavaIdentifierStart(0xFF9F));
1565        assertTrue(Character.isJavaIdentifierStart(0x01BB));
1566        assertTrue(Character.isJavaIdentifierStart(0x2F888));
1567
1568        assertTrue(Character.isJavaIdentifierPart(0x0024));
1569        assertTrue(Character.isJavaIdentifierPart(0xFFE6));
1570
1571        assertTrue(Character.isJavaIdentifierPart(0x005F));
1572        assertTrue(Character.isJavaIdentifierPart(0xFF3F));
1573
1574        assertTrue(Character.isJavaIdentifierPart(0x2160));
1575        assertTrue(Character.isJavaIdentifierPart(0x1034A));
1576
1577        assertFalse(Character.isJavaIdentifierPart(0x110000));
1578    }
1579
1580    /**
1581     * @tests java.lang.Character#isJavaLetter(char)
1582     */
1583    @TestTargetNew(
1584        level = TestLevel.COMPLETE,
1585        notes = "",
1586        method = "isJavaLetter",
1587        args = {char.class}
1588    )
1589    @SuppressWarnings("deprecation")
1590    public void test_isJavaLetterC() {
1591        assertTrue("letter returned false", Character.isJavaLetter('l'));
1592        assertTrue("currency returned false", Character.isJavaLetter('$'));
1593        assertTrue("connecting char returned false", Character
1594                .isJavaLetter('_'));
1595
1596        assertTrue("digit returned true", !Character.isJavaLetter('9'));
1597        assertTrue("ignored control returned true", !Character
1598                .isJavaLetter('\u200b'));
1599        assertTrue("semi returned true", !Character.isJavaLetter(';'));
1600    }
1601
1602    /**
1603     * @tests java.lang.Character#isJavaLetterOrDigit(char)
1604     */
1605    @TestTargetNew(
1606        level = TestLevel.COMPLETE,
1607        notes = "",
1608        method = "isJavaLetterOrDigit",
1609        args = {char.class}
1610    )
1611    @SuppressWarnings("deprecation")
1612    public void test_isJavaLetterOrDigitC() {
1613        assertTrue("letter returned false", Character.isJavaLetterOrDigit('l'));
1614        assertTrue("currency returned false", Character
1615                .isJavaLetterOrDigit('$'));
1616        assertTrue("digit returned false", Character.isJavaLetterOrDigit('9'));
1617        assertTrue("connecting char returned false", Character
1618                .isJavaLetterOrDigit('_'));
1619        assertTrue("semi returned true", !Character.isJavaLetterOrDigit(';'));
1620    }
1621
1622    /**
1623     * @tests java.lang.Character#isLetter(char)
1624     */
1625    @TestTargetNew(
1626        level = TestLevel.COMPLETE,
1627        notes = "",
1628        method = "isLetter",
1629        args = {char.class}
1630    )
1631    public void test_isLetterC() {
1632        assertTrue("Letter returned false", Character.isLetter('L'));
1633        assertTrue("Non-Letter returned true", !Character.isLetter('9'));
1634    }
1635
1636    /**
1637     * @tests java.lang.Character#isLetter(int)
1638     */
1639    @TestTargetNew(
1640        level = TestLevel.COMPLETE,
1641        notes = "",
1642        method = "isLetter",
1643        args = {int.class}
1644    )
1645    public void test_isLetter_I() {
1646        assertTrue(Character.isLetter((int)'L'));
1647        assertFalse(Character.isLetter((int)'9'));
1648
1649        assertTrue(Character.isLetter(0x1FA9));
1650        assertTrue(Character.isLetter(0x1D400));
1651        assertTrue(Character.isLetter(0x1D622));
1652        assertTrue(Character.isLetter(0x10000));
1653
1654        assertFalse(Character.isLetter(0x1012C));
1655        assertFalse(Character.isLetter(0x110000));
1656    }
1657
1658    /**
1659     * @tests java.lang.Character#isLetterOrDigit(char)
1660     */
1661    @TestTargetNew(
1662        level = TestLevel.COMPLETE,
1663        notes = "",
1664        method = "isLetterOrDigit",
1665        args = {char.class}
1666    )
1667    public void test_isLetterOrDigitC() {
1668        assertTrue("Digit returned false", Character.isLetterOrDigit('9'));
1669        assertTrue("Letter returned false", Character.isLetterOrDigit('K'));
1670        assertTrue("Control returned true", !Character.isLetterOrDigit('\n'));
1671        assertTrue("Punctuation returned true", !Character.isLetterOrDigit('?'));
1672    }
1673
1674    /**
1675     * @tests java.lang.Character#isLetterOrDigit(int)
1676     */
1677    @TestTargetNew(
1678        level = TestLevel.COMPLETE,
1679        notes = "",
1680        method = "isLetterOrDigit",
1681        args = {int.class}
1682    )
1683    public void test_isLetterOrDigit_I() {
1684        assertTrue(Character.isLetterOrDigit((int)'9'));
1685        assertTrue(Character.isLetterOrDigit((int)'K'));
1686        assertFalse(Character.isLetterOrDigit((int)'\n'));
1687        assertFalse(Character.isLetterOrDigit((int)'?'));
1688
1689        assertTrue(Character.isLetterOrDigit(0x1FA9));
1690        assertTrue(Character.isLetterOrDigit(0x1D400));
1691        assertTrue(Character.isLetterOrDigit(0x1D622));
1692        assertTrue(Character.isLetterOrDigit(0x10000));
1693
1694        assertTrue(Character.isLetterOrDigit(0x1D7CE));
1695        assertTrue(Character.isLetterOrDigit(0x1D7D8));
1696
1697        assertFalse(Character.isLetterOrDigit(0x10FFFD));
1698        assertFalse(Character.isLetterOrDigit(0x1012C));
1699        assertFalse(Character.isLetterOrDigit(0x110000));
1700    }
1701
1702    /**
1703     * @tests java.lang.Character#isLowerCase(char)
1704     */
1705    @TestTargetNew(
1706        level = TestLevel.COMPLETE,
1707        notes = "",
1708        method = "isLowerCase",
1709        args = {char.class}
1710    )
1711    public void test_isLowerCaseC() {
1712        assertTrue("lower returned false", Character.isLowerCase('a'));
1713        assertTrue("upper returned true", !Character.isLowerCase('T'));
1714    }
1715
1716    /**
1717     * @tests java.lang.Character#isLowerCase(int)
1718     */
1719    @TestTargetNew(
1720        level = TestLevel.COMPLETE,
1721        notes = "",
1722        method = "isLowerCase",
1723        args = {int.class}
1724    )
1725    public void test_isLowerCase_I() {
1726        assertTrue(Character.isLowerCase((int)'a'));
1727        assertFalse(Character.isLowerCase((int)'T'));
1728
1729        assertTrue(Character.isLowerCase(0x10428));
1730        assertTrue(Character.isLowerCase(0x1D4EA));
1731
1732        assertFalse(Character.isLowerCase(0x1D504));
1733        assertFalse(Character.isLowerCase(0x30000));
1734        assertFalse(Character.isLowerCase(0x110000));
1735    }
1736
1737    /**
1738     * @tests java.lang.Character#isSpace(char)
1739     */
1740    @TestTargetNew(
1741        level = TestLevel.COMPLETE,
1742        notes = "",
1743        method = "isSpace",
1744        args = {char.class}
1745    )
1746    @SuppressWarnings("deprecation")
1747    public void test_isSpaceC() {
1748        // Test for method boolean java.lang.Character.isSpace(char)
1749        assertTrue("space returned false", Character.isSpace('\n'));
1750        assertTrue("non-space returned true", !Character.isSpace('T'));
1751    }
1752
1753    /**
1754     * @tests java.lang.Character#isSpaceChar(char)
1755     */
1756    @TestTargetNew(
1757        level = TestLevel.COMPLETE,
1758        notes = "",
1759        method = "isSpaceChar",
1760        args = {char.class}
1761    )
1762    public void test_isSpaceCharC() {
1763        assertTrue("space returned false", Character.isSpaceChar('\u0020'));
1764        assertTrue("non-space returned true", !Character.isSpaceChar('\n'));
1765    }
1766
1767    /**
1768     * @tests java.lang.Character#isSpaceChar(int)
1769     */
1770    @TestTargetNew(
1771        level = TestLevel.COMPLETE,
1772        notes = "",
1773        method = "isSpaceChar",
1774        args = {int.class}
1775    )
1776    public void test_isSpaceChar_I() {
1777        assertTrue(Character.isSpaceChar((int)'\u0020'));
1778        assertFalse(Character.isSpaceChar((int)'\n'));
1779
1780        assertTrue(Character.isSpaceChar(0x2000));
1781        assertTrue(Character.isSpaceChar(0x200A));
1782
1783        assertTrue(Character.isSpaceChar(0x2028));
1784        assertTrue(Character.isSpaceChar(0x2029));
1785
1786        assertFalse(Character.isSpaceChar(0x110000));
1787    }
1788
1789    /**
1790     * @tests java.lang.Character#isTitleCase(char)
1791     */
1792    @TestTargetNew(
1793        level = TestLevel.COMPLETE,
1794        notes = "",
1795        method = "isTitleCase",
1796        args = {char.class}
1797    )
1798    public void test_isTitleCaseC() {
1799        char[] tChars = { (char) 0x01c5, (char) 0x01c8, (char) 0x01cb,
1800                (char) 0x01f2, (char) 0x1f88, (char) 0x1f89, (char) 0x1f8a,
1801                (char) 0x1f8b, (char) 0x1f8c, (char) 0x1f8d, (char) 0x1f8e,
1802                (char) 0x1f8f, (char) 0x1f98, (char) 0x1f99, (char) 0x1f9a,
1803                (char) 0x1f9b, (char) 0x1f9c, (char) 0x1f9d, (char) 0x1f9e,
1804                (char) 0x1f9f, (char) 0x1fa8, (char) 0x1fa9, (char) 0x1faa,
1805                (char) 0x1fab, (char) 0x1fac, (char) 0x1fad, (char) 0x1fae,
1806                (char) 0x1faf, (char) 0x1fbc, (char) 0x1fcc, (char) 0x1ffc };
1807        byte tnum = 0;
1808        for (char c = 0; c < 65535; c++) {
1809            if (Character.isTitleCase(c)) {
1810                tnum++;
1811                int i;
1812                for (i = 0; i < tChars.length; i++)
1813                    if (tChars[i] == c)
1814                        i = tChars.length + 1;
1815                if (i < tChars.length) {
1816                    fail("Non Title Case char returned true");
1817                }
1818            }
1819        }
1820        assertTrue("Failed to find all Title Case chars", tnum == tChars.length);
1821    }
1822
1823    /**
1824     * @tests java.lang.Character#isTitleCase(int)
1825     */
1826    @TestTargetNew(
1827        level = TestLevel.COMPLETE,
1828        notes = "",
1829        method = "isTitleCase",
1830        args = {int.class}
1831    )
1832    public void test_isTitleCase_I() {
1833        //all the titlecase characters
1834        int[] titleCaseCharacters = { 0x01c5, 0x01c8, 0x01cb, 0x01f2, 0x1f88,
1835                0x1f89, 0x1f8a, 0x1f8b, 0x1f8c, 0x1f8d, 0x1f8e, 0x1f8f, 0x1f98,
1836                0x1f99, 0x1f9a, 0x1f9b, 0x1f9c, 0x1f9d, 0x1f9e, 0x1f9f, 0x1fa8,
1837                0x1fa9, 0x1faa, 0x1fab, 0x1fac, 0x1fad, 0x1fae, 0x1faf, 0x1fbc,
1838                0x1fcc, 0x1ffc };
1839
1840        for (int i = 0; i < titleCaseCharacters.length; i++) {
1841            assertTrue(Character.isTitleCase(titleCaseCharacters[i]));
1842        }
1843
1844        assertFalse(Character.isTitleCase(0x110000));
1845    }
1846
1847    /**
1848     * @tests java.lang.Character#isUnicodeIdentifierPart(char)
1849     */
1850    @TestTargetNew(
1851        level = TestLevel.COMPLETE,
1852        notes = "",
1853        method = "isUnicodeIdentifierPart",
1854        args = {char.class}
1855    )
1856    public void test_isUnicodeIdentifierPartC() {
1857        assertTrue("'a' returned false", Character.isUnicodeIdentifierPart('a'));
1858        assertTrue("'2' returned false", Character.isUnicodeIdentifierPart('2'));
1859        assertTrue("'+' returned true", !Character.isUnicodeIdentifierPart('+'));
1860    }
1861
1862    /**
1863     * @tests java.lang.Character#isUnicodeIdentifierPart(int)
1864     */
1865    @TestTargetNew(
1866        level = TestLevel.COMPLETE,
1867        notes = "",
1868        method = "isUnicodeIdentifierPart",
1869        args = {int.class}
1870    )
1871    public void test_isUnicodeIdentifierPart_I() {
1872        assertTrue(Character.isUnicodeIdentifierPart((int)'a'));
1873        assertTrue(Character.isUnicodeIdentifierPart((int)'2'));
1874        assertFalse(Character.isUnicodeIdentifierPart((int)'+'));
1875
1876        assertTrue(Character.isUnicodeIdentifierPart(0x1FA9));
1877        assertTrue(Character.isUnicodeIdentifierPart(0x1D400));
1878        assertTrue(Character.isUnicodeIdentifierPart(0x1D622));
1879        assertTrue(Character.isUnicodeIdentifierPart(0x10000));
1880
1881        assertTrue(Character.isUnicodeIdentifierPart(0x0030));
1882        assertTrue(Character.isUnicodeIdentifierPart(0x0035));
1883        assertTrue(Character.isUnicodeIdentifierPart(0x0039));
1884
1885        assertTrue(Character.isUnicodeIdentifierPart(0x0660));
1886        assertTrue(Character.isUnicodeIdentifierPart(0x0665));
1887        assertTrue(Character.isUnicodeIdentifierPart(0x0669));
1888
1889        assertTrue(Character.isUnicodeIdentifierPart(0x06F0));
1890        assertTrue(Character.isUnicodeIdentifierPart(0x06F5));
1891        assertTrue(Character.isUnicodeIdentifierPart(0x06F9));
1892
1893        assertTrue(Character.isUnicodeIdentifierPart(0x0966));
1894        assertTrue(Character.isUnicodeIdentifierPart(0x096A));
1895        assertTrue(Character.isUnicodeIdentifierPart(0x096F));
1896
1897        assertTrue(Character.isUnicodeIdentifierPart(0xFF10));
1898        assertTrue(Character.isUnicodeIdentifierPart(0xFF15));
1899        assertTrue(Character.isUnicodeIdentifierPart(0xFF19));
1900
1901        assertTrue(Character.isUnicodeIdentifierPart(0x1D7CE));
1902        assertTrue(Character.isUnicodeIdentifierPart(0x1D7D8));
1903
1904        assertTrue(Character.isUnicodeIdentifierPart(0x16EE));
1905        assertTrue(Character.isUnicodeIdentifierPart(0xFE33));
1906        assertTrue(Character.isUnicodeIdentifierPart(0xFF10));
1907        assertTrue(Character.isUnicodeIdentifierPart(0x1D165));
1908        assertTrue(Character.isUnicodeIdentifierPart(0x1D167));
1909        assertTrue(Character.isUnicodeIdentifierPart(0x1D173));
1910
1911        assertFalse(Character.isUnicodeIdentifierPart(0x10FFFF));
1912        assertFalse(Character.isUnicodeIdentifierPart(0x110000));
1913    }
1914
1915    /**
1916     * @tests java.lang.Character#isUnicodeIdentifierStart(char)
1917     */
1918    @TestTargetNew(
1919        level = TestLevel.COMPLETE,
1920        notes = "",
1921        method = "isUnicodeIdentifierStart",
1922        args = {char.class}
1923    )
1924    public void test_isUnicodeIdentifierStartC() {
1925        assertTrue("'a' returned false", Character
1926                .isUnicodeIdentifierStart('a'));
1927        assertTrue("'2' returned true", !Character
1928                .isUnicodeIdentifierStart('2'));
1929        assertTrue("'+' returned true", !Character
1930                .isUnicodeIdentifierStart('+'));
1931    }
1932
1933    /**
1934     * @tests java.lang.Character#isUnicodeIdentifierStart(int)
1935     */
1936    @TestTargetNew(
1937        level = TestLevel.COMPLETE,
1938        notes = "",
1939        method = "isUnicodeIdentifierStart",
1940        args = {int.class}
1941    )
1942    public void test_isUnicodeIdentifierStart_I() {
1943
1944        assertTrue(Character.isUnicodeIdentifierStart((int) 'a'));
1945        assertFalse(Character.isUnicodeIdentifierStart((int) '2'));
1946        assertFalse(Character.isUnicodeIdentifierStart((int) '+'));
1947
1948        assertTrue(Character.isUnicodeIdentifierStart(0x1FA9));
1949        assertTrue(Character.isUnicodeIdentifierStart(0x1D400));
1950        assertTrue(Character.isUnicodeIdentifierStart(0x1D622));
1951        assertTrue(Character.isUnicodeIdentifierStart(0x10000));
1952
1953        assertTrue(Character.isUnicodeIdentifierStart(0x16EE));
1954
1955        // number is not a valid start of a Unicode identifier
1956        assertFalse(Character.isUnicodeIdentifierStart(0x0030));
1957        assertFalse(Character.isUnicodeIdentifierStart(0x0039));
1958        assertFalse(Character.isUnicodeIdentifierStart(0x0660));
1959        assertFalse(Character.isUnicodeIdentifierStart(0x0669));
1960        assertFalse(Character.isUnicodeIdentifierStart(0x06F0));
1961        assertFalse(Character.isUnicodeIdentifierStart(0x06F9));
1962
1963        assertFalse(Character.isUnicodeIdentifierPart(0x10FFFF));
1964        assertFalse(Character.isUnicodeIdentifierPart(0x110000));
1965    }
1966
1967    /**
1968     * @tests java.lang.Character#isUpperCase(char)
1969     */
1970    @TestTargetNew(
1971        level = TestLevel.COMPLETE,
1972        notes = "",
1973        method = "isUpperCase",
1974        args = {char.class}
1975    )
1976    public void test_isUpperCaseC() {
1977        assertTrue("Incorrect case value", !Character.isUpperCase('t'));
1978        assertTrue("Incorrect case value", Character.isUpperCase('T'));
1979        assertFalse("Incorrect case value", Character.isUpperCase('1'));
1980        assertFalse("Incorrect case value", Character.isUpperCase('?'));
1981    }
1982
1983    /**
1984     * @tests java.lang.Character#isUpperCase(int)
1985     */
1986    @TestTargetNew(
1987        level = TestLevel.COMPLETE,
1988        notes = "",
1989        method = "isUpperCase",
1990        args = {int.class}
1991    )
1992    public void test_isUpperCase_I() {
1993        assertFalse(Character.isUpperCase((int)'t'));
1994        assertTrue(Character.isUpperCase((int)'T'));
1995
1996        assertTrue(Character.isUpperCase(0x1D504));
1997        assertTrue(Character.isUpperCase(0x1D608));
1998
1999        assertFalse(Character.isUpperCase(0x1D656));
2000        assertFalse(Character.isUpperCase(0x10FFFD));
2001        assertFalse(Character.isUpperCase(0x110000));
2002    }
2003
2004    /**
2005     * @tests java.lang.Character#isWhitespace(char)
2006     */
2007    @TestTargetNew(
2008        level = TestLevel.COMPLETE,
2009        notes = "",
2010        method = "isWhitespace",
2011        args = {char.class}
2012    )
2013    public void test_isWhitespaceC() {
2014        assertTrue("space returned false", Character.isWhitespace('\n'));
2015        assertTrue("non-space returned true", !Character.isWhitespace('T'));
2016    }
2017
2018    /**
2019     * @tests java.lang.Character#isWhitespace(int)
2020     */
2021    @TestTargetNew(
2022        level = TestLevel.COMPLETE,
2023        notes = "",
2024        method = "isWhitespace",
2025        args = {int.class}
2026    )
2027    public void test_isWhitespace_I() {
2028        assertTrue(Character.isWhitespace((int)'\n'));
2029        assertFalse(Character.isWhitespace((int)'T'));
2030
2031        assertTrue(Character.isWhitespace(0x0009));
2032        assertTrue(Character.isWhitespace(0x000A));
2033        assertTrue(Character.isWhitespace(0x000B));
2034        assertTrue(Character.isWhitespace(0x000C));
2035        assertTrue(Character.isWhitespace(0x000D));
2036        assertTrue(Character.isWhitespace(0x001C));
2037        assertTrue(Character.isWhitespace(0x001D));
2038        assertTrue(Character.isWhitespace(0x001F));
2039        assertTrue(Character.isWhitespace(0x001E));
2040
2041        assertTrue(Character.isWhitespace(0x2000));
2042        assertTrue(Character.isWhitespace(0x200A));
2043
2044        assertTrue(Character.isWhitespace(0x2028));
2045        assertTrue(Character.isWhitespace(0x2029));
2046
2047        assertFalse(Character.isWhitespace(0x00A0));
2048        assertFalse(Character.isWhitespace(0x202F));
2049        assertFalse(Character.isWhitespace(0x110000));
2050
2051        assertFalse(Character.isWhitespace(0xFEFF));
2052
2053        //FIXME depend on ICU4J
2054        //assertFalse(Character.isWhitespace(0x2007));
2055
2056    }
2057
2058    /**
2059     * @tests java.lang.Character#reverseBytes(char)
2060     */
2061    @TestTargetNew(
2062        level = TestLevel.COMPLETE,
2063        notes = "",
2064        method = "reverseBytes",
2065        args = {char.class}
2066    )
2067    public void test_reverseBytesC() {
2068        char original[] = new char[]{0x0000, 0x0010, 0x00AA, 0xB000, 0xCC00, 0xABCD, 0xFFAA};
2069        char reversed[] = new char[]{0x0000, 0x1000, 0xAA00, 0x00B0, 0x00CC, 0xCDAB, 0xAAFF};
2070        assertTrue("Test self check", original.length==reversed.length);
2071
2072        for (int i=0; i<original.length; i++) {
2073            char origChar = original[i];
2074            char reversedChar = reversed[i];
2075            char origReversed= Character.reverseBytes(origChar);
2076
2077            assertTrue("java.lang.Character.reverseBytes failed: orig char="
2078                +Integer.toHexString(origChar)+", reversed char="
2079                +Integer.toHexString(origReversed), reversedChar==origReversed);
2080        }
2081    }
2082
2083    /**
2084     * @tests java.lang.Character#toLowerCase(char)
2085     */
2086    @TestTargetNew(
2087        level = TestLevel.COMPLETE,
2088        notes = "",
2089        method = "toLowerCase",
2090        args = {char.class}
2091    )
2092    public void test_toLowerCaseC() {
2093        assertEquals("Failed to change case", 't', Character.toLowerCase('T'));
2094        assertEquals("Failed to change case", 't', Character.toLowerCase('t'));
2095        assertEquals("Failed to change case", '1', Character.toLowerCase('1'));
2096    }
2097
2098    /**
2099     * @tests java.lang.Character#toLowerCase(int)
2100     */
2101    @TestTargetNew(
2102        level = TestLevel.COMPLETE,
2103        notes = "",
2104        method = "toLowerCase",
2105        args = {int.class}
2106    )
2107    public void test_toLowerCase_I() {
2108        assertEquals('t', Character.toLowerCase((int)'T'));
2109
2110        assertEquals(0x10428, Character.toLowerCase(0x10400));
2111        assertEquals(0x10428, Character.toLowerCase(0x10428));
2112
2113        assertEquals(0x1D504, Character.toLowerCase(0x1D504));
2114        assertEquals(0x10FFFD, Character.toLowerCase(0x10FFFD));
2115        assertEquals(0x110000, Character.toLowerCase(0x110000));
2116    }
2117
2118    /**
2119     * @tests java.lang.Character#toString()
2120     */
2121    @TestTargetNew(
2122        level = TestLevel.COMPLETE,
2123        notes = "",
2124        method = "toString",
2125        args = {}
2126    )
2127    public void test_toString() {
2128        assertEquals("Incorrect String returned", "T", new Character('T').toString());
2129        assertEquals("Incorrect String returned", "1", new Character('1').toString());
2130        assertEquals("Incorrect String returned", "$", new Character('$').toString());
2131    }
2132
2133    /**
2134     * @tests java.lang.Character#toString(char)
2135     */
2136    @TestTargetNew(
2137        level = TestLevel.COMPLETE,
2138        notes = "",
2139        method = "toString",
2140        args = {char.class}
2141    )
2142    public void test_toString_char() {
2143        assertEquals("Incorrect String returned", "T", Character.toString('T'));
2144    }
2145
2146    /**
2147     * @tests java.lang.Character#toTitleCase(char)
2148     */
2149    @TestTargetNew(
2150        level = TestLevel.COMPLETE,
2151        notes = "",
2152        method = "toTitleCase",
2153        args = {char.class}
2154    )
2155    public void test_toTitleCaseC() {
2156        assertEquals("Incorrect title case for a",
2157                'A', Character.toTitleCase('a'));
2158        assertEquals("Incorrect title case for A",
2159                'A', Character.toTitleCase('A'));
2160        assertEquals("Incorrect title case for 1",
2161                '1', Character.toTitleCase('1'));
2162    }
2163
2164    /**
2165     * @tests java.lang.Character#toTitleCase(int)
2166     */
2167    @TestTargetNew(
2168        level = TestLevel.COMPLETE,
2169        notes = "",
2170        method = "toTitleCase",
2171        args = {int.class}
2172    )
2173    public void test_toTitleCase_I() {
2174        assertEquals('A', Character.toTitleCase((int)'a'));
2175        assertEquals('A', Character.toTitleCase((int)'A'));
2176        assertEquals('1', Character.toTitleCase((int)'1'));
2177
2178        assertEquals(0x10400, Character.toTitleCase(0x10428));
2179        assertEquals(0x10400, Character.toTitleCase(0x10400));
2180
2181        assertEquals(0x10FFFF, Character.toTitleCase(0x10FFFF));
2182        assertEquals(0x110000, Character.toTitleCase(0x110000));
2183    }
2184
2185    /**
2186     * @tests java.lang.Character#toUpperCase(char)
2187     */
2188    @TestTargetNew(
2189        level = TestLevel.COMPLETE,
2190        notes = "",
2191        method = "toUpperCase",
2192        args = {char.class}
2193    )
2194    public void test_toUpperCaseC() {
2195        // Test for method char java.lang.Character.toUpperCase(char)
2196        assertEquals("Incorrect upper case for a",
2197                'A', Character.toUpperCase('a'));
2198        assertEquals("Incorrect upper case for A",
2199                'A', Character.toUpperCase('A'));
2200        assertEquals("Incorrect upper case for 1",
2201                '1', Character.toUpperCase('1'));
2202    }
2203
2204    /**
2205     * @tests java.lang.Character#toUpperCase(int)
2206     */
2207    @TestTargetNew(
2208        level = TestLevel.COMPLETE,
2209        notes = "",
2210        method = "toUpperCase",
2211        args = {int.class}
2212    )
2213    public void test_toUpperCase_I() {
2214        assertEquals('A', Character.toUpperCase((int)'a'));
2215        assertEquals('A', Character.toUpperCase((int)'A'));
2216        assertEquals('1', Character.toUpperCase((int)'1'));
2217
2218        assertEquals(0x10400, Character.toUpperCase(0x10428));
2219        assertEquals(0x10400, Character.toUpperCase(0x10400));
2220
2221        assertEquals(0x10FFFF, Character.toUpperCase(0x10FFFF));
2222        assertEquals(0x110000, Character.toUpperCase(0x110000));
2223    }
2224
2225    /**
2226     * @tests java.lang.Character#getDirectionality(int)
2227     */
2228    @TestTargetNew(
2229        level = TestLevel.COMPLETE,
2230        notes = "",
2231        method = "getDirectionality",
2232        args = {int.class}
2233    )
2234    public void test_isDirectionaliy_I(){
2235        assertEquals(Character.DIRECTIONALITY_UNDEFINED, Character
2236                .getDirectionality(0xFFFE));
2237        assertEquals(Character.DIRECTIONALITY_UNDEFINED, Character
2238                .getDirectionality(0x30000));
2239        assertEquals(Character.DIRECTIONALITY_UNDEFINED, Character
2240                .getDirectionality(0x110000));
2241        assertEquals(Character.DIRECTIONALITY_UNDEFINED, Character
2242                .getDirectionality(-1));
2243
2244        assertEquals(Character.DIRECTIONALITY_LEFT_TO_RIGHT, Character
2245                .getDirectionality(0x0041));
2246        assertEquals(Character.DIRECTIONALITY_LEFT_TO_RIGHT, Character
2247                .getDirectionality(0x10000));
2248        assertEquals(Character.DIRECTIONALITY_LEFT_TO_RIGHT, Character
2249                .getDirectionality(0x104A9));
2250
2251        assertEquals(Character.DIRECTIONALITY_RIGHT_TO_LEFT, Character
2252                .getDirectionality(0xFB4F));
2253        assertEquals(Character.DIRECTIONALITY_RIGHT_TO_LEFT, Character
2254                .getDirectionality(0x10838));
2255
2256        assertEquals(Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC, Character
2257                .getDirectionality(0x0600));
2258        assertEquals(Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC, Character
2259                .getDirectionality(0xFEFC));
2260
2261        assertEquals(Character.DIRECTIONALITY_EUROPEAN_NUMBER, Character
2262                .getDirectionality(0x2070));
2263        assertEquals(Character.DIRECTIONALITY_EUROPEAN_NUMBER, Character
2264                .getDirectionality(0x1D7FF));
2265
2266        // No common char in this group on android and java.
2267        // assertEquals(Character.DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR, Character
2268        //         .getDirectionality(0x002B));
2269        // assertEquals(Character.DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR, Character
2270        //         .getDirectionality(0xFF0B));
2271
2272        assertEquals(Character.DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR, Character
2273                .getDirectionality(0x0023));
2274        assertEquals(Character.DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR, Character
2275                .getDirectionality(0x17DB));
2276
2277        assertEquals(Character.DIRECTIONALITY_ARABIC_NUMBER, Character
2278                .getDirectionality(0x0660));
2279        assertEquals(Character.DIRECTIONALITY_ARABIC_NUMBER, Character
2280                .getDirectionality(0x066C));
2281
2282        assertEquals(Character.DIRECTIONALITY_COMMON_NUMBER_SEPARATOR, Character
2283                .getDirectionality(0x002C));
2284        assertEquals(Character.DIRECTIONALITY_COMMON_NUMBER_SEPARATOR, Character
2285                .getDirectionality(0xFF1A));
2286
2287        assertEquals(Character.DIRECTIONALITY_NONSPACING_MARK, Character
2288                .getDirectionality(0x17CE));
2289        assertEquals(Character.DIRECTIONALITY_NONSPACING_MARK, Character
2290                .getDirectionality(0xE01DB));
2291
2292        assertEquals(Character.DIRECTIONALITY_BOUNDARY_NEUTRAL, Character
2293                .getDirectionality(0x0000));
2294        assertEquals(Character.DIRECTIONALITY_BOUNDARY_NEUTRAL, Character
2295                .getDirectionality(0xE007F));
2296
2297        assertEquals(Character.DIRECTIONALITY_PARAGRAPH_SEPARATOR, Character
2298                .getDirectionality(0x000A));
2299        assertEquals(Character.DIRECTIONALITY_PARAGRAPH_SEPARATOR, Character
2300                .getDirectionality(0x2029));
2301
2302        assertEquals(Character.DIRECTIONALITY_SEGMENT_SEPARATOR, Character
2303                .getDirectionality(0x0009));
2304        assertEquals(Character.DIRECTIONALITY_SEGMENT_SEPARATOR, Character
2305                .getDirectionality(0x001F));
2306
2307        assertEquals(Character.DIRECTIONALITY_WHITESPACE, Character
2308                .getDirectionality(0x0020));
2309        assertEquals(Character.DIRECTIONALITY_WHITESPACE, Character
2310                .getDirectionality(0x3000));
2311
2312        assertEquals(Character.DIRECTIONALITY_OTHER_NEUTRALS, Character
2313                .getDirectionality(0x2FF0));
2314        assertEquals(Character.DIRECTIONALITY_OTHER_NEUTRALS, Character
2315                .getDirectionality(0x1D356));
2316
2317        assertEquals(Character.DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING, Character
2318                .getDirectionality(0x202A));
2319
2320        assertEquals(Character.DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE, Character
2321                .getDirectionality(0x202D));
2322
2323        assertEquals(Character.DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING, Character
2324                .getDirectionality(0x202B));
2325
2326        assertEquals(Character.DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE, Character
2327                .getDirectionality(0x202E));
2328
2329        assertEquals(Character.DIRECTIONALITY_POP_DIRECTIONAL_FORMAT, Character
2330                .getDirectionality(0x202C));
2331    }
2332}
2333