jars/icu4j-4_4_2-src/main/tests/core/src/com/ibm/icu/dev/test/lang/UCharacterTest.java

   1 /**\r
   2 *******************************************************************************\r
   3 * Copyright (C) 1996-2010, International Business Machines Corporation and    *\r
   4 * others. All Rights Reserved.                                                *\r
   5 *******************************************************************************\r
   6 */\r
   7 \r
   8 package com.ibm.icu.dev.test.lang;\r
   9 \r
  10 import java.io.BufferedReader;\r
  11 import java.util.Arrays;\r
  12 import java.util.Locale;\r
  13 \r
  14 import com.ibm.icu.dev.test.TestFmwk;\r
  15 import com.ibm.icu.dev.test.TestUtil;\r
  16 import com.ibm.icu.impl.Norm2AllModes;\r
  17 import com.ibm.icu.impl.Normalizer2Impl;\r
  18 import com.ibm.icu.impl.UBiDiProps;\r
  19 import com.ibm.icu.impl.UCaseProps;\r
  20 import com.ibm.icu.impl.UCharacterName;\r
  21 import com.ibm.icu.impl.UCharacterProperty;\r
  22 import com.ibm.icu.impl.Utility;\r
  23 import com.ibm.icu.lang.UCharacter;\r
  24 import com.ibm.icu.lang.UCharacterCategory;\r
  25 import com.ibm.icu.lang.UCharacterDirection;\r
  26 import com.ibm.icu.lang.UCharacterEnums;\r
  27 import com.ibm.icu.lang.UProperty;\r
  28 import com.ibm.icu.lang.UScript;\r
  29 import com.ibm.icu.text.Normalizer2;\r
  30 import com.ibm.icu.text.UTF16;\r
  31 import com.ibm.icu.text.UnicodeSet;\r
  32 import com.ibm.icu.text.UnicodeSetIterator;\r
  33 import com.ibm.icu.util.RangeValueIterator;\r
  34 import com.ibm.icu.util.ULocale;\r
  35 import com.ibm.icu.util.ValueIterator;\r
  36 import com.ibm.icu.util.VersionInfo;\r
  37 \r
  38 /**\r
  39 * Testing class for UCharacter\r
  40 * Mostly following the test cases for ICU\r
  41 * @author Syn Wee Quek\r
  42 * @since nov 04 2000\r
  43 */\r
  44 public final class UCharacterTest extends TestFmwk\r
  45 {\r
  46     // private variables =============================================\r
  47 \r
  48     /**\r
  49     * ICU4J data version number\r
  50     */\r
  51     private final VersionInfo VERSION_ = VersionInfo.getInstance("5.2.0.0");\r
  52 \r
  53     // constructor ===================================================\r
  54 \r
  55     /**\r
  56     * Constructor\r
  57     */\r
  58     public UCharacterTest()\r
  59     {\r
  60     }\r
  61 \r
  62     // public methods ================================================\r
  63 \r
  64     public static void main(String[] arg)\r
  65     {\r
  66         try\r
  67         {\r
  68             UCharacterTest test = new UCharacterTest();\r
  69             test.run(arg);\r
  70         }\r
  71         catch (Exception e)\r
  72         {\r
  73         e.printStackTrace();\r
  74         }\r
  75     }\r
  76 \r
  77     /**\r
  78     * Testing the letter and number determination in UCharacter\r
  79     */\r
  80     public void TestLetterNumber()\r
  81     {\r
  82         for (int i = 0x0041; i < 0x005B; i ++)\r
  83         if (!UCharacter.isLetter(i))\r
  84             errln("FAIL \\u" + hex(i) + " expected to be a letter");\r
  85 \r
  86         for (int i = 0x0660; i < 0x066A; i ++)\r
  87         if (UCharacter.isLetter(i))\r
  88             errln("FAIL \\u" + hex(i) + " expected not to be a letter");\r
  89 \r
  90         for (int i = 0x0660; i < 0x066A; i ++)\r
  91         if (!UCharacter.isDigit(i))\r
  92             errln("FAIL \\u" + hex(i) + " expected to be a digit");\r
  93 \r
  94         for (int i = 0x0041; i < 0x005B; i ++)\r
  95             if (!UCharacter.isLetterOrDigit(i))\r
  96                 errln("FAIL \\u" + hex(i) + " expected not to be a digit");\r
  97 \r
  98         for (int i = 0x0660; i < 0x066A; i ++)\r
  99             if (!UCharacter.isLetterOrDigit(i))\r
 100                 errln("FAIL \\u" + hex(i) +\r
 101                     "expected to be either a letter or a digit");\r
 102 \r
 103         /*\r
 104          * The following checks work only starting from Unicode 4.0.\r
 105          * Check the version number here.\r
 106          */\r
 107         VersionInfo version =    UCharacter.getUnicodeVersion();\r
 108         if(version.getMajor()<4 || version.equals(VersionInfo.getInstance(4, 0, 1))) {\r
 109             return;\r
 110         }\r
 111 \r
 112 \r
 113 \r
 114         /*\r
 115          * Sanity check:\r
 116          * Verify that exactly the digit characters have decimal digit values.\r
 117          * This assumption is used in the implementation of u_digit()\r
 118          * (which checks nt=de)\r
 119          * compared with the parallel java.lang.Character.digit()\r
 120          * (which checks Nd).\r
 121          *\r
 122          * This was not true in Unicode 3.2 and earlier.\r
 123          * Unicode 4.0 fixed discrepancies.\r
 124          * Unicode 4.0.1 re-introduced problems in this area due to an\r
 125          * unintentionally incomplete last-minute change.\r
 126          */\r
 127         String digitsPattern = "[:Nd:]";\r
 128         String decimalValuesPattern = "[:Numeric_Type=Decimal:]";\r
 129 \r
 130         UnicodeSet digits, decimalValues;\r
 131 \r
 132         digits= new UnicodeSet(digitsPattern);\r
 133         decimalValues=new UnicodeSet(decimalValuesPattern);\r
 134 \r
 135 \r
 136         compareUSets(digits, decimalValues, "[:Nd:]", "[:Numeric_Type=Decimal:]", true);\r
 137 \r
 138 \r
 139     }\r
 140 \r
 141     /**\r
 142     * Tests for space determination in UCharacter\r
 143     */\r
 144     public void TestSpaces()\r
 145     {\r
 146         int spaces[] = {0x0020, 0x00a0, 0x2000, 0x2001, 0x2005};\r
 147         int nonspaces[] = {0x0061, 0x0062, 0x0063, 0x0064, 0x0074};\r
 148         int whitespaces[] = {0x2008, 0x2009, 0x200a, 0x001c, 0x000c /* ,0x200b */}; // 0x200b was "Zs" in Unicode 4.0, but it is "Cf" in Unicode 4.1\r
 149         int nonwhitespaces[] = {0x0061, 0x0062, 0x003c, 0x0028, 0x003f, 0x00a0, 0x2007, 0x202f, 0xfefe, 0x200b};\r
 150 \r
 151         int size = spaces.length;\r
 152         for (int i = 0; i < size; i ++)\r
 153         {\r
 154             if (!UCharacter.isSpaceChar(spaces[i]))\r
 155             {\r
 156                 errln("FAIL \\u" + hex(spaces[i]) +\r
 157                     " expected to be a space character");\r
 158                 break;\r
 159             }\r
 160 \r
 161             if (UCharacter.isSpaceChar(nonspaces[i]))\r
 162             {\r
 163                 errln("FAIL \\u" + hex(nonspaces[i]) +\r
 164                 " expected not to be space character");\r
 165                 break;\r
 166             }\r
 167 \r
 168             if (!UCharacter.isWhitespace(whitespaces[i]))\r
 169             {\r
 170                 errln("FAIL \\u" + hex(whitespaces[i]) +\r
 171                         " expected to be a white space character");\r
 172                 break;\r
 173             }\r
 174             if (UCharacter.isWhitespace(nonwhitespaces[i]))\r
 175             {\r
 176                 errln("FAIL \\u" + hex(nonwhitespaces[i]) +\r
 177                             " expected not to be a space character");\r
 178                 break;\r
 179             }\r
 180             logln("Ok    \\u" + hex(spaces[i]) + " and \\u" +\r
 181                   hex(nonspaces[i]) + " and \\u" + hex(whitespaces[i]) +\r
 182                   " and \\u" + hex(nonwhitespaces[i]));\r
 183         }\r
 184 \r
 185         int rulewhitespace[] = {0x9, 0xd, 0x20, 0x85,\r
 186                                 0x200e, 0x200f, 0x2028, 0x2029};\r
 187         int nonrulewhitespace[] = {0x8, 0xe, 0x21, 0x86, 0xa0, 0xa1,\r
 188                                    0x1680, 0x1681, 0x180e, 0x180f,\r
 189                                    0x1FFF, 0x2000, 0x200a, 0x200b,\r
 190                                    0x2010, 0x202f, 0x2030, 0x205f,\r
 191                                    0x2060, 0x3000, 0x3001};\r
 192         for (int i = 0; i < rulewhitespace.length; i ++) {\r
 193             if (!UCharacterProperty.isRuleWhiteSpace(rulewhitespace[i])) {\r
 194                 errln("\\u" + Utility.hex(rulewhitespace[i], 4)\r
 195                       + " expected to be a rule white space");\r
 196             }\r
 197         }\r
 198         for (int i = 0; i < nonrulewhitespace.length; i ++) {\r
 199             if (UCharacterProperty.isRuleWhiteSpace(nonrulewhitespace[i])) {\r
 200                 errln("\\u" + Utility.hex(nonrulewhitespace[i], 4)\r
 201                       + " expected to be a non rule white space");\r
 202             }\r
 203         }\r
 204 \r
 205         // TODO: propose public API for constants like uchar.h's U_GC_*_MASK\r
 206         // (http://bugs.icu-project.org/trac/ticket/7461)\r
 207         int GC_Z_MASK =\r
 208             (1 << UCharacter.SPACE_SEPARATOR) |\r
 209             (1 << UCharacter.LINE_SEPARATOR) |\r
 210             (1 << UCharacter.PARAGRAPH_SEPARATOR);\r
 211 \r
 212         // UCharacter.isWhitespace(c) should be the same as Character.isWhitespace().\r
 213         // This uses logln() because Character.isWhitespace() differs between Java versions, thus\r
 214         // it is not necessarily an error if there is a difference between\r
 215         // particular Java and ICU versions.\r
 216         // However, you need to run tests with -v to see the output.\r
 217         // Also note that, at least as of Unicode 5.2,\r
 218         // there are no supplementary white space characters.\r
 219         for (int c = 0; c <= 0xffff; ++c) {\r
 220             boolean j = Character.isWhitespace(c);\r
 221             boolean i = UCharacter.isWhitespace(c);\r
 222             boolean u = UCharacter.isUWhiteSpace(c);\r
 223             boolean z = (UCharacter.getIntPropertyValue(c, UProperty.GENERAL_CATEGORY_MASK) &\r
 224                          GC_Z_MASK) != 0;\r
 225             if (j != i) {\r
 226                 logln(String.format(\r
 227                     "isWhitespace(U+%04x) difference: JDK %5b ICU %5b Unicode WS %5b Z Separator %5b",\r
 228                     c, j, i, u, z));\r
 229             } else if (j || i || u || z) {\r
 230                 logln(String.format(\r
 231                     "isWhitespace(U+%04x) FYI:        JDK %5b ICU %5b Unicode WS %5b Z Separator %5b",\r
 232                     c, j, i, u, z));\r
 233             }\r
 234         }\r
 235         for (char c = 0; c <= 0xff; ++c) {\r
 236             boolean j = Character.isSpace(c);\r
 237             boolean i = UCharacter.isSpace(c);\r
 238             boolean z = (UCharacter.getIntPropertyValue(c, UProperty.GENERAL_CATEGORY_MASK) &\r
 239                          GC_Z_MASK) != 0;\r
 240             if (j != i) {\r
 241                 logln(String.format(\r
 242                     "isSpace(U+%04x) difference: JDK %5b ICU %5b Z Separator %5b",\r
 243                     (int)c, j, i, z));\r
 244             } else if (j || i || z) {\r
 245                 logln(String.format(\r
 246                     "isSpace(U+%04x) FYI:        JDK %5b ICU %5b Z Separator %5b",\r
 247                     (int)c, j, i, z));\r
 248             }\r
 249         }\r
 250     }\r
 251 \r
 252     /**\r
 253     * Tests for defined and undefined characters\r
 254     */\r
 255     public void TestDefined()\r
 256     {\r
 257         int undefined[] = {0xfff1, 0xfff7, 0xfa6e};\r
 258         int defined[] = {0x523E, 0x004f88, 0x00fffd};\r
 259 \r
 260         int size = undefined.length;\r
 261         for (int i = 0; i < size; i ++)\r
 262         {\r
 263             if (UCharacter.isDefined(undefined[i]))\r
 264             {\r
 265                 errln("FAIL \\u" + hex(undefined[i]) +\r
 266                             " expected not to be defined");\r
 267                 break;\r
 268             }\r
 269             if (!UCharacter.isDefined(defined[i]))\r
 270             {\r
 271                 errln("FAIL \\u" + hex(defined[i]) + " expected defined");\r
 272                 break;\r
 273             }\r
 274         }\r
 275     }\r
 276 \r
 277     /**\r
 278     * Tests for base characters and their cellwidth\r
 279     */\r
 280     public void TestBase()\r
 281     {\r
 282         int base[] = {0x0061, 0x000031, 0x0003d2};\r
 283         int nonbase[] = {0x002B, 0x000020, 0x00203B};\r
 284         int size = base.length;\r
 285         for (int i = 0; i < size; i ++)\r
 286         {\r
 287             if (UCharacter.isBaseForm(nonbase[i]))\r
 288             {\r
 289                 errln("FAIL \\u" + hex(nonbase[i]) +\r
 290                             " expected not to be a base character");\r
 291                 break;\r
 292             }\r
 293             if (!UCharacter.isBaseForm(base[i]))\r
 294             {\r
 295                 errln("FAIL \\u" + hex(base[i]) +\r
 296                       " expected to be a base character");\r
 297                 break;\r
 298             }\r
 299         }\r
 300     }\r
 301 \r
 302     /**\r
 303     * Tests for digit characters\r
 304     */\r
 305     public void TestDigits()\r
 306     {\r
 307         int digits[] = {0x0030, 0x000662, 0x000F23, 0x000ED5, 0x002160};\r
 308 \r
 309         //special characters not in the properties table\r
 310         int digits2[] = {0x3007, 0x004e00, 0x004e8c, 0x004e09, 0x0056d8,\r
 311                          0x004e94, 0x00516d, 0x4e03, 0x00516b, 0x004e5d};\r
 312         int nondigits[] = {0x0010, 0x000041, 0x000122, 0x0068FE};\r
 313 \r
 314         int digitvalues[] = {0, 2, 3, 5, 1};\r
 315         int digitvalues2[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};\r
 316 \r
 317         int size  = digits.length;\r
 318         for (int i = 0; i < size; i ++) {\r
 319             if (UCharacter.isDigit(digits[i]) &&\r
 320                 UCharacter.digit(digits[i]) != digitvalues[i])\r
 321             {\r
 322                 errln("FAIL \\u" + hex(digits[i]) +\r
 323                         " expected digit with value " + digitvalues[i]);\r
 324                 break;\r
 325             }\r
 326         }\r
 327         size = nondigits.length;\r
 328         for (int i = 0; i < size; i ++)\r
 329             if (UCharacter.isDigit(nondigits[i]))\r
 330             {\r
 331                 errln("FAIL \\u" + hex(nondigits[i]) + " expected nondigit");\r
 332                 break;\r
 333             }\r
 334 \r
 335         size = digits2.length;\r
 336         for (int i = 0; i < 10; i ++) {\r
 337             if (UCharacter.isDigit(digits2[i]) &&\r
 338                 UCharacter.digit(digits2[i]) != digitvalues2[i])\r
 339             {\r
 340                 errln("FAIL \\u" + hex(digits2[i]) +\r
 341                     " expected digit with value " + digitvalues2[i]);\r
 342                 break;\r
 343             }\r
 344         }\r
 345     }\r
 346 \r
 347     /**\r
 348     *  Tests for numeric characters\r
 349     */\r
 350     public void TestNumeric()\r
 351     {\r
 352         if (UCharacter.getNumericValue(0x00BC) != -2) {\r
 353             errln("Numeric value of 0x00BC expected to be -2");\r
 354         }\r
 355 \r
 356         for (int i = '0'; i < '9'; i ++) {\r
 357             int n1 = UCharacter.getNumericValue(i);\r
 358             double n2 = UCharacter.getUnicodeNumericValue(i);\r
 359             if (n1 != n2 ||  n1 != (i - '0')) {\r
 360                 errln("Numeric value of " + (char)i + " expected to be " +\r
 361                       (i - '0'));\r
 362             }\r
 363         }\r
 364         for (int i = 'A'; i < 'F'; i ++) {\r
 365             int n1 = UCharacter.getNumericValue(i);\r
 366             double n2 = UCharacter.getUnicodeNumericValue(i);\r
 367             if (n2 != UCharacter.NO_NUMERIC_VALUE ||  n1 != (i - 'A' + 10)) {\r
 368                 errln("Numeric value of " + (char)i + " expected to be " +\r
 369                       (i - 'A' + 10));\r
 370             }\r
 371         }\r
 372         for (int i = 0xFF21; i < 0xFF26; i ++) {\r
 373             // testing full wideth latin characters A-F\r
 374             int n1 = UCharacter.getNumericValue(i);\r
 375             double n2 = UCharacter.getUnicodeNumericValue(i);\r
 376             if (n2 != UCharacter.NO_NUMERIC_VALUE ||  n1 != (i - 0xFF21 + 10)) {\r
 377                 errln("Numeric value of " + (char)i + " expected to be " +\r
 378                       (i - 0xFF21 + 10));\r
 379             }\r
 380         }\r
 381         // testing han numbers\r
 382         int han[] = {0x96f6, 0, 0x58f9, 1, 0x8cb3, 2, 0x53c3, 3,\r
 383                      0x8086, 4, 0x4f0d, 5, 0x9678, 6, 0x67d2, 7,\r
 384                      0x634c, 8, 0x7396, 9, 0x5341, 10, 0x62fe, 10,\r
 385                      0x767e, 100, 0x4f70, 100, 0x5343, 1000, 0x4edf, 1000,\r
 386                      0x824c, 10000, 0x5104, 100000000};\r
 387         for (int i = 0; i < han.length; i += 2) {\r
 388             if (UCharacter.getHanNumericValue(han[i]) != han[i + 1]) {\r
 389                 errln("Numeric value of \\u" +\r
 390                       Integer.toHexString(han[i]) + " expected to be " +\r
 391                       han[i + 1]);\r
 392             }\r
 393         }\r
 394     }\r
 395 \r
 396     /**\r
 397     * Tests for version\r
 398     */\r
 399     public void TestVersion()\r
 400     {\r
 401         if (!UCharacter.getUnicodeVersion().equals(VERSION_))\r
 402             errln("FAIL expected: " + VERSION_ + "got: " + UCharacter.getUnicodeVersion());\r
 403     }\r
 404 \r
 405     /**\r
 406     * Tests for control characters\r
 407     */\r
 408     public void TestISOControl()\r
 409     {\r
 410         int control[] = {0x001b, 0x000097, 0x000082};\r
 411         int noncontrol[] = {0x61, 0x000031, 0x0000e2};\r
 412 \r
 413         int size = control.length;\r
 414         for (int i = 0; i < size; i ++)\r
 415         {\r
 416             if (!UCharacter.isISOControl(control[i]))\r
 417             {\r
 418                 errln("FAIL 0x" + Integer.toHexString(control[i]) +\r
 419                         " expected to be a control character");\r
 420                 break;\r
 421             }\r
 422             if (UCharacter.isISOControl(noncontrol[i]))\r
 423             {\r
 424                 errln("FAIL 0x" + Integer.toHexString(noncontrol[i]) +\r
 425                         " expected to be not a control character");\r
 426                 break;\r
 427             }\r
 428 \r
 429             logln("Ok    0x" + Integer.toHexString(control[i]) + " and 0x" +\r
 430                     Integer.toHexString(noncontrol[i]));\r
 431         }\r
 432     }\r
 433 \r
 434     /**\r
 435      * Test Supplementary\r
 436      */\r
 437     public void TestSupplementary()\r
 438     {\r
 439         for (int i = 0; i < 0x10000; i ++) {\r
 440             if (UCharacter.isSupplementary(i)) {\r
 441                 errln("Codepoint \\u" + Integer.toHexString(i) +\r
 442                       " is not supplementary");\r
 443             }\r
 444         }\r
 445         for (int i = 0x10000; i < 0x10FFFF; i ++) {\r
 446             if (!UCharacter.isSupplementary(i)) {\r
 447                 errln("Codepoint \\u" + Integer.toHexString(i) +\r
 448                       " is supplementary");\r
 449             }\r
 450         }\r
 451     }\r
 452 \r
 453     /**\r
 454      * Test mirroring\r
 455      */\r
 456     public void TestMirror()\r
 457     {\r
 458         if (!(UCharacter.isMirrored(0x28) && UCharacter.isMirrored(0xbb) &&\r
 459               UCharacter.isMirrored(0x2045) && UCharacter.isMirrored(0x232a)\r
 460               && !UCharacter.isMirrored(0x27) &&\r
 461               !UCharacter.isMirrored(0x61) && !UCharacter.isMirrored(0x284)\r
 462               && !UCharacter.isMirrored(0x3400))) {\r
 463             errln("isMirrored() does not work correctly");\r
 464         }\r
 465 \r
 466         if (!(UCharacter.getMirror(0x3c) == 0x3e &&\r
 467               UCharacter.getMirror(0x5d) == 0x5b &&\r
 468               UCharacter.getMirror(0x208d) == 0x208e &&\r
 469               UCharacter.getMirror(0x3017) == 0x3016 &&\r
 470 \r
 471               UCharacter.getMirror(0xbb) == 0xab &&\r
 472               UCharacter.getMirror(0x2215) == 0x29F5 &&\r
 473               UCharacter.getMirror(0x29F5) == 0x2215 && /* large delta between the code points */\r
 474 \r
 475               UCharacter.getMirror(0x2e) == 0x2e &&\r
 476               UCharacter.getMirror(0x6f3) == 0x6f3 &&\r
 477               UCharacter.getMirror(0x301c) == 0x301c &&\r
 478               UCharacter.getMirror(0xa4ab) == 0xa4ab &&\r
 479 \r
 480               /* see Unicode Corrigendum #6 at http://www.unicode.org/versions/corrigendum6.html */\r
 481               UCharacter.getMirror(0x2018) == 0x2018 &&\r
 482               UCharacter.getMirror(0x201b) == 0x201b &&\r
 483               UCharacter.getMirror(0x301d) == 0x301d)) {\r
 484             errln("getMirror() does not work correctly");\r
 485         }\r
 486 \r
 487         /* verify that Bidi_Mirroring_Glyph roundtrips */\r
 488         UnicodeSet set=new UnicodeSet("[:Bidi_Mirrored:]");\r
 489         UnicodeSetIterator iter=new UnicodeSetIterator(set);\r
 490         int start, end, c2, c3;\r
 491         while(iter.nextRange() && (start=iter.codepoint)>=0) {\r
 492             end=iter.codepointEnd;\r
 493             do {\r
 494                 c2=UCharacter.getMirror(start);\r
 495                 c3=UCharacter.getMirror(c2);\r
 496                 if(c3!=start) {\r
 497                     errln("getMirror() does not roundtrip: U+"+hex(start)+"->U+"+hex(c2)+"->U+"+hex(c3));\r
 498                 }\r
 499             } while(++start<=end);\r
 500         }\r
 501 \r
 502         // verify that Unicode Corrigendum #6 reverts mirrored status of the following\r
 503         if (UCharacter.isMirrored(0x2018) ||\r
 504             UCharacter.isMirrored(0x201d) ||\r
 505             UCharacter.isMirrored(0x201f) ||\r
 506             UCharacter.isMirrored(0x301e)) {\r
 507             errln("Unicode Corrigendum #6 conflict, one or more of 2018/201d/201f/301e has mirrored property");\r
 508         }\r
 509     }\r
 510 \r
 511     /**\r
 512     * Tests for printable characters\r
 513     */\r
 514     public void TestPrint()\r
 515     {\r
 516         int printable[] = {0x0042, 0x00005f, 0x002014};\r
 517         int nonprintable[] = {0x200c, 0x00009f, 0x00001b};\r
 518 \r
 519         int size = printable.length;\r
 520         for (int i = 0; i < size; i ++)\r
 521         {\r
 522             if (!UCharacter.isPrintable(printable[i]))\r
 523             {\r
 524                 errln("FAIL \\u" + hex(printable[i]) +\r
 525                     " expected to be a printable character");\r
 526                 break;\r
 527             }\r
 528             if (UCharacter.isPrintable(nonprintable[i]))\r
 529             {\r
 530                 errln("FAIL \\u" + hex(nonprintable[i]) +\r
 531                         " expected not to be a printable character");\r
 532                 break;\r
 533             }\r
 534             logln("Ok    \\u" + hex(printable[i]) + " and \\u" +\r
 535                     hex(nonprintable[i]));\r
 536         }\r
 537 \r
 538         // test all ISO 8 controls\r
 539         for (int ch = 0; ch <= 0x9f; ++ ch) {\r
 540             if (ch == 0x20) {\r
 541                 // skip ASCII graphic characters and continue with DEL\r
 542                 ch = 0x7f;\r
 543             }\r
 544             if (UCharacter.isPrintable(ch)) {\r
 545                 errln("Fail \\u" + hex(ch) +\r
 546                     " is a ISO 8 control character hence not printable\n");\r
 547             }\r
 548         }\r
 549 \r
 550         /* test all Latin-1 graphic characters */\r
 551         for (int ch = 0x20; ch <= 0xff; ++ ch) {\r
 552             if (ch == 0x7f) {\r
 553                 ch = 0xa0;\r
 554             }\r
 555             if (!UCharacter.isPrintable(ch)\r
 556                 && ch != 0x00AD/* Unicode 4.0 changed the defintion of soft hyphen to be a Cf*/) {\r
 557                 errln("Fail \\u" + hex(ch) +\r
 558                       " is a Latin-1 graphic character\n");\r
 559             }\r
 560         }\r
 561     }\r
 562 \r
 563     /**\r
 564     * Testing for identifier characters\r
 565     */\r
 566     public void TestIdentifier()\r
 567     {\r
 568         int unicodeidstart[] = {0x0250, 0x0000e2, 0x000061};\r
 569         int nonunicodeidstart[] = {0x2000, 0x00000a, 0x002019};\r
 570         int unicodeidpart[] = {0x005f, 0x000032, 0x000045};\r
 571         int nonunicodeidpart[] = {0x2030, 0x0000a3, 0x000020};\r
 572         int idignore[] = {0x0006, 0x0010, 0x206b};\r
 573         int nonidignore[] = {0x0075, 0x0000a3, 0x000061};\r
 574 \r
 575         int size = unicodeidstart.length;\r
 576         for (int i = 0; i < size; i ++)\r
 577         {\r
 578             if (!UCharacter.isUnicodeIdentifierStart(unicodeidstart[i]))\r
 579             {\r
 580                 errln("FAIL \\u" + hex(unicodeidstart[i]) +\r
 581                     " expected to be a unicode identifier start character");\r
 582                 break;\r
 583             }\r
 584             if (UCharacter.isUnicodeIdentifierStart(nonunicodeidstart[i]))\r
 585             {\r
 586                 errln("FAIL \\u" + hex(nonunicodeidstart[i]) +\r
 587                         " expected not to be a unicode identifier start " +\r
 588                         "character");\r
 589                 break;\r
 590             }\r
 591             if (!UCharacter.isUnicodeIdentifierPart(unicodeidpart[i]))\r
 592             {\r
 593                 errln("FAIL \\u" + hex(unicodeidpart[i]) +\r
 594                     " expected to be a unicode identifier part character");\r
 595                 break;\r
 596             }\r
 597             if (UCharacter.isUnicodeIdentifierPart(nonunicodeidpart[i]))\r
 598             {\r
 599                 errln("FAIL \\u" + hex(nonunicodeidpart[i]) +\r
 600                         " expected not to be a unicode identifier part " +\r
 601                         "character");\r
 602                 break;\r
 603             }\r
 604             if (!UCharacter.isIdentifierIgnorable(idignore[i]))\r
 605             {\r
 606                 errln("FAIL \\u" + hex(idignore[i]) +\r
 607                         " expected to be a ignorable unicode character");\r
 608                 break;\r
 609             }\r
 610             if (UCharacter.isIdentifierIgnorable(nonidignore[i]))\r
 611             {\r
 612                 errln("FAIL \\u" + hex(nonidignore[i]) +\r
 613                     " expected not to be a ignorable unicode character");\r
 614                 break;\r
 615             }\r
 616             logln("Ok    \\u" + hex(unicodeidstart[i]) + " and \\u" +\r
 617                     hex(nonunicodeidstart[i]) + " and \\u" +\r
 618                     hex(unicodeidpart[i]) + " and \\u" +\r
 619                     hex(nonunicodeidpart[i]) + " and \\u" +\r
 620                     hex(idignore[i]) + " and \\u" + hex(nonidignore[i]));\r
 621         }\r
 622     }\r
 623 \r
 624     /**\r
 625     * Tests for the character types, direction.<br>\r
 626     * This method reads in UnicodeData.txt file for testing purposes. A\r
 627     * default path is provided relative to the src path, however the user\r
 628     * could set a system property to change the directory path.<br>\r
 629     * e.g. java -DUnicodeData="data_directory_path"\r
 630     * com.ibm.icu.dev.test.lang.UCharacterTest\r
 631     */\r
 632     public void TestUnicodeData()\r
 633     {\r
 634         // this is the 2 char category types used in the UnicodeData file\r
 635         final String TYPE =\r
 636             "LuLlLtLmLoMnMeMcNdNlNoZsZlZpCcCfCoCsPdPsPePcPoSmScSkSoPiPf";\r
 637 \r
 638         // directory types used in the UnicodeData file\r
 639         // padded by spaces to make each type size 4\r
 640         final String DIR =\r
 641             "L   R   EN  ES  ET  AN  CS  B   S   WS  ON  LRE LRO AL  RLE RLO PDF NSM BN  ";\r
 642 \r
 643         final int LASTUNICODECHAR = 0xFFFD;\r
 644         int ch = 0,\r
 645             index = 0,\r
 646             type = 0,\r
 647             dir = 0;\r
 648 \r
 649         try\r
 650         {\r
 651             BufferedReader input = TestUtil.getDataReader(\r
 652                                                 "unicode/UnicodeData.txt");\r
 653             int numErrors = 0;\r
 654 \r
 655             while (ch != LASTUNICODECHAR)\r
 656             {\r
 657                 String s = input.readLine();\r
 658                 if(s.length()<4 || s.startsWith("#")) {\r
 659                     continue;\r
 660                 }\r
 661                 // geting the unicode character, its type and its direction\r
 662                 ch = Integer.parseInt(s.substring(0, 4), 16);\r
 663                 index = s.indexOf(';', 5);\r
 664                 String t = s.substring(index + 1, index + 3);\r
 665                 index += 4;\r
 666                 int oldindex = index;\r
 667                 index = s.indexOf(';', index);\r
 668                 int cc = Integer.parseInt(s.substring(oldindex, index));\r
 669                 oldindex = index + 1;\r
 670                 index = s.indexOf(';', oldindex);\r
 671                 String d = s.substring(oldindex, index);\r
 672 \r
 673                 for (int i = 0; i < 6; i ++) {\r
 674                     index = s.indexOf(';', index + 1);\r
 675                     // skipping to the 11th field\r
 676                 }\r
 677                 // iso comment\r
 678                 oldindex = index + 1;\r
 679                 index = s.indexOf(';', oldindex);\r
 680                 String isocomment = s.substring(oldindex, index);\r
 681                 // uppercase\r
 682                 oldindex = index + 1;\r
 683                 index = s.indexOf(';', oldindex);\r
 684                 String upper = s.substring(oldindex, index);\r
 685                 // lowercase\r
 686                 oldindex = index + 1;\r
 687                 index = s.indexOf(';', oldindex);\r
 688                 String lower = s.substring(oldindex, index);\r
 689                 // titlecase last element\r
 690                 oldindex = index + 1;\r
 691                 String title = s.substring(oldindex);\r
 692 \r
 693                 // testing the category\r
 694                 // we override the general category of some control\r
 695                 // characters\r
 696                 type = TYPE.indexOf(t);\r
 697                 if (type < 0)\r
 698                     type = 0;\r
 699                 else\r
 700                     type = (type >> 1) + 1;\r
 701                 if (UCharacter.getType(ch) != type)\r
 702                 {\r
 703                     errln("FAIL \\u" + hex(ch) + " expected type " +\r
 704                             type);\r
 705                     break;\r
 706                 }\r
 707 \r
 708                 if (UCharacter.getIntPropertyValue(ch,\r
 709                            UProperty.GENERAL_CATEGORY_MASK) != (1 << type)) {\r
 710                     errln("error: getIntPropertyValue(\\u" +\r
 711                           Integer.toHexString(ch) +\r
 712                           ", UProperty.GENERAL_CATEGORY_MASK) != " +\r
 713                           "getMask(getType(ch))");\r
 714                 }\r
 715 \r
 716                 // testing combining class\r
 717                 if (UCharacter.getCombiningClass(ch) != cc)\r
 718                 {\r
 719                     errln("FAIL \\u" + hex(ch) + " expected combining " +\r
 720                             "class " + cc);\r
 721                     break;\r
 722                 }\r
 723 \r
 724                 // testing the direction\r
 725                 if (d.length() == 1)\r
 726                     d = d + "   ";\r
 727 \r
 728                 dir = DIR.indexOf(d) >> 2;\r
 729                 if (UCharacter.getDirection(ch) != dir)\r
 730                 {\r
 731                     errln("FAIL \\u" + hex(ch) +\r
 732                         " expected direction " + dir + " but got " +\r
 733               UCharacter.getDirection(ch));\r
 734                     break;\r
 735                 }\r
 736 \r
 737                 byte bdir = (byte)dir;\r
 738                 if (UCharacter.getDirectionality(ch) != bdir)\r
 739                 {\r
 740                     errln("FAIL \\u" + hex(ch) +\r
 741                         " expected directionality " + bdir + " but got " +\r
 742               UCharacter.getDirectionality(ch));\r
 743                     break;\r
 744                 }\r
 745 \r
 746                 // testing iso comment\r
 747                 try{\r
 748                     String comment = UCharacter.getISOComment(ch);\r
 749                     if (comment == null) {\r
 750                         comment = "";\r
 751                     }\r
 752                     if (!comment.equals(isocomment)) {\r
 753                         errln("FAIL \\u" + hex(ch) +\r
 754                             " expected iso comment " + isocomment);\r
 755                         break;\r
 756                     }\r
 757                 }catch(Exception e){\r
 758                     if(e.getMessage().indexOf("unames.icu") >= 0){\r
 759                         numErrors++;\r
 760                     }else{\r
 761                         throw e;\r
 762                     }\r
 763                 }\r
 764 \r
 765                 int tempchar = ch;\r
 766                 if (upper.length() > 0) {\r
 767                     tempchar = Integer.parseInt(upper, 16);\r
 768                 }\r
 769                 if (UCharacter.toUpperCase(ch) != tempchar) {\r
 770                     errln("FAIL \\u" + Utility.hex(ch, 4)\r
 771                             + " expected uppercase \\u"\r
 772                             + Utility.hex(tempchar, 4));\r
 773                     break;\r
 774                 }\r
 775                 tempchar = ch;\r
 776                 if (lower.length() > 0) {\r
 777                     tempchar = Integer.parseInt(lower, 16);\r
 778                 }\r
 779                 if (UCharacter.toLowerCase(ch) != tempchar) {\r
 780                     errln("FAIL \\u" + Utility.hex(ch, 4)\r
 781                             + " expected lowercase \\u"\r
 782                             + Utility.hex(tempchar, 4));\r
 783                     break;\r
 784                 }\r
 785                 tempchar = ch;\r
 786                 if (title.length() > 0) {\r
 787                     tempchar = Integer.parseInt(title, 16);\r
 788                 }\r
 789                 if (UCharacter.toTitleCase(ch) != tempchar) {\r
 790                     errln("FAIL \\u" + Utility.hex(ch, 4)\r
 791                             + " expected titlecase \\u"\r
 792                             + Utility.hex(tempchar, 4));\r
 793                     break;\r
 794                 }\r
 795             }\r
 796             input.close();\r
 797             if(numErrors > 0){\r
 798                 warnln("Could not find unames.icu");\r
 799             }\r
 800         }\r
 801         catch (Exception e)\r
 802         {\r
 803             e.printStackTrace();\r
 804         }\r
 805 \r
 806 \r
 807         if (UCharacter.UnicodeBlock.of(0x0041)\r
 808                                         != UCharacter.UnicodeBlock.BASIC_LATIN\r
 809             || UCharacter.getIntPropertyValue(0x41, UProperty.BLOCK)\r
 810                               != UCharacter.UnicodeBlock.BASIC_LATIN.getID()) {\r
 811             errln("UCharacter.UnicodeBlock.of(\\u0041) property failed! "\r
 812                     + "Expected : "\r
 813                     + UCharacter.UnicodeBlock.BASIC_LATIN.getID() + " got "\r
 814                     + UCharacter.UnicodeBlock.of(0x0041));\r
 815         }\r
 816 \r
 817         // sanity check on repeated properties\r
 818         for (ch = 0xfffe; ch <= 0x10ffff;) {\r
 819             type = UCharacter.getType(ch);\r
 820             if (UCharacter.getIntPropertyValue(ch,\r
 821                                                UProperty.GENERAL_CATEGORY_MASK)\r
 822                 != (1 << type)) {\r
 823                 errln("error: UCharacter.getIntPropertyValue(\\u"\r
 824                       + Integer.toHexString(ch)\r
 825                       + ", UProperty.GENERAL_CATEGORY_MASK) != "\r
 826                       + "getMask(getType())");\r
 827             }\r
 828             if (type != UCharacterCategory.UNASSIGNED) {\r
 829                 errln("error: UCharacter.getType(\\u" + Utility.hex(ch, 4)\r
 830                         + " != UCharacterCategory.UNASSIGNED (returns "\r
 831                         + UCharacterCategory.toString(UCharacter.getType(ch))\r
 832                         + ")");\r
 833             }\r
 834             if ((ch & 0xffff) == 0xfffe) {\r
 835                 ++ ch;\r
 836             }\r
 837             else {\r
 838                 ch += 0xffff;\r
 839             }\r
 840         }\r
 841 \r
 842         // test that PUA is not "unassigned"\r
 843         for(ch = 0xe000; ch <= 0x10fffd;) {\r
 844             type = UCharacter.getType(ch);\r
 845             if (UCharacter.getIntPropertyValue(ch,\r
 846                                                UProperty.GENERAL_CATEGORY_MASK)\r
 847                 != (1 << type)) {\r
 848                 errln("error: UCharacter.getIntPropertyValue(\\u"\r
 849                       + Integer.toHexString(ch)\r
 850                       + ", UProperty.GENERAL_CATEGORY_MASK) != "\r
 851                       + "getMask(getType())");\r
 852             }\r
 853 \r
 854             if (type == UCharacterCategory.UNASSIGNED) {\r
 855                 errln("error: UCharacter.getType(\\u"\r
 856                         + Utility.hex(ch, 4)\r
 857                         + ") == UCharacterCategory.UNASSIGNED");\r
 858             }\r
 859             else if (type != UCharacterCategory.PRIVATE_USE) {\r
 860                 logln("PUA override: UCharacter.getType(\\u"\r
 861                       + Utility.hex(ch, 4) + ")=" + type);\r
 862             }\r
 863             if (ch == 0xf8ff) {\r
 864                 ch = 0xf0000;\r
 865             }\r
 866             else if (ch == 0xffffd) {\r
 867                 ch = 0x100000;\r
 868             }\r
 869             else {\r
 870                 ++ ch;\r
 871             }\r
 872         }\r
 873     }\r
 874 \r
 875 \r
 876     /**\r
 877     * Test for the character names\r
 878     */\r
 879     public void TestNames()\r
 880     {\r
 881         try{\r
 882             int length = UCharacterName.INSTANCE.getMaxCharNameLength();\r
 883             if (length < 83) { // Unicode 3.2 max char name length\r
 884                errln("getMaxCharNameLength()=" + length + " is too short");\r
 885             }\r
 886             // ### TODO same tests for max ISO comment length as for max name length\r
 887 \r
 888             int c[] = {0x0061,                //LATIN SMALL LETTER A\r
 889                        0x000284,              //LATIN SMALL LETTER DOTLESS J WITH STROKE AND HOOK\r
 890                        0x003401,              //CJK UNIFIED IDEOGRAPH-3401\r
 891                        0x007fed,              //CJK UNIFIED IDEOGRAPH-7FED\r
 892                        0x00ac00,              //HANGUL SYLLABLE GA\r
 893                        0x00d7a3,              //HANGUL SYLLABLE HIH\r
 894                        0x00d800, 0x00dc00,    //LINEAR B SYLLABLE B008 A\r
 895                        0xff08,                //FULLWIDTH LEFT PARENTHESIS\r
 896                        0x00ffe5,              //FULLWIDTH YEN SIGN\r
 897                        0x00ffff,              //null\r
 898                        0x0023456              //CJK UNIFIED IDEOGRAPH-23456\r
 899                        };\r
 900             String name[] = {\r
 901                              "LATIN SMALL LETTER A",\r
 902                              "LATIN SMALL LETTER DOTLESS J WITH STROKE AND HOOK",\r
 903                              "CJK UNIFIED IDEOGRAPH-3401",\r
 904                              "CJK UNIFIED IDEOGRAPH-7FED",\r
 905                              "HANGUL SYLLABLE GA",\r
 906                              "HANGUL SYLLABLE HIH",\r
 907                              "",\r
 908                              "",\r
 909                              "FULLWIDTH LEFT PARENTHESIS",\r
 910                              "FULLWIDTH YEN SIGN",\r
 911                              "",\r
 912                              "CJK UNIFIED IDEOGRAPH-23456"\r
 913                              };\r
 914             String oldname[] = {"", "LATIN SMALL LETTER DOTLESS J BAR HOOK", "",\r
 915                             "",\r
 916                             "", "", "", "", "FULLWIDTH OPENING PARENTHESIS", "",\r
 917                             "", ""};\r
 918             String extendedname[] = {"LATIN SMALL LETTER A",\r
 919                                  "LATIN SMALL LETTER DOTLESS J WITH STROKE AND HOOK",\r
 920                                  "CJK UNIFIED IDEOGRAPH-3401",\r
 921                                  "CJK UNIFIED IDEOGRAPH-7FED",\r
 922                                  "HANGUL SYLLABLE GA",\r
 923                                  "HANGUL SYLLABLE HIH",\r
 924                                  "<lead surrogate-D800>",\r
 925                                  "<trail surrogate-DC00>",\r
 926                                  "FULLWIDTH LEFT PARENTHESIS",\r
 927                                  "FULLWIDTH YEN SIGN",\r
 928                                  "<noncharacter-FFFF>",\r
 929                                  "CJK UNIFIED IDEOGRAPH-23456"};\r
 930 \r
 931             int size = c.length;\r
 932             String str;\r
 933             int uc;\r
 934 \r
 935             for (int i = 0; i < size; i ++)\r
 936             {\r
 937                 // modern Unicode character name\r
 938                 str = UCharacter.getName(c[i]);\r
 939                 if ((str == null && name[i].length() > 0) ||\r
 940                     (str != null && !str.equals(name[i])))\r
 941                 {\r
 942                     errln("FAIL \\u" + hex(c[i]) + " expected name " +\r
 943                             name[i]);\r
 944                     break;\r
 945                 }\r
 946 \r
 947                 // 1.0 Unicode character name\r
 948                 str = UCharacter.getName1_0(c[i]);\r
 949                 if ((str == null && oldname[i].length() > 0) ||\r
 950                     (str != null && !str.equals(oldname[i])))\r
 951                 {\r
 952                     errln("FAIL \\u" + hex(c[i]) + " expected 1.0 name " +\r
 953                             oldname[i]);\r
 954                     break;\r
 955                 }\r
 956 \r
 957                 // extended character name\r
 958                 str = UCharacter.getExtendedName(c[i]);\r
 959                 if (str == null || !str.equals(extendedname[i]))\r
 960                 {\r
 961                     errln("FAIL \\u" + hex(c[i]) + " expected extended name " +\r
 962                             extendedname[i]);\r
 963                     break;\r
 964                 }\r
 965 \r
 966                 // retrieving unicode character from modern name\r
 967                 uc = UCharacter.getCharFromName(name[i]);\r
 968                 if (uc != c[i] && name[i].length() != 0)\r
 969                 {\r
 970                     errln("FAIL " + name[i] + " expected character \\u" +\r
 971                           hex(c[i]));\r
 972                     break;\r
 973                 }\r
 974 \r
 975                 //retrieving unicode character from 1.0 name\r
 976                 uc = UCharacter.getCharFromName1_0(oldname[i]);\r
 977                 if (uc != c[i] && oldname[i].length() != 0)\r
 978                 {\r
 979                     errln("FAIL " + oldname[i] + " expected 1.0 character \\u" +\r
 980                           hex(c[i]));\r
 981                     break;\r
 982                 }\r
 983 \r
 984                 //retrieving unicode character from 1.0 name\r
 985                 uc = UCharacter.getCharFromExtendedName(extendedname[i]);\r
 986                 if (uc != c[i] && i != 0 && (i == 1 || i == 6))\r
 987                 {\r
 988                     errln("FAIL " + extendedname[i] +\r
 989                           " expected extended character \\u" + hex(c[i]));\r
 990                     break;\r
 991                 }\r
 992             }\r
 993 \r
 994             // test getName works with mixed-case names (new in 2.0)\r
 995             if (0x61 != UCharacter.getCharFromName("LATin smALl letTER A")) {\r
 996                 errln("FAIL: 'LATin smALl letTER A' should result in character "\r
 997                       + "U+0061");\r
 998             }\r
 999 \r
1000             if (getInclusion() >= 5) {\r
1001                 // extra testing different from icu\r
1002                 for (int i = UCharacter.MIN_VALUE; i < UCharacter.MAX_VALUE; i ++)\r
1003                 {\r
1004                     str = UCharacter.getName(i);\r
1005                     if (str != null && UCharacter.getCharFromName(str) != i)\r
1006                     {\r
1007                         errln("FAIL \\u" + hex(i) + " " + str  +\r
1008                                             " retrieval of name and vice versa" );\r
1009                         break;\r
1010                     }\r
1011                 }\r
1012             }\r
1013 \r
1014             // Test getCharNameCharacters\r
1015             if (getInclusion() >= 10) {\r
1016                 boolean map[] = new boolean[256];\r
1017 \r
1018                 UnicodeSet set = new UnicodeSet(1, 0); // empty set\r
1019                 UnicodeSet dumb = new UnicodeSet(1, 0); // empty set\r
1020 \r
1021                 // uprv_getCharNameCharacters() will likely return more lowercase\r
1022                 // letters than actual character names contain because\r
1023                 // it includes all the characters in lowercased names of\r
1024                 // general categories, for the full possible set of extended names.\r
1025                 UCharacterName.INSTANCE.getCharNameCharacters(set);\r
1026 \r
1027                 // build set the dumb (but sure-fire) way\r
1028                 Arrays.fill(map, false);\r
1029 \r
1030                 int maxLength = 0;\r
1031                 for (int cp = 0; cp < 0x110000; ++ cp) {\r
1032                     String n = UCharacter.getExtendedName(cp);\r
1033                     int len = n.length();\r
1034                     if (len > maxLength) {\r
1035                         maxLength = len;\r
1036                     }\r
1037 \r
1038                     for (int i = 0; i < len; ++ i) {\r
1039                         char ch = n.charAt(i);\r
1040                         if (!map[ch & 0xff]) {\r
1041                             dumb.add(ch);\r
1042                             map[ch & 0xff] = true;\r
1043                         }\r
1044                     }\r
1045                 }\r
1046 \r
1047                 length = UCharacterName.INSTANCE.getMaxCharNameLength();\r
1048                 if (length != maxLength) {\r
1049                     errln("getMaxCharNameLength()=" + length\r
1050                           + " differs from the maximum length " + maxLength\r
1051                           + " of all extended names");\r
1052                 }\r
1053 \r
1054                 // compare the sets.  Where is my uset_equals?!!\r
1055                 boolean ok = true;\r
1056                 for (int i = 0; i < 256; ++ i) {\r
1057                     if (set.contains(i) != dumb.contains(i)) {\r
1058                         if (0x61 <= i && i <= 0x7a // a-z\r
1059                             && set.contains(i) && !dumb.contains(i)) {\r
1060                             // ignore lowercase a-z that are in set but not in dumb\r
1061                             ok = true;\r
1062                         }\r
1063                         else {\r
1064                             ok = false;\r
1065                             break;\r
1066                         }\r
1067                     }\r
1068                 }\r
1069 \r
1070                 String pattern1 = set.toPattern(true);\r
1071                 String pattern2 = dumb.toPattern(true);\r
1072 \r
1073                 if (!ok) {\r
1074                     errln("FAIL: getCharNameCharacters() returned " + pattern1\r
1075                           + " expected " + pattern2\r
1076                           + " (too many lowercase a-z are ok)");\r
1077                 } else {\r
1078                     logln("Ok: getCharNameCharacters() returned " + pattern1);\r
1079                 }\r
1080             }\r
1081             // improve code coverage\r
1082            String expected = "LATIN SMALL LETTER A|LATIN SMALL LETTER DOTLESS J WITH STROKE AND HOOK|"+\r
1083                              "CJK UNIFIED IDEOGRAPH-3401|CJK UNIFIED IDEOGRAPH-7FED|HANGUL SYLLABLE GA|"+\r
1084                              "HANGUL SYLLABLE HIH|LINEAR B SYLLABLE B008 A|FULLWIDTH LEFT PARENTHESIS|"+\r
1085                              "FULLWIDTH YEN SIGN|"+\r
1086                              "null|"+ // getName returns null because 0xFFFF does not have a name, but has an extended name!\r
1087                              "CJK UNIFIED IDEOGRAPH-23456";\r
1088            String separator= "|";\r
1089            String source = Utility.valueOf(c);\r
1090            String result = UCharacter.getName(source, separator);\r
1091            if(!result.equals(expected)){\r
1092                errln("UCharacter.getName did not return the expected result.\n\t Expected: "+ expected+"\n\t Got: "+ result);\r
1093            }\r
1094 \r
1095         }catch(IllegalArgumentException e){\r
1096             if(e.getMessage().indexOf("unames.icu") >= 0){\r
1097                 warnln("Could not find unames.icu");\r
1098             }else{\r
1099                 throw e;\r
1100             }\r
1101         }\r
1102 \r
1103     }\r
1104 \r
1105 \r
1106     /**\r
1107     * Testing name iteration\r
1108     */\r
1109     public void TestNameIteration()throws Exception\r
1110     {\r
1111         try {\r
1112             ValueIterator iterator = UCharacter.getExtendedNameIterator();\r
1113             ValueIterator.Element element = new ValueIterator.Element();\r
1114             ValueIterator.Element old     = new ValueIterator.Element();\r
1115             // testing subrange\r
1116             iterator.setRange(-10, -5);\r
1117             if (iterator.next(element)) {\r
1118                 errln("Fail, expected iterator to return false when range is set outside the meaningful range");\r
1119             }\r
1120             iterator.setRange(0x110000, 0x111111);\r
1121             if (iterator.next(element)) {\r
1122                 errln("Fail, expected iterator to return false when range is set outside the meaningful range");\r
1123             }\r
1124             try {\r
1125                 iterator.setRange(50, 10);\r
1126                 errln("Fail, expected exception when encountered invalid range");\r
1127             } catch (Exception e) {\r
1128             }\r
1129 \r
1130             iterator.setRange(-10, 10);\r
1131             if (!iterator.next(element) || element.integer != 0) {\r
1132                 errln("Fail, expected iterator to return 0 when range start limit is set outside the meaningful range");\r
1133             }\r
1134 \r
1135             iterator.setRange(0x10FFFE, 0x200000);\r
1136             int last = 0;\r
1137             while (iterator.next(element)) {\r
1138                 last = element.integer;\r
1139             }\r
1140             if (last != 0x10FFFF) {\r
1141                 errln("Fail, expected iterator to return 0x10FFFF when range end limit is set outside the meaningful range");\r
1142             }\r
1143 \r
1144             iterator = UCharacter.getNameIterator();\r
1145             iterator.setRange(0xF, 0x45);\r
1146             while (iterator.next(element)) {\r
1147                 if (element.integer <= old.integer) {\r
1148                     errln("FAIL next returned a less codepoint \\u" +\r
1149                         Integer.toHexString(element.integer) + " than \\u" +\r
1150                         Integer.toHexString(old.integer));\r
1151                     break;\r
1152                 }\r
1153                 if (!UCharacter.getName(element.integer).equals(element.value))\r
1154                 {\r
1155                     errln("FAIL next codepoint \\u" +\r
1156                         Integer.toHexString(element.integer) +\r
1157                         " does not have the expected name " +\r
1158                         UCharacter.getName(element.integer) +\r
1159                         " instead have the name " + (String)element.value);\r
1160                     break;\r
1161                 }\r
1162                 old.integer = element.integer;\r
1163             }\r
1164 \r
1165             iterator.reset();\r
1166             iterator.next(element);\r
1167             if (element.integer != 0x20) {\r
1168                 errln("FAIL reset in iterator");\r
1169             }\r
1170 \r
1171             iterator.setRange(0, 0x110000);\r
1172             old.integer = 0;\r
1173             while (iterator.next(element)) {\r
1174                 if (element.integer != 0 && element.integer <= old.integer) {\r
1175                     errln("FAIL next returned a less codepoint \\u" +\r
1176                         Integer.toHexString(element.integer) + " than \\u" +\r
1177                         Integer.toHexString(old.integer));\r
1178                     break;\r
1179                 }\r
1180                 if (!UCharacter.getName(element.integer).equals(element.value))\r
1181                 {\r
1182                     errln("FAIL next codepoint \\u" +\r
1183                             Integer.toHexString(element.integer) +\r
1184                             " does not have the expected name " +\r
1185                             UCharacter.getName(element.integer) +\r
1186                             " instead have the name " + (String)element.value);\r
1187                     break;\r
1188                 }\r
1189                 for (int i = old.integer + 1; i < element.integer; i ++) {\r
1190                     if (UCharacter.getName(i) != null) {\r
1191                         errln("FAIL between codepoints are not null \\u" +\r
1192                                 Integer.toHexString(old.integer) + " and " +\r
1193                                 Integer.toHexString(element.integer) + " has " +\r
1194                                 Integer.toHexString(i) + " with a name " +\r
1195                                 UCharacter.getName(i));\r
1196                         break;\r
1197                     }\r
1198                 }\r
1199                 old.integer = element.integer;\r
1200             }\r
1201 \r
1202             iterator = UCharacter.getExtendedNameIterator();\r
1203             old.integer = 0;\r
1204             while (iterator.next(element)) {\r
1205                 if (element.integer != 0 && element.integer != old.integer) {\r
1206                     errln("FAIL next returned a codepoint \\u" +\r
1207                             Integer.toHexString(element.integer) +\r
1208                             " different from \\u" +\r
1209                             Integer.toHexString(old.integer));\r
1210                     break;\r
1211                 }\r
1212                 if (!UCharacter.getExtendedName(element.integer).equals(\r
1213                                                               element.value)) {\r
1214                     errln("FAIL next codepoint \\u" +\r
1215                         Integer.toHexString(element.integer) +\r
1216                         " name should be "\r
1217                         + UCharacter.getExtendedName(element.integer) +\r
1218                         " instead of " + (String)element.value);\r
1219                     break;\r
1220                 }\r
1221                 old.integer++;\r
1222             }\r
1223             iterator = UCharacter.getName1_0Iterator();\r
1224             old.integer = 0;\r
1225             while (iterator.next(element)) {\r
1226                 logln(Integer.toHexString(element.integer) + " " +\r
1227                                                         (String)element.value);\r
1228                 if (element.integer != 0 && element.integer <= old.integer) {\r
1229                     errln("FAIL next returned a less codepoint \\u" +\r
1230                         Integer.toHexString(element.integer) + " than \\u" +\r
1231                         Integer.toHexString(old.integer));\r
1232                     break;\r
1233                 }\r
1234                 if (!element.value.equals(UCharacter.getName1_0(\r
1235                                                             element.integer))) {\r
1236                     errln("FAIL next codepoint \\u" +\r
1237                             Integer.toHexString(element.integer) +\r
1238                             " name cannot be null");\r
1239                     break;\r
1240                 }\r
1241                 for (int i = old.integer + 1; i < element.integer; i ++) {\r
1242                     if (UCharacter.getName1_0(i) != null) {\r
1243                         errln("FAIL between codepoints are not null \\u" +\r
1244                             Integer.toHexString(old.integer) + " and " +\r
1245                             Integer.toHexString(element.integer) + " has " +\r
1246                             Integer.toHexString(i) + " with a name " +\r
1247                             UCharacter.getName1_0(i));\r
1248                         break;\r
1249                     }\r
1250                 }\r
1251                 old.integer = element.integer;\r
1252             }\r
1253         } catch(Exception e){\r
1254             // !!! wouldn't preflighting be simpler?  This looks like\r
1255             // it is effectively be doing that.  It seems that for every\r
1256             // true error the code will call errln, which will throw the error, which\r
1257             // this will catch, which this will then rethrow the error.  Just seems\r
1258             // cumbersome.\r
1259             if(e.getMessage().indexOf("unames.icu") >= 0){\r
1260                 warnln("Could not find unames.icu");\r
1261             } else {\r
1262                 errln(e.getMessage());\r
1263             }\r
1264         }\r
1265     }\r
1266 \r
1267     /**\r
1268     * Testing the for illegal characters\r
1269     */\r
1270     public void TestIsLegal()\r
1271     {\r
1272         int illegal[] = {0xFFFE, 0x00FFFF, 0x005FFFE, 0x005FFFF, 0x0010FFFE,\r
1273                          0x0010FFFF, 0x110000, 0x00FDD0, 0x00FDDF, 0x00FDE0,\r
1274                          0x00FDEF, 0xD800, 0xDC00, -1};\r
1275         int legal[] = {0x61, 0x00FFFD, 0x0010000, 0x005FFFD, 0x0060000,\r
1276                        0x0010FFFD, 0xFDCF, 0x00FDF0};\r
1277         for (int count = 0; count < illegal.length; count ++) {\r
1278             if (UCharacter.isLegal(illegal[count])) {\r
1279                 errln("FAIL \\u" + hex(illegal[count]) +\r
1280                         " is not a legal character");\r
1281             }\r
1282         }\r
1283 \r
1284         for (int count = 0; count < legal.length; count ++) {\r
1285             if (!UCharacter.isLegal(legal[count])) {\r
1286                 errln("FAIL \\u" + hex(legal[count]) +\r
1287                                                    " is a legal character");\r
1288             }\r
1289         }\r
1290 \r
1291         String illegalStr = "This is an illegal string ";\r
1292         String legalStr = "This is a legal string ";\r
1293 \r
1294         for (int count = 0; count < illegal.length; count ++) {\r
1295             StringBuffer str = new StringBuffer(illegalStr);\r
1296             if (illegal[count] < 0x10000) {\r
1297                 str.append((char)illegal[count]);\r
1298             }\r
1299             else {\r
1300                 char lead = UTF16.getLeadSurrogate(illegal[count]);\r
1301                 char trail = UTF16.getTrailSurrogate(illegal[count]);\r
1302                 str.append(lead);\r
1303                 str.append(trail);\r
1304             }\r
1305             if (UCharacter.isLegal(str.toString())) {\r
1306                 errln("FAIL " + hex(str.toString()) +\r
1307                       " is not a legal string");\r
1308             }\r
1309         }\r
1310 \r
1311         for (int count = 0; count < legal.length; count ++) {\r
1312             StringBuffer str = new StringBuffer(legalStr);\r
1313             if (legal[count] < 0x10000) {\r
1314                 str.append((char)legal[count]);\r
1315             }\r
1316             else {\r
1317                 char lead = UTF16.getLeadSurrogate(legal[count]);\r
1318                 char trail = UTF16.getTrailSurrogate(legal[count]);\r
1319                 str.append(lead);\r
1320                 str.append(trail);\r
1321             }\r
1322             if (!UCharacter.isLegal(str.toString())) {\r
1323                 errln("FAIL " + hex(str.toString()) + " is a legal string");\r
1324             }\r
1325         }\r
1326     }\r
1327 \r
1328     /**\r
1329      * Test getCodePoint\r
1330      */\r
1331     public void TestCodePoint()\r
1332     {\r
1333         int ch = 0x10000;\r
1334         for (char i = 0xD800; i < 0xDC00; i ++) {\r
1335             for (char j = 0xDC00; j <= 0xDFFF; j ++) {\r
1336                 if (UCharacter.getCodePoint(i, j) != ch) {\r
1337                     errln("Error getting codepoint for surrogate " +\r
1338                           "characters \\u"\r
1339                           + Integer.toHexString(i) + " \\u" +\r
1340                           Integer.toHexString(j));\r
1341                 }\r
1342                 ch ++;\r
1343             }\r
1344         }\r
1345         try\r
1346         {\r
1347             UCharacter.getCodePoint((char)0xD7ff, (char)0xDC00);\r
1348             errln("Invalid surrogate characters should not form a " +\r
1349                   "supplementary");\r
1350         } catch(Exception e) {\r
1351         }\r
1352         for (char i = 0; i < 0xFFFF; i++) {\r
1353             if (i == 0xFFFE ||\r
1354                 (i >= 0xD800 && i <= 0xDFFF) ||\r
1355                 (i >= 0xFDD0 && i <= 0xFDEF)) {\r
1356                 // not a character\r
1357                 try {\r
1358                     UCharacter.getCodePoint(i);\r
1359                     errln("Not a character is not a valid codepoint");\r
1360                 } catch (Exception e) {\r
1361                 }\r
1362             }\r
1363             else {\r
1364                 if (UCharacter.getCodePoint(i) != i) {\r
1365                     errln("A valid codepoint should return itself");\r
1366                 }\r
1367             }\r
1368         }\r
1369     }\r
1370 \r
1371     /**\r
1372     * This method is a little different from the type test in icu4c.\r
1373     * But combined with testUnicodeData, they basically do the same thing.\r
1374     */\r
1375     public void TestIteration()\r
1376     {\r
1377         int limit     = 0;\r
1378         int prevtype  = -1;\r
1379         int shouldBeDir;\r
1380         int test[][]={{0x41, UCharacterCategory.UPPERCASE_LETTER},\r
1381                         {0x308, UCharacterCategory.NON_SPACING_MARK},\r
1382                         {0xfffe, UCharacterCategory.GENERAL_OTHER_TYPES},\r
1383                         {0xe0041, UCharacterCategory.FORMAT},\r
1384                         {0xeffff, UCharacterCategory.UNASSIGNED}};\r
1385 \r
1386         // default Bidi classes for unassigned code points\r
1387         int defaultBidi[][]={\r
1388             { 0x0590, UCharacterDirection.LEFT_TO_RIGHT },\r
1389             { 0x0600, UCharacterDirection.RIGHT_TO_LEFT },\r
1390             { 0x07C0, UCharacterDirection.RIGHT_TO_LEFT_ARABIC },\r
1391             { 0x0900, UCharacterDirection.RIGHT_TO_LEFT },\r
1392             { 0xFB1D, UCharacterDirection.LEFT_TO_RIGHT },\r
1393             { 0xFB50, UCharacterDirection.RIGHT_TO_LEFT },\r
1394             { 0xFE00, UCharacterDirection.RIGHT_TO_LEFT_ARABIC },\r
1395             { 0xFE70, UCharacterDirection.LEFT_TO_RIGHT },\r
1396             { 0xFF00, UCharacterDirection.RIGHT_TO_LEFT_ARABIC },\r
1397             { 0x10800, UCharacterDirection.LEFT_TO_RIGHT },\r
1398             { 0x11000, UCharacterDirection.RIGHT_TO_LEFT },\r
1399             { 0x1E800, UCharacterDirection.LEFT_TO_RIGHT },  /* new default-R range in Unicode 5.2: U+1E800 - U+1EFFF */\r
1400             { 0x1F000, UCharacterDirection.RIGHT_TO_LEFT },\r
1401             { 0x110000, UCharacterDirection.LEFT_TO_RIGHT }\r
1402         };\r
1403 \r
1404         RangeValueIterator iterator = UCharacter.getTypeIterator();\r
1405         RangeValueIterator.Element result = new RangeValueIterator.Element();\r
1406         while (iterator.next(result)) {\r
1407             if (result.start != limit) {\r
1408                 errln("UCharacterIteration failed: Ranges not continuous " +\r
1409                         "0x" + Integer.toHexString(result.start));\r
1410             }\r
1411 \r
1412             limit = result.limit;\r
1413             if (result.value == prevtype) {\r
1414                 errln("Type of the next set of enumeration should be different");\r
1415             }\r
1416             prevtype = result.value;\r
1417 \r
1418             for (int i = result.start; i < limit; i ++) {\r
1419                 int temptype = UCharacter.getType(i);\r
1420                 if (temptype != result.value) {\r
1421                     errln("UCharacterIteration failed: Codepoint \\u" +\r
1422                             Integer.toHexString(i) + " should be of type " +\r
1423                             temptype + " not " + result.value);\r
1424                 }\r
1425             }\r
1426 \r
1427             for (int i = 0; i < test.length; ++ i) {\r
1428                 if (result.start <= test[i][0] && test[i][0] < result.limit) {\r
1429                     if (result.value != test[i][1]) {\r
1430                         errln("error: getTypes() has range ["\r
1431                               + Integer.toHexString(result.start) + ", "\r
1432                               + Integer.toHexString(result.limit)\r
1433                               + "] with type " + result.value\r
1434                               + " instead of ["\r
1435                               + Integer.toHexString(test[i][0]) + ", "\r
1436                               + Integer.toHexString(test[i][1]));\r
1437                     }\r
1438                 }\r
1439             }\r
1440 \r
1441             // LineBreak.txt specifies:\r
1442             //   #  - Assigned characters that are not listed explicitly are given the value\r
1443             //   #    "AL".\r
1444             //   #  - Unassigned characters are given the value "XX".\r
1445             //\r
1446             // PUA characters are listed explicitly with "XX".\r
1447             // Verify that no assigned character has "XX".\r
1448             if (result.value != UCharacterCategory.UNASSIGNED\r
1449                 && result.value != UCharacterCategory.PRIVATE_USE) {\r
1450                 int c = result.start;\r
1451                 while (c < result.limit) {\r
1452                     if (0 == UCharacter.getIntPropertyValue(c,\r
1453                                                 UProperty.LINE_BREAK)) {\r
1454                         logln("error UProperty.LINE_BREAK(assigned \\u"\r
1455                               + Utility.hex(c, 4) + ")=XX");\r
1456                     }\r
1457                     ++ c;\r
1458                 }\r
1459             }\r
1460 \r
1461             /*\r
1462              * Verify default Bidi classes.\r
1463              * For recent Unicode versions, see UCD.html.\r
1464              *\r
1465              * For older Unicode versions:\r
1466              * See table 3-7 "Bidirectional Character Types" in UAX #9.\r
1467              * http://www.unicode.org/reports/tr9/\r
1468              *\r
1469              * See also DerivedBidiClass.txt for Cn code points!\r
1470              *\r
1471              * Unicode 4.0.1/Public Review Issue #28 (http://www.unicode.org/review/resolved-pri.html)\r
1472              * changed some default values.\r
1473              * In particular, non-characters and unassigned Default Ignorable Code Points\r
1474              * change from L to BN.\r
1475              *\r
1476              * UCD.html version 4.0.1 does not yet reflect these changes.\r
1477              */\r
1478             if (result.value == UCharacterCategory.UNASSIGNED\r
1479                 || result.value == UCharacterCategory.PRIVATE_USE) {\r
1480                 int c = result.start;\r
1481                 for (int i = 0; i < defaultBidi.length && c < result.limit;\r
1482                      ++ i) {\r
1483                     if (c < defaultBidi[i][0]) {\r
1484                         while (c < result.limit && c < defaultBidi[i][0]) {\r
1485                             // TODO change to public UCharacter.isNonCharacter(c) once it's available\r
1486                             if(com.ibm.icu.impl.UCharacterUtility.isNonCharacter(c) || UCharacter.hasBinaryProperty(c, UProperty.DEFAULT_IGNORABLE_CODE_POINT)) {\r
1487                                 shouldBeDir=UCharacter.BOUNDARY_NEUTRAL;\r
1488                             } else {\r
1489                                 shouldBeDir=defaultBidi[i][1];\r
1490                             }\r
1491 \r
1492                             if (UCharacter.getDirection(c) != shouldBeDir\r
1493                                 || UCharacter.getIntPropertyValue(c,\r
1494                                                           UProperty.BIDI_CLASS)\r
1495                                    != shouldBeDir) {\r
1496                                 errln("error: getDirection(unassigned/PUA "\r
1497                                       + Integer.toHexString(c)\r
1498                                       + ") should be "\r
1499                                       + shouldBeDir);\r
1500                             }\r
1501                             ++ c;\r
1502                         }\r
1503                     }\r
1504                 }\r
1505             }\r
1506         }\r
1507 \r
1508         iterator.reset();\r
1509         if (iterator.next(result) == false || result.start != 0) {\r
1510             System.out.println("result " + result.start);\r
1511             errln("UCharacterIteration reset() failed");\r
1512         }\r
1513     }\r
1514 \r
1515     /**\r
1516      * Testing getAge\r
1517      */\r
1518     public void TestGetAge()\r
1519     {\r
1520         int ages[] = {0x41,    1, 1, 0, 0,\r
1521                       0xffff,  1, 1, 0, 0,\r
1522                       0x20ab,  2, 0, 0, 0,\r
1523                       0x2fffe, 2, 0, 0, 0,\r
1524                       0x20ac,  2, 1, 0, 0,\r
1525                       0xfb1d,  3, 0, 0, 0,\r
1526                       0x3f4,   3, 1, 0, 0,\r
1527                       0x10300, 3, 1, 0, 0,\r
1528                       0x220,   3, 2, 0, 0,\r
1529                       0xff60,  3, 2, 0, 0};\r
1530         for (int i = 0; i < ages.length; i += 5) {\r
1531             VersionInfo age = UCharacter.getAge(ages[i]);\r
1532             if (age != VersionInfo.getInstance(ages[i + 1], ages[i + 2],\r
1533                                                ages[i + 3], ages[i + 4])) {\r
1534                 errln("error: getAge(\\u" + Integer.toHexString(ages[i]) +\r
1535                       ") == " + age.toString() + " instead of " +\r
1536                       ages[i + 1] + "." + ages[i + 2] + "." + ages[i + 3] +\r
1537                       "." + ages[i + 4]);\r
1538             }\r
1539         }\r
1540         \r
1541         int[] valid_tests = {\r
1542                 UCharacter.MIN_VALUE, UCharacter.MIN_VALUE+1,\r
1543                 UCharacter.MAX_VALUE-1, UCharacter.MAX_VALUE};\r
1544         int[] invalid_tests = {\r
1545                 UCharacter.MIN_VALUE-1, UCharacter.MIN_VALUE-2,\r
1546                 UCharacter.MAX_VALUE+1, UCharacter.MAX_VALUE+2};\r
1547         \r
1548         for(int i=0; i< valid_tests.length; i++){\r
1549             try{\r
1550                 UCharacter.getAge(valid_tests[i]);\r
1551             } catch(Exception e){\r
1552                 errln("UCharacter.getAge(int) was not suppose to have " +\r
1553                         "an exception. Value passed: " + valid_tests[i]);\r
1554             }\r
1555         }\r
1556             \r
1557         for(int i=0; i< invalid_tests.length; i++){\r
1558             try{\r
1559                 UCharacter.getAge(invalid_tests[i]);\r
1560                 errln("UCharacter.getAge(int) was suppose to have " +\r
1561                         "an exception. Value passed: " + invalid_tests[i]);\r
1562             } catch(Exception e){\r
1563             }\r
1564         }\r
1565     }\r
1566 \r
1567     /**\r
1568      * Test binary non core properties\r
1569      */\r
1570     public void TestAdditionalProperties()\r
1571     {\r
1572         // test data for hasBinaryProperty()\r
1573         int props[][] = { // code point, property\r
1574             { 0x0627, UProperty.ALPHABETIC, 1 },\r
1575             { 0x1034a, UProperty.ALPHABETIC, 1 },\r
1576             { 0x2028, UProperty.ALPHABETIC, 0 },\r
1577 \r
1578             { 0x0066, UProperty.ASCII_HEX_DIGIT, 1 },\r
1579             { 0x0067, UProperty.ASCII_HEX_DIGIT, 0 },\r
1580 \r
1581             { 0x202c, UProperty.BIDI_CONTROL, 1 },\r
1582             { 0x202f, UProperty.BIDI_CONTROL, 0 },\r
1583 \r
1584             { 0x003c, UProperty.BIDI_MIRRORED, 1 },\r
1585             { 0x003d, UProperty.BIDI_MIRRORED, 0 },\r
1586 \r
1587             /* see Unicode Corrigendum #6 at http://www.unicode.org/versions/corrigendum6.html */\r
1588             { 0x2018, UProperty.BIDI_MIRRORED, 0 },\r
1589             { 0x201d, UProperty.BIDI_MIRRORED, 0 },\r
1590             { 0x201f, UProperty.BIDI_MIRRORED, 0 },\r
1591             { 0x301e, UProperty.BIDI_MIRRORED, 0 },\r
1592 \r
1593             { 0x058a, UProperty.DASH, 1 },\r
1594             { 0x007e, UProperty.DASH, 0 },\r
1595 \r
1596             { 0x0c4d, UProperty.DIACRITIC, 1 },\r
1597             { 0x3000, UProperty.DIACRITIC, 0 },\r
1598 \r
1599             { 0x0e46, UProperty.EXTENDER, 1 },\r
1600             { 0x0020, UProperty.EXTENDER, 0 },\r
1601 \r
1602             { 0xfb1d, UProperty.FULL_COMPOSITION_EXCLUSION, 1 },\r
1603             { 0x1d15f, UProperty.FULL_COMPOSITION_EXCLUSION, 1 },\r
1604             { 0xfb1e, UProperty.FULL_COMPOSITION_EXCLUSION, 0 },\r
1605 \r
1606             { 0x110a, UProperty.NFD_INERT, 1 },      /* Jamo L */\r
1607             { 0x0308, UProperty.NFD_INERT, 0 },\r
1608 \r
1609             { 0x1164, UProperty.NFKD_INERT, 1 },     /* Jamo V */\r
1610             { 0x1d79d, UProperty.NFKD_INERT, 0 },   /* math compat version of xi */\r
1611 \r
1612             { 0x0021, UProperty.NFC_INERT, 1 },      /* ! */\r
1613             { 0x0061, UProperty.NFC_INERT, 0 },     /* a */\r
1614             { 0x00e4, UProperty.NFC_INERT, 0 },     /* a-umlaut */\r
1615             { 0x0102, UProperty.NFC_INERT, 0 },     /* a-breve */\r
1616             { 0xac1c, UProperty.NFC_INERT, 0 },     /* Hangul LV */\r
1617             { 0xac1d, UProperty.NFC_INERT, 1 },      /* Hangul LVT */\r
1618 \r
1619             { 0x1d79d, UProperty.NFKC_INERT, 0 },   /* math compat version of xi */\r
1620             { 0x2a6d6, UProperty.NFKC_INERT, 1 },    /* Han, last of CJK ext. B */\r
1621 \r
1622             { 0x00e4, UProperty.SEGMENT_STARTER, 1 },\r
1623             { 0x0308, UProperty.SEGMENT_STARTER, 0 },\r
1624             { 0x110a, UProperty.SEGMENT_STARTER, 1 }, /* Jamo L */\r
1625             { 0x1164, UProperty.SEGMENT_STARTER, 0 },/* Jamo V */\r
1626             { 0xac1c, UProperty.SEGMENT_STARTER, 1 }, /* Hangul LV */\r
1627             { 0xac1d, UProperty.SEGMENT_STARTER, 1 }, /* Hangul LVT */\r
1628 \r
1629             { 0x0044, UProperty.HEX_DIGIT, 1 },\r
1630             { 0xff46, UProperty.HEX_DIGIT, 1 },\r
1631             { 0x0047, UProperty.HEX_DIGIT, 0 },\r
1632 \r
1633             { 0x30fb, UProperty.HYPHEN, 1 },\r
1634             { 0xfe58, UProperty.HYPHEN, 0 },\r
1635 \r
1636             { 0x2172, UProperty.ID_CONTINUE, 1 },\r
1637             { 0x0307, UProperty.ID_CONTINUE, 1 },\r
1638             { 0x005c, UProperty.ID_CONTINUE, 0 },\r
1639 \r
1640             { 0x2172, UProperty.ID_START, 1 },\r
1641             { 0x007a, UProperty.ID_START, 1 },\r
1642             { 0x0039, UProperty.ID_START, 0 },\r
1643 \r
1644             { 0x4db5, UProperty.IDEOGRAPHIC, 1 },\r
1645             { 0x2f999, UProperty.IDEOGRAPHIC, 1 },\r
1646             { 0x2f99, UProperty.IDEOGRAPHIC, 0 },\r
1647 \r
1648             { 0x200c, UProperty.JOIN_CONTROL, 1 },\r
1649             { 0x2029, UProperty.JOIN_CONTROL, 0 },\r
1650 \r
1651             { 0x1d7bc, UProperty.LOWERCASE, 1 },\r
1652             { 0x0345, UProperty.LOWERCASE, 1 },\r
1653             { 0x0030, UProperty.LOWERCASE, 0 },\r
1654 \r
1655             { 0x1d7a9, UProperty.MATH, 1 },\r
1656             { 0x2135, UProperty.MATH, 1 },\r
1657             { 0x0062, UProperty.MATH, 0 },\r
1658 \r
1659             { 0xfde1, UProperty.NONCHARACTER_CODE_POINT, 1 },\r
1660             { 0x10ffff, UProperty.NONCHARACTER_CODE_POINT, 1 },\r
1661             { 0x10fffd, UProperty.NONCHARACTER_CODE_POINT, 0 },\r
1662 \r
1663             { 0x0022, UProperty.QUOTATION_MARK, 1 },\r
1664             { 0xff62, UProperty.QUOTATION_MARK, 1 },\r
1665             { 0xd840, UProperty.QUOTATION_MARK, 0 },\r
1666 \r
1667             { 0x061f, UProperty.TERMINAL_PUNCTUATION, 1 },\r
1668             { 0xe003f, UProperty.TERMINAL_PUNCTUATION, 0 },\r
1669 \r
1670             { 0x1d44a, UProperty.UPPERCASE, 1 },\r
1671             { 0x2162, UProperty.UPPERCASE, 1 },\r
1672             { 0x0345, UProperty.UPPERCASE, 0 },\r
1673 \r
1674             { 0x0020, UProperty.WHITE_SPACE, 1 },\r
1675             { 0x202f, UProperty.WHITE_SPACE, 1 },\r
1676             { 0x3001, UProperty.WHITE_SPACE, 0 },\r
1677 \r
1678             { 0x0711, UProperty.XID_CONTINUE, 1 },\r
1679             { 0x1d1aa, UProperty.XID_CONTINUE, 1 },\r
1680             { 0x007c, UProperty.XID_CONTINUE, 0 },\r
1681 \r
1682             { 0x16ee, UProperty.XID_START, 1 },\r
1683             { 0x23456, UProperty.XID_START, 1 },\r
1684             { 0x1d1aa, UProperty.XID_START, 0 },\r
1685 \r
1686             /*\r
1687              * Version break:\r
1688              * The following properties are only supported starting with the\r
1689              * Unicode version indicated in the second field.\r
1690              */\r
1691             { -1, 0x320, 0 },\r
1692 \r
1693             { 0x180c, UProperty.DEFAULT_IGNORABLE_CODE_POINT, 1 },\r
1694             { 0xfe02, UProperty.DEFAULT_IGNORABLE_CODE_POINT, 1 },\r
1695             { 0x1801, UProperty.DEFAULT_IGNORABLE_CODE_POINT, 0 },\r
1696 \r
1697             { 0x0149, UProperty.DEPRECATED, 1 },         /* changed in Unicode 5.2 */\r
1698             { 0x0341, UProperty.DEPRECATED, 0 },        /* changed in Unicode 5.2 */\r
1699             { 0xe0041, UProperty.DEPRECATED, 1 },       /* Changed from Unicode 5 to 5.1 */\r
1700             { 0xe0100, UProperty.DEPRECATED, 0 },\r
1701 \r
1702             { 0x00a0, UProperty.GRAPHEME_BASE, 1 },\r
1703             { 0x0a4d, UProperty.GRAPHEME_BASE, 0 },\r
1704             { 0xff9d, UProperty.GRAPHEME_BASE, 1 },\r
1705             { 0xff9f, UProperty.GRAPHEME_BASE, 0 },      /* changed from Unicode 3.2 to 4  and again 5 to 5.1 */\r
1706 \r
1707             { 0x0300, UProperty.GRAPHEME_EXTEND, 1 },\r
1708             { 0xff9d, UProperty.GRAPHEME_EXTEND, 0 }, \r
1709             { 0xff9f, UProperty.GRAPHEME_EXTEND, 1 },   /* changed from Unicode 3.2 to 4 and again 5 to 5.1 */\r
1710             { 0x0603, UProperty.GRAPHEME_EXTEND, 0 },\r
1711 \r
1712             { 0x0a4d, UProperty.GRAPHEME_LINK, 1 },\r
1713             { 0xff9f, UProperty.GRAPHEME_LINK, 0 },\r
1714 \r
1715             { 0x2ff7, UProperty.IDS_BINARY_OPERATOR, 1 },\r
1716             { 0x2ff3, UProperty.IDS_BINARY_OPERATOR, 0 },\r
1717 \r
1718             { 0x2ff3, UProperty.IDS_TRINARY_OPERATOR, 1 },\r
1719             { 0x2f03, UProperty.IDS_TRINARY_OPERATOR, 0 },\r
1720 \r
1721             { 0x0ec1, UProperty.LOGICAL_ORDER_EXCEPTION, 1 },\r
1722             { 0xdcba, UProperty.LOGICAL_ORDER_EXCEPTION, 0 },\r
1723 \r
1724             { 0x2e9b, UProperty.RADICAL, 1 },\r
1725             { 0x4e00, UProperty.RADICAL, 0 },\r
1726 \r
1727             { 0x012f, UProperty.SOFT_DOTTED, 1 },\r
1728             { 0x0049, UProperty.SOFT_DOTTED, 0 },\r
1729 \r
1730             { 0xfa11, UProperty.UNIFIED_IDEOGRAPH, 1 },\r
1731             { 0xfa12, UProperty.UNIFIED_IDEOGRAPH, 0 },\r
1732 \r
1733             { -1, 0x401, 0 }, /* version break for Unicode 4.0.1 */\r
1734 \r
1735             { 0x002e, UProperty.S_TERM, 1 },\r
1736             { 0x0061, UProperty.S_TERM, 0 },\r
1737 \r
1738             { 0x180c, UProperty.VARIATION_SELECTOR, 1 },\r
1739             { 0xfe03, UProperty.VARIATION_SELECTOR, 1 },\r
1740             { 0xe01ef, UProperty.VARIATION_SELECTOR, 1 },\r
1741             { 0xe0200, UProperty.VARIATION_SELECTOR, 0 },\r
1742 \r
1743             /* enum/integer type properties */\r
1744             /* test default Bidi classes for unassigned code points */\r
1745             { 0x0590, UProperty.BIDI_CLASS, UCharacterDirection.RIGHT_TO_LEFT },\r
1746             { 0x05cf, UProperty.BIDI_CLASS, UCharacterDirection.RIGHT_TO_LEFT },\r
1747             { 0x05ed, UProperty.BIDI_CLASS, UCharacterDirection.RIGHT_TO_LEFT },\r
1748             { 0x07f2, UProperty.BIDI_CLASS, UCharacterDirection.DIR_NON_SPACING_MARK }, /* Nko, new in Unicode 5.0 */\r
1749             { 0x07fe, UProperty.BIDI_CLASS, UCharacterDirection.RIGHT_TO_LEFT }, /* unassigned R */\r
1750             { 0x08ba, UProperty.BIDI_CLASS, UCharacterDirection.RIGHT_TO_LEFT },\r
1751             { 0xfb37, UProperty.BIDI_CLASS, UCharacterDirection.RIGHT_TO_LEFT },\r
1752             { 0xfb42, UProperty.BIDI_CLASS, UCharacterDirection.RIGHT_TO_LEFT },\r
1753             { 0x10806, UProperty.BIDI_CLASS, UCharacterDirection.RIGHT_TO_LEFT },\r
1754             { 0x10909, UProperty.BIDI_CLASS, UCharacterDirection.RIGHT_TO_LEFT },\r
1755             { 0x10fe4, UProperty.BIDI_CLASS, UCharacterDirection.RIGHT_TO_LEFT },\r
1756 \r
1757             { 0x0605, UProperty.BIDI_CLASS, UCharacterDirection.RIGHT_TO_LEFT_ARABIC },\r
1758             { 0x061c, UProperty.BIDI_CLASS, UCharacterDirection.RIGHT_TO_LEFT_ARABIC },\r
1759             { 0x063f, UProperty.BIDI_CLASS, UCharacterDirection.RIGHT_TO_LEFT_ARABIC },\r
1760             { 0x070e, UProperty.BIDI_CLASS, UCharacterDirection.RIGHT_TO_LEFT_ARABIC },\r
1761             { 0x0775, UProperty.BIDI_CLASS, UCharacterDirection.RIGHT_TO_LEFT_ARABIC },\r
1762             { 0xfbc2, UProperty.BIDI_CLASS, UCharacterDirection.RIGHT_TO_LEFT_ARABIC },\r
1763             { 0xfd90, UProperty.BIDI_CLASS, UCharacterDirection.RIGHT_TO_LEFT_ARABIC },\r
1764             { 0xfefe, UProperty.BIDI_CLASS, UCharacterDirection.RIGHT_TO_LEFT_ARABIC },\r
1765 \r
1766             { 0x02AF, UProperty.BLOCK, UCharacter.UnicodeBlock.IPA_EXTENSIONS.getID() },\r
1767             { 0x0C4E, UProperty.BLOCK, UCharacter.UnicodeBlock.TELUGU.getID()},\r
1768             { 0x155A, UProperty.BLOCK, UCharacter.UnicodeBlock.UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS.getID() },\r
1769             { 0x1717, UProperty.BLOCK, UCharacter.UnicodeBlock.TAGALOG.getID() },\r
1770             { 0x1900, UProperty.BLOCK, UCharacter.UnicodeBlock.LIMBU.getID() },\r
1771             { 0x1AFF, UProperty.BLOCK, UCharacter.UnicodeBlock.NO_BLOCK.getID()},\r
1772             { 0x3040, UProperty.BLOCK, UCharacter.UnicodeBlock.HIRAGANA.getID()},\r
1773             { 0x1D0FF, UProperty.BLOCK, UCharacter.UnicodeBlock.BYZANTINE_MUSICAL_SYMBOLS.getID()},\r
1774             { 0x50000, UProperty.BLOCK, UCharacter.UnicodeBlock.NO_BLOCK.getID() },\r
1775             { 0xEFFFF, UProperty.BLOCK, UCharacter.UnicodeBlock.NO_BLOCK.getID() },\r
1776             { 0x10D0FF, UProperty.BLOCK, UCharacter.UnicodeBlock.SUPPLEMENTARY_PRIVATE_USE_AREA_B.getID() },\r
1777 \r
1778             /* UProperty.CANONICAL_COMBINING_CLASS tested for assigned characters in TestUnicodeData() */\r
1779             { 0xd7d7, UProperty.CANONICAL_COMBINING_CLASS, 0 },\r
1780 \r
1781             { 0x00A0, UProperty.DECOMPOSITION_TYPE, UCharacter.DecompositionType.NOBREAK },\r
1782             { 0x00A8, UProperty.DECOMPOSITION_TYPE, UCharacter.DecompositionType.COMPAT },\r
1783             { 0x00bf, UProperty.DECOMPOSITION_TYPE, UCharacter.DecompositionType.NONE },\r
1784             { 0x00c0, UProperty.DECOMPOSITION_TYPE, UCharacter.DecompositionType.CANONICAL },\r
1785             { 0x1E9B, UProperty.DECOMPOSITION_TYPE, UCharacter.DecompositionType.CANONICAL },\r
1786             { 0xBCDE, UProperty.DECOMPOSITION_TYPE, UCharacter.DecompositionType.CANONICAL },\r
1787             { 0xFB5D, UProperty.DECOMPOSITION_TYPE, UCharacter.DecompositionType.MEDIAL },\r
1788             { 0x1D736, UProperty.DECOMPOSITION_TYPE, UCharacter.DecompositionType.FONT },\r
1789             { 0xe0033, UProperty.DECOMPOSITION_TYPE, UCharacter.DecompositionType.NONE },\r
1790 \r
1791             { 0x0009, UProperty.EAST_ASIAN_WIDTH, UCharacter.EastAsianWidth.NEUTRAL },\r
1792             { 0x0020, UProperty.EAST_ASIAN_WIDTH, UCharacter.EastAsianWidth.NARROW },\r
1793             { 0x00B1, UProperty.EAST_ASIAN_WIDTH, UCharacter.EastAsianWidth.AMBIGUOUS },\r
1794             { 0x20A9, UProperty.EAST_ASIAN_WIDTH, UCharacter.EastAsianWidth.HALFWIDTH },\r
1795             { 0x2FFB, UProperty.EAST_ASIAN_WIDTH, UCharacter.EastAsianWidth.WIDE },\r
1796             { 0x3000, UProperty.EAST_ASIAN_WIDTH, UCharacter.EastAsianWidth.FULLWIDTH },\r
1797             { 0x35bb, UProperty.EAST_ASIAN_WIDTH, UCharacter.EastAsianWidth.WIDE },\r
1798             { 0x58bd, UProperty.EAST_ASIAN_WIDTH, UCharacter.EastAsianWidth.WIDE },\r
1799             { 0xD7A3, UProperty.EAST_ASIAN_WIDTH, UCharacter.EastAsianWidth.WIDE },\r
1800             { 0xEEEE, UProperty.EAST_ASIAN_WIDTH, UCharacter.EastAsianWidth.AMBIGUOUS },\r
1801             { 0x1D198, UProperty.EAST_ASIAN_WIDTH, UCharacter.EastAsianWidth.NEUTRAL },\r
1802             { 0x20000, UProperty.EAST_ASIAN_WIDTH, UCharacter.EastAsianWidth.WIDE },\r
1803             { 0x2F8C7, UProperty.EAST_ASIAN_WIDTH, UCharacter.EastAsianWidth.WIDE },\r
1804             { 0x3a5bd, UProperty.EAST_ASIAN_WIDTH, UCharacter.EastAsianWidth.WIDE },\r
1805             { 0x5a5bd, UProperty.EAST_ASIAN_WIDTH, UCharacter.EastAsianWidth.NEUTRAL },\r
1806             { 0xFEEEE, UProperty.EAST_ASIAN_WIDTH, UCharacter.EastAsianWidth.AMBIGUOUS },\r
1807             { 0x10EEEE, UProperty.EAST_ASIAN_WIDTH, UCharacter.EastAsianWidth.AMBIGUOUS },\r
1808 \r
1809             /* UProperty.GENERAL_CATEGORY tested for assigned characters in TestUnicodeData() */\r
1810             { 0xd7c7, UProperty.GENERAL_CATEGORY, 0 },\r
1811             { 0xd7d7, UProperty.GENERAL_CATEGORY, UCharacterEnums.ECharacterCategory.OTHER_LETTER },     /* changed in Unicode 5.2 */\r
1812 \r
1813             { 0x0444, UProperty.JOINING_GROUP, UCharacter.JoiningGroup.NO_JOINING_GROUP },\r
1814             { 0x0639, UProperty.JOINING_GROUP, UCharacter.JoiningGroup.AIN },\r
1815             { 0x072A, UProperty.JOINING_GROUP, UCharacter.JoiningGroup.DALATH_RISH },\r
1816             { 0x0647, UProperty.JOINING_GROUP, UCharacter.JoiningGroup.HEH },\r
1817             { 0x06C1, UProperty.JOINING_GROUP, UCharacter.JoiningGroup.HEH_GOAL },\r
1818             { 0x06C3, UProperty.JOINING_GROUP, UCharacter.JoiningGroup.HAMZA_ON_HEH_GOAL },\r
1819 \r
1820             { 0x200C, UProperty.JOINING_TYPE, UCharacter.JoiningType.NON_JOINING },\r
1821             { 0x200D, UProperty.JOINING_TYPE, UCharacter.JoiningType.JOIN_CAUSING },\r
1822             { 0x0639, UProperty.JOINING_TYPE, UCharacter.JoiningType.DUAL_JOINING },\r
1823             { 0x0640, UProperty.JOINING_TYPE, UCharacter.JoiningType.JOIN_CAUSING },\r
1824             { 0x06C3, UProperty.JOINING_TYPE, UCharacter.JoiningType.RIGHT_JOINING },\r
1825             { 0x0300, UProperty.JOINING_TYPE, UCharacter.JoiningType.TRANSPARENT },\r
1826             { 0x070F, UProperty.JOINING_TYPE, UCharacter.JoiningType.TRANSPARENT },\r
1827             { 0xe0033, UProperty.JOINING_TYPE, UCharacter.JoiningType.TRANSPARENT },\r
1828 \r
1829             /* TestUnicodeData() verifies that no assigned character has "XX" (unknown) */\r
1830             { 0xe7e7, UProperty.LINE_BREAK, UCharacter.LineBreak.UNKNOWN },\r
1831             { 0x10fffd, UProperty.LINE_BREAK, UCharacter.LineBreak.UNKNOWN },\r
1832             { 0x0028, UProperty.LINE_BREAK, UCharacter.LineBreak.OPEN_PUNCTUATION },\r
1833             { 0x232A, UProperty.LINE_BREAK, UCharacter.LineBreak.CLOSE_PUNCTUATION },\r
1834             { 0x3401, UProperty.LINE_BREAK, UCharacter.LineBreak.IDEOGRAPHIC },\r
1835             { 0x4e02, UProperty.LINE_BREAK, UCharacter.LineBreak.IDEOGRAPHIC },\r
1836             { 0x20004, UProperty.LINE_BREAK, UCharacter.LineBreak.IDEOGRAPHIC },\r
1837             { 0xf905, UProperty.LINE_BREAK, UCharacter.LineBreak.IDEOGRAPHIC },\r
1838             { 0xdb7e, UProperty.LINE_BREAK, UCharacter.LineBreak.SURROGATE },\r
1839             { 0xdbfd, UProperty.LINE_BREAK, UCharacter.LineBreak.SURROGATE },\r
1840             { 0xdffc, UProperty.LINE_BREAK, UCharacter.LineBreak.SURROGATE },\r
1841             { 0x2762, UProperty.LINE_BREAK, UCharacter.LineBreak.EXCLAMATION },\r
1842             { 0x002F, UProperty.LINE_BREAK, UCharacter.LineBreak.BREAK_SYMBOLS },\r
1843             { 0x1D49C, UProperty.LINE_BREAK, UCharacter.LineBreak.ALPHABETIC },\r
1844             { 0x1731, UProperty.LINE_BREAK, UCharacter.LineBreak.ALPHABETIC },\r
1845 \r
1846             /* UProperty.NUMERIC_TYPE tested in TestNumericProperties() */\r
1847 \r
1848             /* UProperty.SCRIPT tested in TestUScriptCodeAPI() */\r
1849 \r
1850             { 0x10ff, UProperty.HANGUL_SYLLABLE_TYPE, 0 },\r
1851             { 0x1100, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.LEADING_JAMO },\r
1852             { 0x1111, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.LEADING_JAMO },\r
1853             { 0x1159, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.LEADING_JAMO },\r
1854             { 0x115a, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.LEADING_JAMO },     /* changed in Unicode 5.2 */\r
1855             { 0x115e, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.LEADING_JAMO },     /* changed in Unicode 5.2 */\r
1856             { 0x115f, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.LEADING_JAMO },\r
1857 \r
1858             { 0xa95f, UProperty.HANGUL_SYLLABLE_TYPE, 0 },\r
1859             { 0xa960, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.LEADING_JAMO },     /* changed in Unicode 5.2 */\r
1860             { 0xa97c, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.LEADING_JAMO },     /* changed in Unicode 5.2 */\r
1861             { 0xa97d, UProperty.HANGUL_SYLLABLE_TYPE, 0 },\r
1862 \r
1863             { 0x1160, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.VOWEL_JAMO },\r
1864             { 0x1161, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.VOWEL_JAMO },\r
1865             { 0x1172, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.VOWEL_JAMO },\r
1866             { 0x11a2, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.VOWEL_JAMO },\r
1867             { 0x11a3, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.VOWEL_JAMO },       /* changed in Unicode 5.2 */\r
1868             { 0x11a7, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.VOWEL_JAMO },       /* changed in Unicode 5.2 */\r
1869 \r
1870             { 0xd7af, UProperty.HANGUL_SYLLABLE_TYPE, 0 },\r
1871             { 0xd7b0, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.VOWEL_JAMO },       /* changed in Unicode 5.2 */\r
1872             { 0xd7c6, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.VOWEL_JAMO },       /* changed in Unicode 5.2 */\r
1873             { 0xd7c7, UProperty.HANGUL_SYLLABLE_TYPE, 0 },\r
1874 \r
1875             { 0x11a8, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.TRAILING_JAMO },\r
1876             { 0x11b8, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.TRAILING_JAMO },\r
1877             { 0x11c8, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.TRAILING_JAMO },\r
1878             { 0x11f9, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.TRAILING_JAMO },\r
1879             { 0x11fa, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.TRAILING_JAMO },    /* changed in Unicode 5.2 */\r
1880             { 0x11ff, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.TRAILING_JAMO },    /* changed in Unicode 5.2 */\r
1881             { 0x1200, UProperty.HANGUL_SYLLABLE_TYPE, 0 },\r
1882 \r
1883             { 0xd7ca, UProperty.HANGUL_SYLLABLE_TYPE, 0 },\r
1884             { 0xd7cb, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.TRAILING_JAMO },    /* changed in Unicode 5.2 */\r
1885             { 0xd7fb, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.TRAILING_JAMO },    /* changed in Unicode 5.2 */\r
1886             { 0xd7fc, UProperty.HANGUL_SYLLABLE_TYPE, 0 },\r
1887 \r
1888             { 0xac00, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.LV_SYLLABLE },\r
1889             { 0xac1c, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.LV_SYLLABLE },\r
1890             { 0xc5ec, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.LV_SYLLABLE },\r
1891             { 0xd788, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.LV_SYLLABLE },\r
1892 \r
1893             { 0xac01, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.LVT_SYLLABLE },\r
1894             { 0xac1b, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.LVT_SYLLABLE },\r
1895             { 0xac1d, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.LVT_SYLLABLE },\r
1896             { 0xc5ee, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.LVT_SYLLABLE },\r
1897             { 0xd7a3, UProperty.HANGUL_SYLLABLE_TYPE, UCharacter.HangulSyllableType.LVT_SYLLABLE },\r
1898 \r
1899             { 0xd7a4, UProperty.HANGUL_SYLLABLE_TYPE, 0 },\r
1900 \r
1901             { -1, 0x410, 0 }, /* version break for Unicode 4.1 */\r
1902 \r
1903             { 0x00d7, UProperty.PATTERN_SYNTAX, 1 },\r
1904             { 0xfe45, UProperty.PATTERN_SYNTAX, 1 },\r
1905             { 0x0061, UProperty.PATTERN_SYNTAX, 0 },\r
1906 \r
1907             { 0x0020, UProperty.PATTERN_WHITE_SPACE, 1 },\r
1908             { 0x0085, UProperty.PATTERN_WHITE_SPACE, 1 },\r
1909             { 0x200f, UProperty.PATTERN_WHITE_SPACE, 1 },\r
1910             { 0x00a0, UProperty.PATTERN_WHITE_SPACE, 0 },\r
1911             { 0x3000, UProperty.PATTERN_WHITE_SPACE, 0 },\r
1912 \r
1913             { 0x1d200, UProperty.BLOCK, UCharacter.UnicodeBlock.ANCIENT_GREEK_MUSICAL_NOTATION_ID },\r
1914             { 0x2c8e,  UProperty.BLOCK, UCharacter.UnicodeBlock.COPTIC_ID },\r
1915             { 0xfe17,  UProperty.BLOCK, UCharacter.UnicodeBlock.VERTICAL_FORMS_ID },\r
1916 \r
1917             { 0x1a00,  UProperty.SCRIPT, UScript.BUGINESE },\r
1918             { 0x2cea,  UProperty.SCRIPT, UScript.COPTIC },\r
1919             { 0xa82b,  UProperty.SCRIPT, UScript.SYLOTI_NAGRI },\r
1920             { 0x103d0, UProperty.SCRIPT, UScript.OLD_PERSIAN },\r
1921 \r
1922             { 0xcc28, UProperty.LINE_BREAK, UCharacter.LineBreak.H2 },\r
1923             { 0xcc29, UProperty.LINE_BREAK, UCharacter.LineBreak.H3 },\r
1924             { 0xac03, UProperty.LINE_BREAK, UCharacter.LineBreak.H3 },\r
1925             { 0x115f, UProperty.LINE_BREAK, UCharacter.LineBreak.JL },\r
1926             { 0x11aa, UProperty.LINE_BREAK, UCharacter.LineBreak.JT },\r
1927             { 0x11a1, UProperty.LINE_BREAK, UCharacter.LineBreak.JV },\r
1928 \r
1929             { 0xb2c9, UProperty.GRAPHEME_CLUSTER_BREAK, UCharacter.GraphemeClusterBreak.LVT },\r
1930             { 0x036f, UProperty.GRAPHEME_CLUSTER_BREAK, UCharacter.GraphemeClusterBreak.EXTEND },\r
1931             { 0x0000, UProperty.GRAPHEME_CLUSTER_BREAK, UCharacter.GraphemeClusterBreak.CONTROL },\r
1932             { 0x1160, UProperty.GRAPHEME_CLUSTER_BREAK, UCharacter.GraphemeClusterBreak.V },\r
1933 \r
1934             { 0x05f4, UProperty.WORD_BREAK, UCharacter.WordBreak.MIDLETTER },\r
1935             { 0x4ef0, UProperty.WORD_BREAK, UCharacter.WordBreak.OTHER },\r
1936             { 0x19d9, UProperty.WORD_BREAK, UCharacter.WordBreak.NUMERIC },\r
1937             { 0x2044, UProperty.WORD_BREAK, UCharacter.WordBreak.MIDNUM },\r
1938 \r
1939             { 0xfffd, UProperty.SENTENCE_BREAK, UCharacter.SentenceBreak.OTHER },\r
1940             { 0x1ffc, UProperty.SENTENCE_BREAK, UCharacter.SentenceBreak.UPPER },\r
1941             { 0xff63, UProperty.SENTENCE_BREAK, UCharacter.SentenceBreak.CLOSE },\r
1942             { 0x2028, UProperty.SENTENCE_BREAK, UCharacter.SentenceBreak.SEP },\r
1943 \r
1944             { -1, 0x520, 0 }, /* version break for Unicode 5.2 */\r
1945 \r
1946             /* test some script codes >127 */\r
1947             { 0xa6e6,  UProperty.SCRIPT, UScript.BAMUM },\r
1948             { 0xa4d0,  UProperty.SCRIPT, UScript.LISU },\r
1949             { 0x10a7f,  UProperty.SCRIPT, UScript.OLD_SOUTH_ARABIAN },\r
1950 \r
1951             /* undefined UProperty values */\r
1952             { 0x61, 0x4a7, 0 },\r
1953             { 0x234bc, 0x15ed, 0 }\r
1954         };\r
1955 \r
1956 \r
1957         if (UCharacter.getIntPropertyMinValue(UProperty.DASH) != 0\r
1958             || UCharacter.getIntPropertyMinValue(UProperty.BIDI_CLASS) != 0\r
1959             || UCharacter.getIntPropertyMinValue(UProperty.BLOCK)!= 0  /* j2478 */\r
1960             || UCharacter.getIntPropertyMinValue(UProperty.SCRIPT)!= 0 /* JB#2410 */\r
1961             || UCharacter.getIntPropertyMinValue(0x2345) != 0) {\r
1962             errln("error: UCharacter.getIntPropertyMinValue() wrong");\r
1963         }\r
1964 \r
1965         if( UCharacter.getIntPropertyMaxValue(UProperty.DASH)!=1) {\r
1966             errln("error: UCharacter.getIntPropertyMaxValue(UProperty.DASH) wrong\n");\r
1967         }\r
1968         if( UCharacter.getIntPropertyMaxValue(UProperty.ID_CONTINUE)!=1) {\r
1969             errln("error: UCharacter.getIntPropertyMaxValue(UProperty.ID_CONTINUE) wrong\n");\r
1970         }\r
1971         if( UCharacter.getIntPropertyMaxValue(UProperty.BINARY_LIMIT-1)!=1) {\r
1972             errln("error: UCharacter.getIntPropertyMaxValue(UProperty.BINARY_LIMIT-1) wrong\n");\r
1973         }\r
1974 \r
1975         if( UCharacter.getIntPropertyMaxValue(UProperty.BIDI_CLASS)!=UCharacterDirection.CHAR_DIRECTION_COUNT-1 ) {\r
1976             errln("error: UCharacter.getIntPropertyMaxValue(UProperty.BIDI_CLASS) wrong\n");\r
1977         }\r
1978         if( UCharacter.getIntPropertyMaxValue(UProperty.BLOCK)!=UCharacter.UnicodeBlock.COUNT-1 ) {\r
1979             errln("error: UCharacter.getIntPropertyMaxValue(UProperty.BLOCK) wrong\n");\r
1980         }\r
1981         if(UCharacter.getIntPropertyMaxValue(UProperty.LINE_BREAK)!=UCharacter.LineBreak.COUNT-1) {\r
1982             errln("error: UCharacter.getIntPropertyMaxValue(UProperty.LINE_BREAK) wrong\n");\r
1983         }\r
1984         if(UCharacter.getIntPropertyMaxValue(UProperty.SCRIPT)!=UScript.CODE_LIMIT-1) {\r
1985             errln("error: UCharacter.getIntPropertyMaxValue(UProperty.SCRIPT) wrong\n");\r
1986         }\r
1987         if(UCharacter.getIntPropertyMaxValue(UProperty.NUMERIC_TYPE)!=UCharacter.NumericType.COUNT-1) {\r
1988             errln("error: UCharacter.getIntPropertyMaxValue(UProperty.NUMERIC_TYPE) wrong\n");\r
1989         }\r
1990         if(UCharacter.getIntPropertyMaxValue(UProperty.GENERAL_CATEGORY)!=UCharacterCategory.CHAR_CATEGORY_COUNT-1) {\r
1991             errln("error: UCharacter.getIntPropertyMaxValue(UProperty.GENERAL_CATEGORY) wrong\n");\r
1992         }\r
1993         if(UCharacter.getIntPropertyMaxValue(UProperty.HANGUL_SYLLABLE_TYPE)!=UCharacter.HangulSyllableType.COUNT-1) {\r
1994             errln("error: UCharacter.getIntPropertyMaxValue(UProperty.HANGUL_SYLLABLE_TYPE) wrong\n");\r
1995         }\r
1996         if(UCharacter.getIntPropertyMaxValue(UProperty.GRAPHEME_CLUSTER_BREAK)!=UCharacter.GraphemeClusterBreak.COUNT-1) {\r
1997             errln("error: UCharacter.getIntPropertyMaxValue(UProperty.GRAPHEME_CLUSTER_BREAK) wrong\n");\r
1998         }\r
1999         if(UCharacter.getIntPropertyMaxValue(UProperty.SENTENCE_BREAK)!=UCharacter.SentenceBreak.COUNT-1) {\r
2000             errln("error: UCharacter.getIntPropertyMaxValue(UProperty.SENTENCE_BREAK) wrong\n");\r
2001         }\r
2002         if(UCharacter.getIntPropertyMaxValue(UProperty.WORD_BREAK)!=UCharacter.WordBreak.COUNT-1) {\r
2003             errln("error: UCharacter.getIntPropertyMaxValue(UProperty.WORD_BREAK) wrong\n");\r
2004         }\r
2005         /*JB#2410*/\r
2006         if( UCharacter.getIntPropertyMaxValue(0x2345)!=-1) {\r
2007             errln("error: UCharacter.getIntPropertyMaxValue(0x2345) wrong\n");\r
2008         }\r
2009         if( UCharacter.getIntPropertyMaxValue(UProperty.DECOMPOSITION_TYPE) !=  (UCharacter.DecompositionType.COUNT - 1)) {\r
2010             errln("error: UCharacter.getIntPropertyMaxValue(UProperty.DECOMPOSITION_TYPE) wrong\n");\r
2011         }\r
2012         if( UCharacter.getIntPropertyMaxValue(UProperty.JOINING_GROUP) !=   (UCharacter.JoiningGroup.COUNT -1)) {\r
2013             errln("error: UCharacter.getIntPropertyMaxValue(UProperty.JOINING_GROUP) wrong\n");\r
2014         }\r
2015         if( UCharacter.getIntPropertyMaxValue(UProperty.JOINING_TYPE) !=  (UCharacter.JoiningType.COUNT -1)) {\r
2016             errln("error: UCharacter.getIntPropertyMaxValue(UProperty.JOINING_TYPE) wrong\n");\r
2017         }\r
2018         if( UCharacter.getIntPropertyMaxValue(UProperty.EAST_ASIAN_WIDTH) !=  (UCharacter.EastAsianWidth.COUNT -1)) {\r
2019             errln("error: UCharacter.getIntPropertyMaxValue(UProperty.EAST_ASIAN_WIDTH) wrong\n");\r
2020         }\r
2021 \r
2022         VersionInfo version = UCharacter.getUnicodeVersion();\r
2023 \r
2024         // test hasBinaryProperty()\r
2025         for (int i = 0; i < props.length; ++ i) {\r
2026             int which = props[i][1];\r
2027             if (props[i][0] < 0) {\r
2028                 if (version.compareTo(VersionInfo.getInstance(which >> 8,\r
2029                                                           (which >> 4) & 0xF,\r
2030                                                           which & 0xF,\r
2031                                                           0)) < 0) {\r
2032                     break;\r
2033                 }\r
2034                 continue;\r
2035             }\r
2036             String whichName;\r
2037             try {\r
2038                 whichName = UCharacter.getPropertyName(which, UProperty.NameChoice.LONG);\r
2039             } catch(IllegalArgumentException e) {\r
2040                 // There are intentionally invalid property integer values ("which").\r
2041                 // Catch and ignore the exception from getPropertyName().\r
2042                 whichName = "undefined UProperty value";\r
2043             }\r
2044             boolean expect = true;\r
2045             if (props[i][2] == 0) {\r
2046                 expect = false;\r
2047             }\r
2048             if (which < UProperty.INT_START) {\r
2049                 if (UCharacter.hasBinaryProperty(props[i][0], which)\r
2050                     != expect) {\r
2051                     errln("error: UCharacter.hasBinaryProperty(U+" +\r
2052                             Utility.hex(props[i][0], 4) + ", " +\r
2053                           whichName + ") has an error, expected=" + expect);\r
2054                 }\r
2055             }\r
2056 \r
2057             int retVal = UCharacter.getIntPropertyValue(props[i][0], which);\r
2058             if (retVal != props[i][2]) {\r
2059                 errln("error: UCharacter.getIntPropertyValue(U+" +\r
2060                       Utility.hex(props[i][0], 4) +\r
2061                       ", " + whichName + ") is wrong, expected="\r
2062                       + props[i][2] + " actual=" + retVal);\r
2063             }\r
2064 \r
2065             // test separate functions, too\r
2066             switch (which) {\r
2067             case UProperty.ALPHABETIC:\r
2068                 if (UCharacter.isUAlphabetic(props[i][0]) != expect) {\r
2069                     errln("error: UCharacter.isUAlphabetic(\\u" +\r
2070                           Integer.toHexString(props[i][0]) +\r
2071                           ") is wrong expected " + props[i][2]);\r
2072                 }\r
2073                 break;\r
2074             case UProperty.LOWERCASE:\r
2075                 if (UCharacter.isULowercase(props[i][0]) != expect) {\r
2076                     errln("error: UCharacter.isULowercase(\\u" +\r
2077                           Integer.toHexString(props[i][0]) +\r
2078                           ") is wrong expected " +props[i][2]);\r
2079                 }\r
2080                 break;\r
2081             case UProperty.UPPERCASE:\r
2082                 if (UCharacter.isUUppercase(props[i][0]) != expect) {\r
2083                     errln("error: UCharacter.isUUppercase(\\u" +\r
2084                           Integer.toHexString(props[i][0]) +\r
2085                           ") is wrong expected " + props[i][2]);\r
2086                 }\r
2087                 break;\r
2088             case UProperty.WHITE_SPACE:\r
2089                 if (UCharacter.isUWhiteSpace(props[i][0]) != expect) {\r
2090                     errln("error: UCharacter.isUWhiteSpace(\\u" +\r
2091                           Integer.toHexString(props[i][0]) +\r
2092                           ") is wrong expected " + props[i][2]);\r
2093                 }\r
2094                 break;\r
2095             default:\r
2096                 break;\r
2097             }\r
2098         }\r
2099     }\r
2100 \r
2101     public void TestNumericProperties()\r
2102     {\r
2103         // see UnicodeData.txt, DerivedNumericValues.txt\r
2104         double values[][] = {\r
2105             { 0x0F33, UCharacter.NumericType.NUMERIC, -1./2. },\r
2106             { 0x0C66, UCharacter.NumericType.DECIMAL, 0 },\r
2107             { 0x96f6, UCharacter.NumericType.NUMERIC, 0 },\r
2108             { 0xa833, UCharacter.NumericType.NUMERIC, 1./16. },\r
2109             { 0x2152, UCharacter.NumericType.NUMERIC, 1./10. },\r
2110             { 0x2151, UCharacter.NumericType.NUMERIC, 1./9. },\r
2111             { 0x1245f, UCharacter.NumericType.NUMERIC, 1./8. },\r
2112             { 0x2150, UCharacter.NumericType.NUMERIC, 1./7. },\r
2113             { 0x2159, UCharacter.NumericType.NUMERIC, 1./6. },\r
2114             { 0x09f6, UCharacter.NumericType.NUMERIC, 3./16. },\r
2115             { 0x2155, UCharacter.NumericType.NUMERIC, 1./5. },\r
2116             { 0x00BD, UCharacter.NumericType.NUMERIC, 1./2. },\r
2117             { 0x0031, UCharacter.NumericType.DECIMAL, 1. },\r
2118             { 0x4e00, UCharacter.NumericType.NUMERIC, 1. },\r
2119             { 0x58f1, UCharacter.NumericType.NUMERIC, 1. },\r
2120             { 0x10320, UCharacter.NumericType.NUMERIC, 1. },\r
2121             { 0x0F2B, UCharacter.NumericType.NUMERIC, 3./2. },\r
2122             { 0x00B2, UCharacter.NumericType.DIGIT, 2. }, /* Unicode 4.0 change */\r
2123             { 0x5f10, UCharacter.NumericType.NUMERIC, 2. },\r
2124             { 0x1813, UCharacter.NumericType.DECIMAL, 3. },\r
2125             { 0x5f0e, UCharacter.NumericType.NUMERIC, 3. },\r
2126             { 0x2173, UCharacter.NumericType.NUMERIC, 4. },\r
2127             { 0x8086, UCharacter.NumericType.NUMERIC, 4. },\r
2128             { 0x278E, UCharacter.NumericType.DIGIT, 5. },\r
2129             { 0x1D7F2, UCharacter.NumericType.DECIMAL, 6. },\r
2130             { 0x247A, UCharacter.NumericType.DIGIT, 7. },\r
2131             { 0x7396, UCharacter.NumericType.NUMERIC, 9. },\r
2132             { 0x1372, UCharacter.NumericType.NUMERIC, 10. },\r
2133             { 0x216B, UCharacter.NumericType.NUMERIC, 12. },\r
2134             { 0x16EE, UCharacter.NumericType.NUMERIC, 17. },\r
2135             { 0x249A, UCharacter.NumericType.NUMERIC, 19. },\r
2136             { 0x303A, UCharacter.NumericType.NUMERIC, 30. },\r
2137             { 0x5345, UCharacter.NumericType.NUMERIC, 30. },\r
2138             { 0x32B2, UCharacter.NumericType.NUMERIC, 37. },\r
2139             { 0x1375, UCharacter.NumericType.NUMERIC, 40. },\r
2140             { 0x10323, UCharacter.NumericType.NUMERIC, 50. },\r
2141             { 0x0BF1, UCharacter.NumericType.NUMERIC, 100. },\r
2142             { 0x964c, UCharacter.NumericType.NUMERIC, 100. },\r
2143             { 0x217E, UCharacter.NumericType.NUMERIC, 500. },\r
2144             { 0x2180, UCharacter.NumericType.NUMERIC, 1000. },\r
2145             { 0x4edf, UCharacter.NumericType.NUMERIC, 1000. },\r
2146             { 0x2181, UCharacter.NumericType.NUMERIC, 5000. },\r
2147             { 0x137C, UCharacter.NumericType.NUMERIC, 10000. },\r
2148             { 0x4e07, UCharacter.NumericType.NUMERIC, 10000. },\r
2149             { 0x4ebf, UCharacter.NumericType.NUMERIC, 100000000. },\r
2150             { 0x5146, UCharacter.NumericType.NUMERIC, 1000000000000. },\r
2151             { -1, UCharacter.NumericType.NONE, UCharacter.NO_NUMERIC_VALUE },\r
2152             { 0x61, UCharacter.NumericType.NONE, UCharacter.NO_NUMERIC_VALUE },\r
2153             { 0x3000, UCharacter.NumericType.NONE, UCharacter.NO_NUMERIC_VALUE },\r
2154             { 0xfffe, UCharacter.NumericType.NONE, UCharacter.NO_NUMERIC_VALUE },\r
2155             { 0x10301, UCharacter.NumericType.NONE, UCharacter.NO_NUMERIC_VALUE },\r
2156             { 0xe0033, UCharacter.NumericType.NONE, UCharacter.NO_NUMERIC_VALUE },\r
2157             { 0x10ffff, UCharacter.NumericType.NONE, UCharacter.NO_NUMERIC_VALUE },\r
2158             { 0x110000, UCharacter.NumericType.NONE, UCharacter.NO_NUMERIC_VALUE }\r
2159         };\r
2160 \r
2161         for (int i = 0; i < values.length; ++ i) {\r
2162             int c = (int)values[i][0];\r
2163             int type = UCharacter.getIntPropertyValue(c,\r
2164                                                       UProperty.NUMERIC_TYPE);\r
2165             double nv = UCharacter.getUnicodeNumericValue(c);\r
2166 \r
2167             if (type != values[i][1]) {\r
2168                 errln("UProperty.NUMERIC_TYPE(\\u" + Utility.hex(c, 4)\r
2169                        + ") = " + type + " should be " + (int)values[i][1]);\r
2170             }\r
2171             if (0.000001 <= Math.abs(nv - values[i][2])) {\r
2172                 errln("UCharacter.getNumericValue(\\u" + Utility.hex(c, 4)\r
2173                         + ") = " + nv + " should be " + values[i][2]);\r
2174             }\r
2175         }\r
2176     }\r
2177 \r
2178     /**\r
2179      * Test the property values API.  See JB#2410.\r
2180      */\r
2181     public void TestPropertyValues() {\r
2182         int i, p, min, max;\r
2183 \r
2184         /* Min should be 0 for everything. */\r
2185         /* Until JB#2478 is fixed, the one exception is UProperty.BLOCK. */\r
2186         for (p=UProperty.INT_START; p<UProperty.INT_LIMIT; ++p) {\r
2187             min = UCharacter.getIntPropertyMinValue(p);\r
2188             if (min != 0) {\r
2189                 if (p == UProperty.BLOCK) {\r
2190                     /* This is okay...for now.  See JB#2487.\r
2191                        TODO Update this for JB#2487. */\r
2192                 } else {\r
2193                     String name;\r
2194                     name = UCharacter.getPropertyName(p, UProperty.NameChoice.LONG);\r
2195                     errln("FAIL: UCharacter.getIntPropertyMinValue(" + name + ") = " +\r
2196                           min + ", exp. 0");\r
2197                 }\r
2198             }\r
2199         }\r
2200 \r
2201         if (UCharacter.getIntPropertyMinValue(UProperty.GENERAL_CATEGORY_MASK)\r
2202             != 0\r
2203             || UCharacter.getIntPropertyMaxValue(\r
2204                                                UProperty.GENERAL_CATEGORY_MASK)\r
2205                != -1) {\r
2206             errln("error: UCharacter.getIntPropertyMin/MaxValue("\r
2207                   + "UProperty.GENERAL_CATEGORY_MASK) is wrong");\r
2208         }\r
2209 \r
2210         /* Max should be -1 for invalid properties. */\r
2211         max = UCharacter.getIntPropertyMaxValue(-1);\r
2212         if (max != -1) {\r
2213             errln("FAIL: UCharacter.getIntPropertyMaxValue(-1) = " +\r
2214                   max + ", exp. -1");\r
2215         }\r
2216 \r
2217         /* Script should return 0 for an invalid code point. If the API\r
2218            throws an exception then that's fine too. */\r
2219         for (i=0; i<2; ++i) {\r
2220             try {\r
2221                 int script = 0;\r
2222                 String desc = null;\r
2223                 switch (i) {\r
2224                 case 0:\r
2225                     script = UScript.getScript(-1);\r
2226                     desc = "UScript.getScript(-1)";\r
2227                     break;\r
2228                 case 1:\r
2229                     script = UCharacter.getIntPropertyValue(-1, UProperty.SCRIPT);\r
2230                     desc = "UCharacter.getIntPropertyValue(-1, UProperty.SCRIPT)";\r
2231                     break;\r
2232                 }\r
2233                 if (script != 0) {\r
2234                     errln("FAIL: " + desc + " = " + script + ", exp. 0");\r
2235                 }\r
2236             } catch (IllegalArgumentException e) {}\r
2237         }\r
2238     }\r
2239 \r
2240     public void TestIsBMP()\r
2241     {\r
2242         int ch[] = {0x0, -1, 0xffff, 0x10ffff, 0xff, 0x1ffff};\r
2243         boolean flag[] = {true, false, true, false, true, false};\r
2244         for (int i = 0; i < ch.length; i ++) {\r
2245             if (UCharacter.isBMP(ch[i]) != flag[i]) {\r
2246                 errln("Fail: \\u" + Utility.hex(ch[i], 8)\r
2247                       + " failed at UCharacter.isBMP");\r
2248             }\r
2249         }\r
2250     }\r
2251 \r
2252     private boolean showADiffB(UnicodeSet a, UnicodeSet b,\r
2253                                         String a_name, String b_name,\r
2254                                         boolean expect,\r
2255                                         boolean diffIsError){\r
2256         int i, start, end, length;\r
2257         boolean equal;\r
2258         equal=true;\r
2259         i=0;\r
2260         for(;;) {\r
2261             start  = a.getRangeStart(i);\r
2262             length = (i < a.getRangeCount()) ? 0 : a.getRangeCount();\r
2263             end    = a.getRangeEnd(i);\r
2264 \r
2265             if(length!=0) {\r
2266                 return equal; /* done with code points, got a string or -1 */\r
2267             }\r
2268 \r
2269             if(expect!=b.contains(start, end)) {\r
2270                 equal=false;\r
2271                 while(start<=end) {\r
2272                     if(expect!=b.contains(start)) {\r
2273                         if(diffIsError) {\r
2274                             if(expect) {\r
2275                                 errln("error: "+ a_name +" contains "+ hex(start)+" but "+ b_name +" does not");\r
2276                             } else {\r
2277                                 errln("error: "+a_name +" and "+ b_name+" both contain "+hex(start) +" but should not intersect");\r
2278                             }\r
2279                         } else {\r
2280                             if(expect) {\r
2281                                 logln("info: "+a_name +" contains "+hex(start)+ "but " + b_name +" does not");\r
2282                             } else {\r
2283                                 logln("info: "+a_name +" and "+b_name+" both contain "+hex(start)+" but should not intersect");\r
2284                             }\r
2285                         }\r
2286                     }\r
2287                     ++start;\r
2288                 }\r
2289             }\r
2290 \r
2291             ++i;\r
2292         }\r
2293     }\r
2294     private boolean showAMinusB(UnicodeSet a, UnicodeSet b,\r
2295                                         String a_name, String b_name,\r
2296                                         boolean diffIsError) {\r
2297 \r
2298         return showADiffB(a, b, a_name, b_name, true, diffIsError);\r
2299     }\r
2300 \r
2301     private boolean showAIntersectB(UnicodeSet a, UnicodeSet b,\r
2302                                             String a_name, String b_name,\r
2303                                             boolean diffIsError) {\r
2304         return showADiffB(a, b, a_name, b_name, false, diffIsError);\r
2305     }\r
2306 \r
2307     private boolean compareUSets(UnicodeSet a, UnicodeSet b,\r
2308                                          String a_name, String b_name,\r
2309                                          boolean diffIsError) {\r
2310         return\r
2311             showAMinusB(a, b, a_name, b_name, diffIsError) &&\r
2312             showAMinusB(b, a, b_name, a_name, diffIsError);\r
2313     }\r
2314 \r
2315    /* various tests for consistency of UCD data and API behavior */\r
2316    public void TestConsistency() {\r
2317        UnicodeSet set1, set2, set3, set4;\r
2318 \r
2319        int start, end;\r
2320        int i, length;\r
2321 \r
2322        String hyphenPattern = "[:Hyphen:]";\r
2323        String dashPattern = "[:Dash:]";\r
2324        String lowerPattern = "[:Lowercase:]";\r
2325        String formatPattern = "[:Cf:]";\r
2326        String alphaPattern  =  "[:Alphabetic:]";\r
2327 \r
2328        /*\r
2329         * It used to be that UCD.html and its precursors said\r
2330         * "Those dashes used to mark connections between pieces of words,\r
2331         *  plus the Katakana middle dot."\r
2332         *\r
2333         * Unicode 4 changed 00AD Soft Hyphen to Cf and removed it from Dash\r
2334         * but not from Hyphen.\r
2335         * UTC 94 (2003mar) decided to leave it that way and to changed UCD.html.\r
2336         * Therefore, do not show errors when testing the Hyphen property.\r
2337         */\r
2338        logln("Starting with Unicode 4, inconsistencies with [:Hyphen:] are\n"\r
2339                    + "known to the UTC and not considered errors.\n");\r
2340 \r
2341        set1=new UnicodeSet(hyphenPattern);\r
2342        set2=new UnicodeSet(dashPattern);\r
2343 \r
2344            /* remove the Katakana middle dot(s) from set1 */\r
2345            set1.remove(0x30fb);\r
2346            set2.remove (0xff65); /* halfwidth variant */\r
2347            showAMinusB(set1, set2, "[:Hyphen:]", "[:Dash:]", false);\r
2348 \r
2349 \r
2350        /* check that Cf is neither Hyphen nor Dash nor Alphabetic */\r
2351        set3=new UnicodeSet(formatPattern);\r
2352        set4=new UnicodeSet(alphaPattern);\r
2353 \r
2354        showAIntersectB(set3, set1, "[:Cf:]", "[:Hyphen:]", false);\r
2355        showAIntersectB(set3, set2, "[:Cf:]", "[:Dash:]", true);\r
2356        showAIntersectB(set3, set4, "[:Cf:]", "[:Alphabetic:]", true);\r
2357        /*\r
2358         * Check that each lowercase character has "small" in its name\r
2359         * and not "capital".\r
2360         * There are some such characters, some of which seem odd.\r
2361         * Use the verbose flag to see these notices.\r
2362         */\r
2363        set1=new UnicodeSet(lowerPattern);\r
2364 \r
2365        for(i=0;; ++i) {\r
2366 //               try{\r
2367 //                   length=set1.getItem(set1, i, &start, &end, NULL, 0, &errorCode);\r
2368 //               }catch(Exception e){\r
2369 //                   break;\r
2370 //               }\r
2371             start = set1.getRangeStart(i);\r
2372             end = set1.getRangeEnd(i);\r
2373             length = i<set1.getRangeCount() ? set1.getRangeCount() : 0;\r
2374            if(length!=0) {\r
2375                break; /* done with code points, got a string or -1 */\r
2376            }\r
2377 \r
2378            while(start<=end) {\r
2379                String name=UCharacter.getName(start);\r
2380 \r
2381                if( (name.indexOf("SMALL")< 0 || name.indexOf("CAPITAL")<-1) &&\r
2382                    name.indexOf("SMALL CAPITAL")==-1\r
2383                ) {\r
2384                    logln("info: [:Lowercase:] contains U+"+hex(start) + " whose name does not suggest lowercase: " + name);\r
2385                }\r
2386                ++start;\r
2387            }\r
2388        }\r
2389 \r
2390 \r
2391        /*\r
2392         * Test for an example that unorm_getCanonStartSet() delivers\r
2393         * all characters that compose from the input one,\r
2394         * even in multiple steps.\r
2395         * For example, the set for "I" (0049) should contain both\r
2396         * I-diaeresis (00CF) and I-diaeresis-acute (1E2E).\r
2397         * In general, the set for the middle such character should be a subset\r
2398         * of the set for the first.\r
2399         */\r
2400        Normalizer2 norm2=Normalizer2.getInstance(null, "nfc", Normalizer2.Mode.DECOMPOSE);\r
2401        set1=new UnicodeSet();\r
2402        Norm2AllModes.getNFCInstance().impl.\r
2403            ensureCanonIterData().getCanonStartSet(0x49, set1);\r
2404        set2=new UnicodeSet();\r
2405 \r
2406        /* enumerate all characters that are plausible to be latin letters */\r
2407        for(start=0xa0; start<0x2000; ++start) {\r
2408            String decomp=norm2.normalize(UTF16.valueOf(start));\r
2409            if(decomp.length() > 1 && decomp.charAt(0)==0x49) {\r
2410                set2.add(start);\r
2411            }\r
2412        }\r
2413 \r
2414        compareUSets(set1, set2,\r
2415                     "[canon start set of 0049]", "[all c with canon decomp with 0049]",\r
2416                     false);\r
2417 \r
2418    }\r
2419 \r
2420     public void TestCoverage() {\r
2421         //cover forDigit\r
2422         char ch1 = UCharacter.forDigit(7, 11);\r
2423         assertEquals("UCharacter.forDigit ", "7", String.valueOf(ch1));\r
2424         char ch2 = UCharacter.forDigit(17, 20);\r
2425         assertEquals("UCharacter.forDigit ", "h", String.valueOf(ch2));\r
2426 \r
2427         //Jitterbug 4451, for coverage\r
2428         for (int i = 0x0041; i < 0x005B; i++) {\r
2429             if (!UCharacter.isJavaLetter(i))\r
2430                 errln("FAIL \\u" + hex(i) + " expected to be a letter");\r
2431             if (!UCharacter.isJavaIdentifierStart(i))\r
2432                 errln("FAIL \\u" + hex(i) + " expected to be a Java identifier start character");\r
2433             if (!UCharacter.isJavaLetterOrDigit(i))\r
2434                 errln("FAIL \\u" + hex(i) + " expected not to be a Java letter");\r
2435             if (!UCharacter.isJavaIdentifierPart(i))\r
2436                 errln("FAIL \\u" + hex(i) + " expected to be a Java identifier part character");\r
2437         }\r
2438         char[] spaces = {'\t','\n','\f','\r',' '};\r
2439         for (int i = 0; i < spaces.length; i++){\r
2440             if (!UCharacter.isSpace(spaces[i]))\r
2441                 errln("FAIL \\u" + hex(spaces[i]) + " expected to be a Java space");\r
2442         }\r
2443     }\r
2444 \r
2445     public void TestCasePropsDummy() {\r
2446         // code coverage for UCaseProps.getDummy() \r
2447         if(UCaseProps.getDummy().tolower(0x41)!=0x41) {\r
2448             errln("UCaseProps.getDummy().tolower(0x41)!=0x41");\r
2449         }\r
2450     }\r
2451 \r
2452     public void TestBiDiPropsDummy() {\r
2453         // code coverage for UBiDiProps.getDummy() \r
2454         if(UBiDiProps.getDummy().getClass(0x20)!=0) {\r
2455             errln("UBiDiProps.getDummy().getClass(0x20)!=0");\r
2456         }\r
2457     }\r
2458     \r
2459     public void TestBlockData()\r
2460     {\r
2461         Class ubc = UCharacter.UnicodeBlock.class;\r
2462         \r
2463         for (int b = 1; b < UCharacter.UnicodeBlock.COUNT; b += 1) {\r
2464             UCharacter.UnicodeBlock blk = UCharacter.UnicodeBlock.getInstance(b);\r
2465             int id = blk.getID();\r
2466             String name = blk.toString();\r
2467             \r
2468             if (id != b) {\r
2469                 errln("UCharacter.UnicodeBlock.getInstance(" + b + ") returned a block with id = " + id);\r
2470             }\r
2471             \r
2472             try {\r
2473                 if (ubc.getField(name + "_ID").getInt(blk) != b) {\r
2474                     errln("UCharacter.UnicodeBlock.getInstance(" + b + ") returned a block with a name of " + name +\r
2475                           " which does not match the block id.");\r
2476                 }\r
2477             } catch (Exception e) {\r
2478                 errln("Couldn't get the id name for id " + b);\r
2479             }\r
2480         }\r
2481     }\r
2482 \r
2483     /*\r
2484      * The following method tests\r
2485      *      public static UnicodeBlock getInstance(int id)\r
2486      */\r
2487     public void TestGetInstance(){\r
2488         // Testing values for invalid and valid ID\r
2489         int[] invalid_test = {-1,-10,-100};\r
2490         for(int i=0; i< invalid_test.length; i++){\r
2491             if(UCharacter.UnicodeBlock.INVALID_CODE != UCharacter.UnicodeBlock.getInstance(invalid_test[i])){\r
2492                 errln("UCharacter.UnicodeBlock.getInstance(invalid_test[i]) was " +\r
2493                         "suppose to return UCharacter.UnicodeBlock.INVALID_CODE. Got " +\r
2494                         UCharacter.UnicodeBlock.getInstance(invalid_test[i]) + ". Expected " +\r
2495                         UCharacter.UnicodeBlock.INVALID_CODE);\r
2496             }\r
2497         }\r
2498     }\r
2499 \r
2500     /*\r
2501      * The following method tests\r
2502      *      public static UnicodeBlock of(int ch)\r
2503      */\r
2504     public void TestOf(){\r
2505         if(UCharacter.UnicodeBlock.INVALID_CODE != UCharacter.UnicodeBlock.of(UTF16.CODEPOINT_MAX_VALUE+1)){\r
2506             errln("UCharacter.UnicodeBlock.of(UTF16.CODEPOINT_MAX_VALUE+1) was " +\r
2507                     "suppose to return UCharacter.UnicodeBlock.INVALID_CODE. Got " +\r
2508                     UCharacter.UnicodeBlock.of(UTF16.CODEPOINT_MAX_VALUE+1) + ". Expected " +\r
2509                     UCharacter.UnicodeBlock.INVALID_CODE);\r
2510         }\r
2511     }\r
2512 \r
2513     /*\r
2514      * The following method tests\r
2515      *      static int idOf(int ch)\r
2516      */\r
2517     public void TestIDOf(){\r
2518         int[] invalid_test = {-2, -1, UTF16.CODEPOINT_MAX_VALUE+1, UTF16.CODEPOINT_MAX_VALUE+2};\r
2519         \r
2520         for(int i=0; i < invalid_test.length; i++){\r
2521             int result = UCharacter.getIntPropertyValue(invalid_test[i], UProperty.BLOCK);\r
2522             if(result != -1){\r
2523                 errln("UCharacter.UnicodeBlock.idOf() was suppose to return -1. Got " + result);\r
2524             }\r
2525         }\r
2526         \r
2527         int[] valid_test = {0, 1, UTF16.CODEPOINT_MAX_VALUE, UTF16.CODEPOINT_MAX_VALUE-1};\r
2528         \r
2529         for(int i=0; i < valid_test.length; i++){\r
2530             int result = UCharacter.getIntPropertyValue(valid_test[i], UProperty.BLOCK);\r
2531             if(result == -1){\r
2532                 errln("UCharacter.UnicodeBlock.idOf() was not suppose to return -1. Got " + result);\r
2533             }\r
2534         }\r
2535     }\r
2536     \r
2537     /*\r
2538      * The following method tests\r
2539      *      public static final UnicodeBlock forName(String blockName)\r
2540      */\r
2541     public void TestForName(){\r
2542         //UCharacter.UnicodeBlock.forName("");\r
2543         //Tests when "if (b == null)" is true\r
2544     }\r
2545     \r
2546     /*\r
2547      * The following method tests\r
2548      *      public static int getNumericValue(int ch)\r
2549      */\r
2550     public void TestGetNumericValue(){\r
2551         // The following tests the else statement when\r
2552         //      if(numericType<NumericType.COUNT) is false\r
2553         // The following values were obtained by testing all values from\r
2554         //      UTF16.CODEPOINT_MIN_VALUE to UTF16.CODEPOINT_MAX_VALUE inclusively\r
2555         //      to obtain the value to go through the else statement.\r
2556         int[] valid_values =\r
2557             {3058,3442,4988,8558,8559,8574,8575,8576,8577,8578,8583,8584,19975,\r
2558              20159,20191,20740,20806,21315,33836,38433,65819,65820,65821,65822,\r
2559              65823,65824,65825,65826,65827,65828,65829,65830,65831,65832,65833,\r
2560              65834,65835,65836,65837,65838,65839,65840,65841,65842,65843,65861,\r
2561              65862,65863,65868,65869,65870,65875,65876,65877,65878,65899,65900,\r
2562              65901,65902,65903,65904,65905,65906,66378,68167};\r
2563         \r
2564         int[] results =\r
2565             {1000,1000,10000,500,1000,500,1000,1000,5000,10000,50000,100000,\r
2566              10000,100000000,1000,100000000,-2,1000,10000,1000,300,400,500,\r
2567              600,700,800,900,1000,2000,3000,4000,5000,6000,7000,8000,9000,\r
2568              10000,20000,30000,40000,50000,60000,70000,80000,90000,500,5000,\r
2569              50000,500,1000,5000,500,1000,10000,50000,300,500,500,500,500,500,\r
2570              1000,5000,900,1000};\r
2571         \r
2572         if(valid_values.length != results.length){\r
2573             errln("The valid_values array and the results array need to be "+\r
2574                     "the same length.");\r
2575         } else {\r
2576             for(int i = 0; i < valid_values.length; i++){\r
2577                 try{\r
2578                     if(UCharacter.getNumericValue(valid_values[i]) != results[i]){\r
2579                         errln("UCharacter.getNumericValue(i) returned a " +\r
2580                                 "different value from the expected result. " +\r
2581                                 "Got " + UCharacter.getNumericValue(valid_values[i]) +\r
2582                                 "Expected" + results[i]);\r
2583                     }\r
2584                 } catch(Exception e){\r
2585                     errln("UCharacter.getNumericValue(int) returned an exception " +\r
2586                             "with the parameter value");\r
2587                 }\r
2588             }\r
2589         }\r
2590     }\r
2591 \r
2592     /*\r
2593      * The following method tests\r
2594      *      public static double getUnicodeNumericValue(int ch)\r
2595      */\r
2596     // The following tests covers if(mant==0), else if(mant > 9), and default\r
2597     public void TestGetUnicodeNumericValue(){\r
2598         /*  The code coverage for if(mant==0), else if(mant > 9), and default\r
2599          *  could not be covered even with input values from UTF16.CODEPOINT_MIN_VALUE\r
2600          *  to UTF16.CODEPOINT_MAX_VALUE. I also tested from UTF16.CODEPOINT_MAX_VALUE to\r
2601          *  Integer.MAX_VALUE and didn't recieve any code coverage there too.\r
2602          *  Therefore, the code could either be dead code or meaningless. \r
2603          */\r
2604     }\r
2605 \r
2606     /*\r
2607      * The following method tests\r
2608      *      public static String toString(int ch)\r
2609      */\r
2610     public void TestToString(){\r
2611         int[] valid_tests = {\r
2612                 UCharacter.MIN_VALUE, UCharacter.MIN_VALUE+1,\r
2613                 UCharacter.MAX_VALUE-1, UCharacter.MAX_VALUE};\r
2614         int[] invalid_tests = {\r
2615                 UCharacter.MIN_VALUE-1, UCharacter.MIN_VALUE-2,\r
2616                 UCharacter.MAX_VALUE+1, UCharacter.MAX_VALUE+2};\r
2617         \r
2618         for(int i=0; i< valid_tests.length; i++){\r
2619             if(UCharacter.toString(valid_tests[i]) == null){\r
2620                 errln("UCharacter.toString(int) was not suppose to return " +\r
2621                 "null because it was given a valid parameter. Value passed: " +\r
2622                 valid_tests[i] + ". Got null.");\r
2623             }\r
2624         }\r
2625         \r
2626         for(int i=0; i< invalid_tests.length; i++){\r
2627             if(UCharacter.toString(invalid_tests[i]) != null){\r
2628                 errln("UCharacter.toString(int) was suppose to return " +\r
2629                 "null because it was given an invalid parameter. Value passed: " +\r
2630                 invalid_tests[i] + ". Got: " + UCharacter.toString(invalid_tests[i]));\r
2631             }\r
2632         }\r
2633     }\r
2634 \r
2635     /*\r
2636      * The following method tests\r
2637      *      public static int getCombiningClass(int ch)\r
2638      */\r
2639     public void TestGetCombiningClass(){\r
2640         int[] valid_tests = {\r
2641                 UCharacter.MIN_VALUE, UCharacter.MIN_VALUE+1,\r
2642                 UCharacter.MAX_VALUE-1, UCharacter.MAX_VALUE};\r
2643         int[] invalid_tests = {\r
2644                 UCharacter.MIN_VALUE-1, UCharacter.MIN_VALUE-2,\r
2645                 UCharacter.MAX_VALUE+1, UCharacter.MAX_VALUE+2};\r
2646         \r
2647         for(int i=0; i< valid_tests.length; i++){\r
2648             try{\r
2649                 UCharacter.getCombiningClass(valid_tests[i]);\r
2650             } catch(Exception e){\r
2651                 errln("UCharacter.getCombiningClass(int) was not suppose to have " +\r
2652                         "an exception. Value passed: " + valid_tests[i]);\r
2653             }\r
2654         }\r
2655             \r
2656         for(int i=0; i< invalid_tests.length; i++){\r
2657             try{\r
2658                 UCharacter.getCombiningClass(invalid_tests[i]);\r
2659                 errln("UCharacter.getCombiningClass(int) was suppose to have " +\r
2660                         "an exception. Value passed: " + invalid_tests[i]);\r
2661             } catch(Exception e){\r
2662             }\r
2663         }\r
2664     }\r
2665 \r
2666     /*\r
2667      * The following method tests\r
2668      *      public static String getName(int ch)\r
2669      */\r
2670     public void TestGetName(){\r
2671         // Need to test on other "one characters" for the getName() method\r
2672         String[] data = {"a","z"};\r
2673         String[] results = {"LATIN SMALL LETTER A","LATIN SMALL LETTER Z"};\r
2674         if(data.length != results.length){\r
2675             errln("The data array and the results array need to be "+\r
2676                     "the same length.");\r
2677         } else {\r
2678             for(int i=0; i < data.length; i++){\r
2679                 if(UCharacter.getName(data[i], "").compareTo(results[i]) != 0){\r
2680                     errln("UCharacter.getName(String, String) was suppose " +\r
2681                             "to have the same result for the data in the parameter. " +\r
2682                             "Value passed: " + data[i] + ". Got: " +\r
2683                             UCharacter.getName(data[i], "") + ". Expected: " +\r
2684                             results[i]);\r
2685                 }\r
2686             }\r
2687         }\r
2688     }\r
2689     \r
2690     /*\r
2691      * The following method tests\r
2692      *      public static String getISOComment(int ch)\r
2693      */\r
2694     public void TestGetISOComment(){\r
2695         int[] invalid_tests = {\r
2696                 UCharacter.MIN_VALUE-1, UCharacter.MIN_VALUE-2,\r
2697                 UCharacter.MAX_VALUE+1, UCharacter.MAX_VALUE+2};\r
2698         \r
2699         for(int i=0; i< invalid_tests.length; i++){\r
2700             if(UCharacter.getISOComment(invalid_tests[i]) != null){\r
2701                 errln("UCharacter.getISOComment(int) was suppose to return " +\r
2702                 "null because it was given an invalid parameter. Value passed: " +\r
2703                 invalid_tests[i] + ". Got: " + UCharacter.getISOComment(invalid_tests[i]));\r
2704             }\r
2705         }\r
2706     }\r
2707 \r
2708     /*\r
2709      * The following method tests\r
2710      *      public void setLimit(int lim)\r
2711      */\r
2712     public void TestSetLimit(){\r
2713         // TODO: Tests when "if(0<=lim && lim<=s.length())" is false\r
2714     }\r
2715 \r
2716     /*\r
2717      * The following method tests\r
2718      *      public int nextCaseMapCP()\r
2719      */\r
2720     public void TestNextCaseMapCP(){\r
2721         // TODO: Tests when "if(UTF16.LEAD_SURROGATE_MIN_VALUE<=c || c<=UTF16.TRAIL_SURROGATE_MAX_VALUE)" is false\r
2722         /* TODO: Tests when "if( c<=UTF16.LEAD_SURROGATE_MAX_VALUE && cpLimit<limit &&\r
2723          * UTF16.TRAIL_SURROGATE_MIN_VALUE<=(c2=s.charAt(cpLimit)) && c2<=UTF16.TRAIL_SURROGATE_MAX_VALUE)" is false\r
2724          */\r
2725     }\r
2726 \r
2727     /*\r
2728      * The following method tests\r
2729      *      public void reset(int direction)\r
2730      */\r
2731     public void TestReset(){\r
2732         // The method reset() is never called by another function\r
2733         // TODO: Tests when "else if(direction<0)" is false\r
2734     }\r
2735 \r
2736     /*\r
2737      * The following method tests\r
2738      *      public static String toTitleCase(Locale locale, String str, BreakIterator breakiter)\r
2739      */\r
2740     public void TestToTitleCaseCoverage(){\r
2741         //Calls the function "toTitleCase(Locale locale, String str, BreakIterator breakiter)"\r
2742         String[] locale={"en","fr","zh","ko","ja","it","de",""};\r
2743         for(int i=0; i<locale.length; i++){\r
2744             UCharacter.toTitleCase(new Locale(locale[i]), "", null);\r
2745         }\r
2746         \r
2747         // Calls the function "String toTitleCase(ULocale locale, String str, BreakIterator titleIter, int options)"\r
2748         // Tests when "if (locale == null)" is true\r
2749         UCharacter.toTitleCase(null, "", null, 0);\r
2750         \r
2751         // TODO: Tests when "if(index==BreakIterator.DONE || index>srcLength)" is true\r
2752         // TODO: Tests when "while((c=iter.nextCaseMapCP())>=0 && UCaseProps.NONE==gCsp.getType(c))" is false\r
2753         // TODO: Tests when "if(prev<titleStart)" is false\r
2754         // TODO: Tests when "if(c<=0xffff)" is false\r
2755         // TODO: Tests when "if(c<=0xffff)" is false\r
2756         // TODO: Tests when "if(titleLimit<index)" is false\r
2757         // TODO: Tests when "else if((nc=iter.nextCaseMapCP())>=0)" is false\r
2758     }\r
2759     /*\r
2760      * The following method tests\r
2761      *      public static String toUpperCase(ULocale locale, String str)\r
2762      */\r
2763     public void TestToUpperCase(){\r
2764         // TODO: Tests when "while((c=iter.nextCaseMapCP())>=0)" is false\r
2765     }\r
2766 \r
2767     /*\r
2768      * The following method tests\r
2769      *      public static String toLowerCase(ULocale locale, String str)\r
2770      */\r
2771     public void TestToLowerCase(){\r
2772         // Test when locale is null\r
2773         String[] cases = {"","a","A","z","Z","Dummy","DUMMY","dummy","a z","A Z",\r
2774                 "'","\"","0","9","0a","a0","*","~!@#$%^&*()_+"};\r
2775         for(int i=0; i<cases.length; i++){\r
2776             try{\r
2777                 UCharacter.toLowerCase((ULocale) null, cases[i]);\r
2778             } catch(Exception e){\r
2779                 errln("UCharacter.toLowerCase was not suppose to return an " +\r
2780                         "exception for input of null and string: " + cases[i]);\r
2781             }\r
2782         }\r
2783         // TODO: Tests when "while((c=iter.nextCaseMapCP())>=0)" is false\r
2784     }\r
2785 \r
2786     /*\r
2787      * The following method tests\r
2788      *      public static int getHanNumericValue(int ch)\r
2789      */\r
2790     public void TestGetHanNumericValue(){\r
2791         int[] valid = {\r
2792                 0x3007, //IDEOGRAPHIC_NUMBER_ZERO_\r
2793                 0x96f6, //CJK_IDEOGRAPH_COMPLEX_ZERO_\r
2794                 0x4e00, //CJK_IDEOGRAPH_FIRST_\r
2795                 0x58f9, //CJK_IDEOGRAPH_COMPLEX_ONE_\r
2796                 0x4e8c, //CJK_IDEOGRAPH_SECOND_\r
2797                 0x8cb3, //CJK_IDEOGRAPH_COMPLEX_TWO_\r
2798                 0x4e09, //CJK_IDEOGRAPH_THIRD_\r
2799                 0x53c3, //CJK_IDEOGRAPH_COMPLEX_THREE_\r
2800                 0x56d8, //CJK_IDEOGRAPH_FOURTH_\r
2801                 0x8086, //CJK_IDEOGRAPH_COMPLEX_FOUR_\r
2802                 0x4e94, //CJK_IDEOGRAPH_FIFTH_\r
2803                 0x4f0d, //CJK_IDEOGRAPH_COMPLEX_FIVE_\r
2804                 0x516d, //CJK_IDEOGRAPH_SIXTH_\r
2805                 0x9678, //CJK_IDEOGRAPH_COMPLEX_SIX_\r
2806                 0x4e03, //CJK_IDEOGRAPH_SEVENTH_\r
2807                 0x67d2, //CJK_IDEOGRAPH_COMPLEX_SEVEN_\r
2808                 0x516b, //CJK_IDEOGRAPH_EIGHTH_\r
2809                 0x634c, //CJK_IDEOGRAPH_COMPLEX_EIGHT_\r
2810                 0x4e5d, //CJK_IDEOGRAPH_NINETH_\r
2811                 0x7396, //CJK_IDEOGRAPH_COMPLEX_NINE_\r
2812                 0x5341, //CJK_IDEOGRAPH_TEN_\r
2813                 0x62fe, //CJK_IDEOGRAPH_COMPLEX_TEN_\r
2814                 0x767e, //CJK_IDEOGRAPH_HUNDRED_\r
2815                 0x4f70, //CJK_IDEOGRAPH_COMPLEX_HUNDRED_\r
2816                 0x5343, //CJK_IDEOGRAPH_THOUSAND_\r
2817                 0x4edf, //CJK_IDEOGRAPH_COMPLEX_THOUSAND_\r
2818                 0x824c, //CJK_IDEOGRAPH_TEN_THOUSAND_\r
2819                 0x5104, //CJK_IDEOGRAPH_HUNDRED_MILLION_\r
2820         };\r
2821         \r
2822         int[] invalid = {-5,-2,-1,0};\r
2823         \r
2824         int[] results = {0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,100,100,\r
2825                 1000,1000,10000,100000000};\r
2826         \r
2827         if(valid.length != results.length){\r
2828             errln("The arrays valid and results are suppose to be the same length " +\r
2829                     "to test getHanNumericValue(int ch).");\r
2830         } else{\r
2831             for(int i=0; i<valid.length; i++){\r
2832                 if(UCharacter.getHanNumericValue(valid[i]) != results[i]){\r
2833                     errln("UCharacter.getHanNumericValue does not return the " + \r
2834                             "same result as expected. Passed value: " + valid[i] +\r
2835                             ". Got: " + UCharacter.getHanNumericValue(valid[i]) +\r
2836                             ". Expected: " + results[i]);\r
2837                 }\r
2838             }\r
2839         }\r
2840         \r
2841         for(int i=0; i<invalid.length; i++){\r
2842             if(UCharacter.getHanNumericValue(invalid[i]) != -1){\r
2843                 errln("UCharacter.getHanNumericValue does not return the " + \r
2844                         "same result as expected. Passed value: " + invalid[i] +\r
2845                         ". Got: " + UCharacter.getHanNumericValue(invalid[i]) +\r
2846                         ". Expected: -1");\r
2847             }\r
2848         }\r
2849     }\r
2850 \r
2851     /*\r
2852      * The following method tests\r
2853      *      public static boolean hasBinaryProperty(int ch, int property) \r
2854      */\r
2855     public void TestHasBinaryProperty(){\r
2856         // Testing when "if (ch < MIN_VALUE || ch > MAX_VALUE)" is true\r
2857         int[] invalid = {\r
2858                 UCharacter.MIN_VALUE-1, UCharacter.MIN_VALUE-2,\r
2859                 UCharacter.MAX_VALUE+1, UCharacter.MAX_VALUE+2};\r
2860         int[] valid = {\r
2861                 UCharacter.MIN_VALUE, UCharacter.MIN_VALUE+1,\r
2862                 UCharacter.MAX_VALUE, UCharacter.MAX_VALUE-1};\r
2863         \r
2864         for(int i=0; i<invalid.length; i++){\r
2865             try{\r
2866                 UCharacter.hasBinaryProperty(invalid[i], 1);\r
2867                 errln("UCharacter.hasBinaryProperty(ch, property) was suppose to " +\r
2868                         "give an exception for an invalid input. Value passed: " +\r
2869                         invalid[i]);\r
2870                 \r
2871             } catch(Exception e){}\r
2872         }\r
2873         \r
2874         for(int i=0; i<valid.length; i++){\r
2875             try{\r
2876                 UCharacter.hasBinaryProperty(valid[i], 1);\r
2877             } catch(Exception e){\r
2878                 errln("UCharacter.hasBinaryProperty(ch, property) was not suppose to " +\r
2879                         "give an exception for an valid input. Value passed: " +\r
2880                         invalid[i]);\r
2881             }\r
2882         }\r
2883     }\r
2884 \r
2885     /*\r
2886      * The following method tests\r
2887      *      public static int getIntPropertyValue(int ch, int type)\r
2888      */\r
2889     public void TestGetIntPropertyValue(){\r
2890         /* Testing UCharacter.getIntPropertyValue(ch, type) */\r
2891         // Testing when "if (type < UProperty.BINARY_START)" is true\r
2892         int[] negative_cases = {-100,-50,-10,-5,-2,-1};\r
2893         for(int i=0; i<negative_cases.length; i++){\r
2894             if(UCharacter.getIntPropertyValue(0, negative_cases[i]) != 0){\r
2895                 errln("UCharacter.getIntPropertyValue(ch, type) was suppose to return 0 " +\r
2896                         "when passing a negative value of " + negative_cases[i]);\r
2897 \r
2898             }\r
2899         }\r
2900         \r
2901         // Testing when "if(ch<NormalizerImpl.JAMO_L_BASE)" is true\r
2902         for(int i=Normalizer2Impl.Hangul.JAMO_L_BASE-5; i<Normalizer2Impl.Hangul.JAMO_L_BASE; i++){\r
2903             if(UCharacter.getIntPropertyValue(i, UProperty.HANGUL_SYLLABLE_TYPE) != 0){\r
2904                 errln("UCharacter.getIntPropertyValue(ch, type) was suppose to return 0 " +\r
2905                         "when passing ch: " + i + "and type of Property.HANGUL_SYLLABLE_TYPE");\r
2906 \r
2907             }\r
2908         }\r
2909         \r
2910         // Testing when "else if((ch-=NormalizerImpl.HANGUL_BASE)<0)" is true\r
2911         for(int i=Normalizer2Impl.Hangul.HANGUL_BASE-5; i<Normalizer2Impl.Hangul.HANGUL_BASE; i++){\r
2912             if(UCharacter.getIntPropertyValue(i, UProperty.HANGUL_SYLLABLE_TYPE) != 0){\r
2913                 errln("UCharacter.getIntPropertyValue(ch, type) was suppose to return 0 " +\r
2914                         "when passing ch: " + i + "and type of Property.HANGUL_SYLLABLE_TYPE");\r
2915 \r
2916             }\r
2917         }\r
2918     }\r
2919 \r
2920     /*\r
2921      * The following method tests\r
2922      *      public static int getIntPropertyMaxValue(int type)\r
2923      */\r
2924     public void TestGetIntPropertyMaxValue(){\r
2925         /* Testing UCharacter.getIntPropertyMaxValue(type) */\r
2926         // Testing when "else if (type < UProperty.INT_START)" is true\r
2927         int[] cases = {UProperty.BINARY_LIMIT, UProperty.BINARY_LIMIT+1,\r
2928                 UProperty.INT_START-2, UProperty.INT_START-1};\r
2929         for(int i=0; i<cases.length; i++){\r
2930             if(UCharacter.getIntPropertyMaxValue(cases[i]) != -1){\r
2931                 errln("UCharacter.getIntPropertyMaxValue was suppose to return -1 " +\r
2932                         "but got " + UCharacter.getIntPropertyMaxValue(cases[i]));\r
2933             }\r
2934         }\r
2935         \r
2936         // TODO: Testing when the case statment reaches "default"\r
2937         // After testing between values of UProperty.INT_START and\r
2938         // UProperty.INT_LIMIT are covered, none of the values reaches default.\r
2939     }\r
2940     \r
2941     /*\r
2942      * The following method tests\r
2943      *      public static final int codePointAt(CharSequence seq, int index)\r
2944      *      public static final int codePointAt(char[] text, int index, int limit)\r
2945      */\r
2946     public void TestCodePointAt(){\r
2947         \r
2948         // {LEAD_SURROGATE_MIN_VALUE,\r
2949         //  LEAD_SURROGATE_MAX_VALUE, LEAD_SURROGATE_MAX_VALUE-1\r
2950         String[] cases = {"\uD800","\uDBFF","\uDBFE"};\r
2951         int[] result = {55296,56319,56318};\r
2952         for(int i=0; i < cases.length; i++){\r
2953             /* Testing UCharacter.codePointAt(seq, index) */\r
2954             // Testing when "if (index < seq.length())" is false\r
2955             if(UCharacter.codePointAt((CharSequence) cases[i], 0) != result[i])\r
2956                 errln("UCharacter.codePointAt(CharSequence ...) did not return as expected. " +\r
2957                         "Passed value: " + cases[i] + ". Expected: " +\r
2958                         result[i] + ". Got: " +\r
2959                         UCharacter.codePointAt((CharSequence) cases[i], 0));\r
2960             \r
2961             /* Testing UCharacter.codePointAt(text, index) */\r
2962             // Testing when "if (index < text.length)" is false\r
2963             if(UCharacter.codePointAt(cases[i].toCharArray(), 0) != result[i])\r
2964                 errln("UCharacter.codePointAt(char[] ...) did not return as expected. " +\r
2965                         "Passed value: " + cases[i] + ". Expected: " +\r
2966                         result[i] + ". Got: " +\r
2967                         UCharacter.codePointAt(cases[i].toCharArray(), 0));\r
2968             \r
2969             /* Testing UCharacter.codePointAt(text, index, limit) */\r
2970             // Testing when "if (index < limit)" is false\r
2971             if(UCharacter.codePointAt(cases[i].toCharArray(), 0, 1) != result[i])\r
2972                 errln("UCharacter.codePointAt(char[], int, int) did not return as expected. " +\r
2973                         "Passed value: " + cases[i] + ". Expected: " +\r
2974                         result[i] + ". Got: " +\r
2975                         UCharacter.codePointAt(cases[i].toCharArray(), 0, 1));\r
2976         }\r
2977 \r
2978         /* Testing UCharacter.codePointAt(text, index, limit) */\r
2979         // Testing when "if (index >= limit || limit > text.length)" is true\r
2980         char[] empty_text = {};\r
2981         char[] one_char_text = {'a'};\r
2982         char[] reg_text = {'d','u','m','m','y'};\r
2983         int[] limitCases = {2,3,5,10,25};\r
2984         \r
2985         // When index >= limit\r
2986         for(int i=0; i < limitCases.length; i++){\r
2987             try{\r
2988                 UCharacter.codePointAt(reg_text, 100, limitCases[i]);\r
2989                 errln("UCharacter.codePointAt was suppose to return an exception " +\r
2990                         "but got " + UCharacter.codePointAt(reg_text, 100, limitCases[i]) +\r
2991                         ". The following passed parameters were Text: " + reg_text.toString() + ", Start: " + \r
2992                         100 + ", Limit: " + limitCases[i] + ".");\r
2993             } catch(Exception e){\r
2994             }\r
2995         }\r
2996         \r
2997         // When limit > text.length\r
2998         for(int i=0; i < limitCases.length; i++){\r
2999             try{\r
3000                 UCharacter.codePointAt(empty_text, 0, limitCases[i]);\r
3001                 errln("UCharacter.codePointAt was suppose to return an exception " +\r
3002                         "but got " + UCharacter.codePointAt(empty_text, 0, limitCases[i]) +\r
3003                         ". The following passed parameters were Text: " + empty_text.toString() + ", Start: " + \r
3004                         0 + ", Limit: " + limitCases[i] + ".");\r
3005             } catch(Exception e){\r
3006             }\r
3007             \r
3008             try{\r
3009                 UCharacter.codePointCount(one_char_text, 0, limitCases[i]);\r
3010                 errln("UCharacter.codePointCount was suppose to return an exception " +\r
3011                         "but got " + UCharacter.codePointCount(one_char_text, 0, limitCases[i]) +\r
3012                         ". The following passed parameters were Text: " + one_char_text.toString() + ", Start: " + \r
3013                         0 + ", Limit: " + limitCases[i] + ".");\r
3014             } catch(Exception e){\r
3015             }\r
3016         }\r
3017     }\r
3018 \r
3019     /*\r
3020      * The following method tests\r
3021      *      public static final int codePointBefore(CharSequence seq, int index)\r
3022      *      public static final int codePointBefore(char[] text, int index)\r
3023      *      public static final int codePointBefore(char[] text, int index, int limit)\r
3024      */\r
3025     public void TestCodePointBefore(){\r
3026         // {TRAIL_SURROGATE_MIN_VALUE,\r
3027         //  TRAIL_SURROGATE_MAX_VALUE, TRAIL_SURROGATE_MAX_VALUE -1\r
3028         String[] cases = {"\uDC00","\uDFFF","\uDDFE"};\r
3029         int[] result = {56320,57343,56830};\r
3030         for(int i=0; i < cases.length; i++){\r
3031             /* Testing UCharacter.codePointBefore(seq, index) */\r
3032             // Testing when "if (index > 0)" is false\r
3033             if(UCharacter.codePointBefore((CharSequence) cases[i], 1) != result[i])\r
3034                 errln("UCharacter.codePointBefore(CharSequence ...) did not return as expected. " +\r
3035                         "Passed value: " + cases[i] + ". Expected: " +\r
3036                         result[i] + ". Got: " +\r
3037                         UCharacter.codePointBefore((CharSequence) cases[i], 1));\r
3038             \r
3039             /* Testing UCharacter.codePointBefore(text, index) */\r
3040             // Testing when "if (index > 0)" is false\r
3041             if(UCharacter.codePointBefore(cases[i].toCharArray(), 1) != result[i])\r
3042                 errln("UCharacter.codePointBefore(char[] ...) did not return as expected. " +\r
3043                         "Passed value: " + cases[i] + ". Expected: " +\r
3044                         result[i] + ". Got: " +\r
3045                         UCharacter.codePointBefore(cases[i].toCharArray(), 1));\r
3046             \r
3047             /* Testing UCharacter.codePointBefore(text, index, limit) */\r
3048             // Testing when "if (index > limit)" is false\r
3049             if(UCharacter.codePointBefore(cases[i].toCharArray(), 1, 0) != result[i])\r
3050                 errln("UCharacter.codePointBefore(char[], int, int) did not return as expected. " +\r
3051                         "Passed value: " + cases[i] + ". Expected: " +\r
3052                         result[i] + ". Got: " +\r
3053                         UCharacter.codePointBefore(cases[i].toCharArray(), 1, 0));\r
3054         }\r
3055         \r
3056         /* Testing UCharacter.codePointBefore(text, index, limit) */\r
3057         char[] dummy = {'d','u','m','m','y'};\r
3058         // Testing when "if (index <= limit || limit < 0)" is true\r
3059         int[] negative_cases = {-100,-10,-5,-2,-1};\r
3060         int[] index_cases = {0,1,2,5,10,100};\r
3061         \r
3062         for(int i=0; i < negative_cases.length; i++){\r
3063             try{\r
3064                 UCharacter.codePointBefore(dummy, 10000, negative_cases[i]);\r
3065                 errln("UCharacter.codePointBefore(text, index, limit) was suppose to return an exception " +\r
3066                         "when the parameter limit of " + negative_cases[i] + " is a negative number.");\r
3067             } catch(Exception e) {}\r
3068         }\r
3069         \r
3070         for(int i=0; i < index_cases.length; i++){\r
3071             try{\r
3072                 UCharacter.codePointBefore(dummy, index_cases[i], 101);\r
3073                 errln("UCharacter.codePointBefore(text, index, limit) was suppose to return an exception " +\r
3074                         "when the parameter index of " + index_cases[i] + " is a negative number.");\r
3075             } catch(Exception e) {}\r
3076         }\r
3077     }\r
3078 \r
3079     /*\r
3080      * The following method tests\r
3081      *      public static final int toChars(int cp, char[] dst, int dstIndex)\r
3082      *      public static final char[] toChars(int cp)\r
3083      */\r
3084     public void TestToChars(){\r
3085         int[] positive_cases = {1,2,5,10,100};\r
3086         char[] dst = {'a'};\r
3087         \r
3088         /* Testing UCharacter.toChars(cp, dst, dstIndex) */\r
3089         for(int i=0; i < positive_cases.length; i++){\r
3090             // Testing negative values when cp < 0 for if (cp >= 0)\r
3091             try{\r
3092                 UCharacter.toChars(-1*positive_cases[i],dst,0);\r
3093                 errln("UCharacter.toChars(int,char[],int) was suppose to return an exception " +\r
3094                         "when the parameter " + (-1*positive_cases[i]) + " is a negative number.");\r
3095             } catch(Exception e){\r
3096             }\r
3097             \r
3098             // Testing when "if (cp < MIN_SUPPLEMENTARY_CODE_POINT)" is true\r
3099             if(UCharacter.toChars(UCharacter.MIN_SUPPLEMENTARY_CODE_POINT-positive_cases[i], dst, 0) != 1){\r
3100                 errln("UCharacter.toChars(int,char[],int) was suppose to return a value of 1. Got: " +\r
3101                         UCharacter.toChars(UCharacter.MIN_SUPPLEMENTARY_CODE_POINT-positive_cases[i], dst, 0));\r
3102             }\r
3103             \r
3104             // Testing when "if (cp < MIN_SUPPLEMENTARY_CODE_POINT)" is false and\r
3105             //     when "if (cp <= MAX_CODE_POINT)" is false\r
3106             try{\r
3107                 UCharacter.toChars(UCharacter.MAX_CODE_POINT+positive_cases[i],dst,0);\r
3108                 errln("UCharacter.toChars(int,char[],int) was suppose to return an exception " +\r
3109                         "when the parameter " + (UCharacter.MAX_CODE_POINT+positive_cases[i]) +\r
3110                         " is a large number.");\r
3111             } catch(Exception e){\r
3112             }\r
3113         }\r
3114         \r
3115         \r
3116         /* Testing UCharacter.toChars(cp)*/\r
3117         for(int i=0; i<positive_cases.length; i++){\r
3118             // Testing negative values when cp < 0 for if (cp >= 0)\r
3119             try{\r
3120                 UCharacter.toChars(-1*positive_cases[i]);\r
3121                 errln("UCharacter.toChars(cint) was suppose to return an exception " +\r
3122                         "when the parameter " + positive_cases[i] + " is a negative number.");\r
3123             } catch(Exception e){\r
3124             }\r
3125             \r
3126             // Testing when "if (cp < MIN_SUPPLEMENTARY_CODE_POINT)" is true\r
3127             if(UCharacter.toChars(UCharacter.MIN_SUPPLEMENTARY_CODE_POINT-positive_cases[i]).length <= 0){\r
3128                 errln("UCharacter.toChars(int) was suppose to return some result result when the parameter " +\r
3129                         (UCharacter.MIN_SUPPLEMENTARY_CODE_POINT-positive_cases[i]) + "is passed.");\r
3130             }\r
3131             \r
3132             // Testing when "if (cp < MIN_SUPPLEMENTARY_CODE_POINT)" is false and\r
3133             //     when "if (cp <= MAX_CODE_POINT)" is false\r
3134             try{\r
3135                 UCharacter.toChars(UCharacter.MAX_CODE_POINT+positive_cases[i]);\r
3136                 errln("UCharacter.toChars(int) was suppose to return an exception " +\r
3137                         "when the parameter " + positive_cases[i] + " is a large number.");\r
3138             } catch(Exception e){\r
3139             }\r
3140         }\r
3141     }\r
3142 \r
3143     /*\r
3144      * The following method tests\r
3145      *      public static int codePointCount(CharSequence text, int start, int limit)\r
3146      *      public static int codePointCount(char[] text, int start, int limit)\r
3147      */\r
3148     public void TestCodePointCount(){\r
3149         // The following tests the first if statement to make it true:\r
3150         //  if (start < 0 || limit < start || limit > text.length)\r
3151         //  which will throw an exception.\r
3152         char[] empty_text = {};\r
3153         char[] one_char_text = {'a'};\r
3154         char[] reg_text = {'d','u','m','m','y'};\r
3155         int[] invalid_startCases = {-1,-2,-5,-10,-100};\r
3156         int[] limitCases = {2,3,5,10,25};\r
3157         \r
3158         // When start < 0\r
3159         for(int i=0; i < invalid_startCases.length; i++){\r
3160             try{\r
3161                 UCharacter.codePointCount(reg_text, invalid_startCases[i], 1);\r
3162                 errln("UCharacter.codePointCount was suppose to return an exception " +\r
3163                         "but got " + UCharacter.codePointCount(reg_text, invalid_startCases[i], 1) +\r
3164                         ". The following passed parameters were Text: " + reg_text.toString() + ", Start: " + \r
3165                         invalid_startCases[i] + ", Limit: " + 1 + ".");\r
3166             } catch(Exception e){\r
3167             }\r
3168         }\r
3169 \r
3170         // When limit < start\r
3171         for(int i=0; i < limitCases.length; i++){\r
3172             try{\r
3173                 UCharacter.codePointCount(reg_text, 100, limitCases[i]);\r
3174                 errln("UCharacter.codePointCount was suppose to return an exception " +\r
3175                         "but got " + UCharacter.codePointCount(reg_text, 100, limitCases[i]) +\r
3176                         ". The following passed parameters were Text: " + reg_text.toString() + ", Start: " + \r
3177                         100 + ", Limit: " + limitCases[i] + ".");\r
3178             } catch(Exception e){\r
3179             }\r
3180         }\r
3181         \r
3182         // When limit > text.length\r
3183         for(int i=0; i < limitCases.length; i++){\r
3184             try{\r
3185                 UCharacter.codePointCount(empty_text, 0, limitCases[i]);\r
3186                 errln("UCharacter.codePointCount was suppose to return an exception " +\r
3187                         "but got " + UCharacter.codePointCount(empty_text, 0, limitCases[i]) +\r
3188                         ". The following passed parameters were Text: " + empty_text.toString() + ", Start: " + \r
3189                         0 + ", Limit: " + limitCases[i] + ".");\r
3190             } catch(Exception e){\r
3191             }\r
3192             \r
3193             try{\r
3194                 UCharacter.codePointCount(one_char_text, 0, limitCases[i]);\r
3195                 errln("UCharacter.codePointCount was suppose to return an exception " +\r
3196                         "but got " + UCharacter.codePointCount(one_char_text, 0, limitCases[i]) +\r
3197                         ". The following passed parameters were Text: " + one_char_text.toString() + ", Start: " + \r
3198                         0 + ", Limit: " + limitCases[i] + ".");\r
3199             } catch(Exception e){\r
3200             }\r
3201         }\r
3202     }\r
3203     \r
3204     /*\r
3205      * The following method tests\r
3206      *      private static int getEuropeanDigit(int ch)\r
3207      * The method needs to use the method "digit" in order to access the\r
3208      * getEuropeanDigit method.\r
3209      */\r
3210     public void TestGetEuropeanDigit(){\r
3211         //The number retrieved from 0xFF41 to 0xFF5A is due to\r
3212         //  exhaustive testing from UTF16.CODEPOINT_MIN_VALUE to\r
3213         //  UTF16.CODEPOINT_MAX_VALUE return a value of -1.\r
3214         \r
3215         int[] radixResult = {\r
3216                 10,11,12,13,14,15,16,17,18,19,20,21,22,\r
3217                 23,24,25,26,27,28,29,30,31,32,33,34,35};\r
3218         // Invalid and too-small-for-these-digits radix values. \r
3219         int[] radixCase1 = {0,1,5,10,100};\r
3220         // Radix values that work for at least some of the "digits".\r
3221         int[] radixCase2 = {12,16,20,36};\r
3222         \r
3223         for(int i=0xFF41; i<=0xFF5A; i++){\r
3224             for(int j=0; j < radixCase1.length; j++){\r
3225                 if(UCharacter.digit(i, radixCase1[j]) != -1){\r
3226                     errln("UCharacter.digit(int,int) was supposed to return -1 for radix " + radixCase1[j]\r
3227                             + ". Value passed: U+" + Integer.toHexString(i) + ". Got: " + UCharacter.digit(i, radixCase1[j]));\r
3228                 }\r
3229             }\r
3230             for(int j=0; j < radixCase2.length; j++){\r
3231                 int radix = radixCase2[j];\r
3232                 int expected = (radixResult[i-0xFF41] < radix) ? radixResult[i-0xFF41] : -1;\r
3233                 int actual = UCharacter.digit(i, radix);\r
3234                 if(actual != expected){\r
3235                     errln("UCharacter.digit(int,int) was supposed to return " +\r
3236                             expected + " for radix " + radix +\r
3237                             ". Value passed: U+" + Integer.toHexString(i) + ". Got: " + actual);\r
3238                     break;\r
3239                 }\r
3240             }\r
3241         }\r
3242     }\r
3243     \r
3244     /* Tests the method\r
3245      *      private static final int getProperty(int ch)\r
3246      * from public static int getType(int ch)\r
3247      */\r
3248     public void TestGetProperty(){\r
3249         int[] cases = {UTF16.CODEPOINT_MAX_VALUE+1, UTF16.CODEPOINT_MAX_VALUE+2};\r
3250         for(int i=0; i < cases.length; i++)\r
3251             if(UCharacter.getType(cases[i]) != 0)\r
3252                 errln("UCharacter.getType for testing UCharacter.getProperty "\r
3253                         + "did not return 0 for passed value of " + cases[i] +\r
3254                         " but got " + UCharacter.getType(cases[i]));\r
3255     }\r
3256     \r
3257     /* Tests the class\r
3258      *      abstract public static class XSymbolTable implements SymbolTable\r
3259      */\r
3260     public void TestXSymbolTable(){\r
3261         class MyXSymbolTable extends UnicodeSet.XSymbolTable {}\r
3262         MyXSymbolTable st = new MyXSymbolTable();\r
3263         \r
3264         // Tests "public UnicodeMatcher lookupMatcher(int i)"\r
3265         if(st.lookupMatcher(0) != null)\r
3266             errln("XSymbolTable.lookupMatcher(int i) was suppose to return null.");\r
3267         \r
3268         // Tests "public boolean applyPropertyAlias(String propertyName, String propertyValue, UnicodeSet result)"\r
3269         if(st.applyPropertyAlias("", "", new UnicodeSet()) != false)\r
3270             errln("XSymbolTable.applyPropertyAlias(String propertyName, String propertyValue, UnicodeSet result) was suppose to return false.");\r
3271 \r
3272         // Tests "public char[] lookup(String s)"\r
3273         if(st.lookup("") != null)\r
3274             errln("XSymbolTable.lookup(String s) was suppose to return null.");\r
3275         \r
3276         // Tests "public String parseReference(String text, ParsePosition pos, int limit)"\r
3277         if(st.parseReference("", null, 0) != null)\r
3278             errln("XSymbolTable.parseReference(String text, ParsePosition pos, int limit) was suppose to return null.");\r
3279     }\r
3280     \r
3281     /* Tests the method\r
3282      *      public boolean isFrozen()\r
3283      */\r
3284     public void TestIsFrozen(){\r
3285         UnicodeSet us = new UnicodeSet();\r
3286         if(us.isFrozen() != false)\r
3287             errln("Unicode.isFrozen() was suppose to return false.");\r
3288         \r
3289         us.freeze();\r
3290         if(us.isFrozen() != true)\r
3291             errln("Unicode.isFrozen() was suppose to return true.");\r
3292     }\r
3293 }\r