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