jars/icu4j-4_4_2-src/main/tests/core/src/com/ibm/icu/dev/test/lang/UTF16Test.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 com.ibm.icu.dev.test.TestFmwk;\r
  11 import com.ibm.icu.dev.test.UTF16Util;\r
  12 import com.ibm.icu.impl.Utility;\r
  13 import com.ibm.icu.lang.UCharacter;\r
  14 import com.ibm.icu.text.ReplaceableString;\r
  15 import com.ibm.icu.text.UTF16;\r
  16 \r
  17 /**\r
  18 * Testing class for UTF16\r
  19 * @author Syn Wee Quek\r
  20 * @since feb 09 2001\r
  21 */\r
  22 public final class UTF16Test extends TestFmwk\r
  23 {\r
  24     // constructor ===================================================\r
  25 \r
  26     /**\r
  27      * Constructor\r
  28      */\r
  29     public UTF16Test()\r
  30     {\r
  31     }\r
  32 \r
  33     // public methods ================================================\r
  34 \r
  35     /**\r
  36      * Testing UTF16 class methods append\r
  37      */\r
  38     public void TestAppend()\r
  39     {\r
  40           StringBuffer strbuff = new StringBuffer("this is a string ");\r
  41           char array[] = new char[UCharacter.MAX_VALUE >> 2];\r
  42           int strsize = strbuff.length();\r
  43           int arraysize = strsize;\r
  44 \r
  45           if (0 != strsize) {\r
  46             strbuff.getChars(0, strsize, array, 0);\r
  47         }\r
  48           for (int i = 1; i < UCharacter.MAX_VALUE; i += 100) {\r
  49         UTF16.append(strbuff, i);\r
  50         arraysize = UTF16.append(array, arraysize, i);\r
  51 \r
  52         String arraystr = new String(array, 0, arraysize);\r
  53         if (!arraystr.equals(strbuff.toString())) {\r
  54         errln("FAIL Comparing char array append and string append " +\r
  55               "with 0x" + Integer.toHexString(i));\r
  56         }\r
  57 \r
  58         // this is to cater for the combination of 0xDBXX 0xDC50 which\r
  59         // forms a supplementary character\r
  60         if (i == 0xDC51) {\r
  61         strsize --;\r
  62         }\r
  63 \r
  64         if (UTF16.countCodePoint(strbuff) != strsize + (i / 100) + 1) {\r
  65         errln("FAIL Counting code points in string appended with " +\r
  66               " 0x" + Integer.toHexString(i));\r
  67         break;\r
  68         }\r
  69     }\r
  70 \r
  71     // coverage for new 1.5 - cover only so no real test\r
  72     strbuff = new StringBuffer();\r
  73     UTF16.appendCodePoint(strbuff, 0x10000);\r
  74     if (strbuff.length() != 2) {\r
  75         errln("fail appendCodePoint");\r
  76     }\r
  77     }\r
  78 \r
  79     /**\r
  80      * Testing UTF16 class methods bounds\r
  81      */\r
  82     public void TestBounds()\r
  83     {\r
  84           StringBuffer strbuff =\r
  85                         //0     12345     6     7     8     9\r
  86         new StringBuffer("\udc000123\ud800\udc00\ud801\udc01\ud802");\r
  87           String str = strbuff.toString();\r
  88           char array[] = str.toCharArray();\r
  89           int boundtype[] = {UTF16.SINGLE_CHAR_BOUNDARY,\r
  90                UTF16.SINGLE_CHAR_BOUNDARY,\r
  91                UTF16.SINGLE_CHAR_BOUNDARY,\r
  92                UTF16.SINGLE_CHAR_BOUNDARY,\r
  93                UTF16.SINGLE_CHAR_BOUNDARY,\r
  94                UTF16.LEAD_SURROGATE_BOUNDARY,\r
  95                UTF16.TRAIL_SURROGATE_BOUNDARY,\r
  96                UTF16.LEAD_SURROGATE_BOUNDARY,\r
  97                UTF16.TRAIL_SURROGATE_BOUNDARY,\r
  98                UTF16.SINGLE_CHAR_BOUNDARY};\r
  99           int length = str.length();\r
 100           for (int i = 0; i < length; i ++) {\r
 101         if (UTF16.bounds(str, i) != boundtype[i]) {\r
 102                   errln("FAIL checking bound type at index " + i);\r
 103         }\r
 104         if (UTF16.bounds(strbuff, i) != boundtype[i]) {\r
 105                   errln("FAIL checking bound type at index " + i);\r
 106         }\r
 107         if (UTF16.bounds(array, 0, length, i) != boundtype[i]) {\r
 108                   errln("FAIL checking bound type at index " + i);\r
 109         }\r
 110           }\r
 111           // does not straddle between supplementary character\r
 112           int start = 4;\r
 113           int limit = 9;\r
 114           int subboundtype1[] = {UTF16.SINGLE_CHAR_BOUNDARY,\r
 115                    UTF16.LEAD_SURROGATE_BOUNDARY,\r
 116                    UTF16.TRAIL_SURROGATE_BOUNDARY,\r
 117                    UTF16.LEAD_SURROGATE_BOUNDARY,\r
 118                    UTF16.TRAIL_SURROGATE_BOUNDARY};\r
 119           try {\r
 120         UTF16.bounds(array, start, limit, -1);\r
 121         errln("FAIL Out of bounds index in bounds should fail");\r
 122           } catch (Exception e) {\r
 123         // getting rid of warnings\r
 124         System.out.print("");\r
 125           }\r
 126 \r
 127           for (int i = 0; i < limit - start; i ++) {\r
 128         if (UTF16.bounds(array, start, limit, i) != subboundtype1[i]) {\r
 129                   errln("FAILED Subarray bounds in [" + start + ", " + limit +\r
 130               "] expected " + subboundtype1[i] + " at offset " + i);\r
 131         }\r
 132           }\r
 133 \r
 134           // starts from the mid of a supplementary character\r
 135           int subboundtype2[] = {UTF16.SINGLE_CHAR_BOUNDARY,\r
 136                    UTF16.LEAD_SURROGATE_BOUNDARY,\r
 137                    UTF16.TRAIL_SURROGATE_BOUNDARY};\r
 138 \r
 139           start = 6;\r
 140           limit = 9;\r
 141           for (int i = 0; i < limit - start; i ++) {\r
 142         if (UTF16.bounds(array, start, limit, i) != subboundtype2[i]) {\r
 143                   errln("FAILED Subarray bounds in [" + start + ", " + limit +\r
 144               "] expected " + subboundtype2[i] + " at offset " + i);\r
 145         }\r
 146           }\r
 147 \r
 148           // ends in the mid of a supplementary character\r
 149           int subboundtype3[] = {UTF16.LEAD_SURROGATE_BOUNDARY,\r
 150                    UTF16.TRAIL_SURROGATE_BOUNDARY,\r
 151                    UTF16.SINGLE_CHAR_BOUNDARY};\r
 152           start = 5;\r
 153           limit = 8;\r
 154           for (int i = 0; i < limit - start; i ++) {\r
 155         if (UTF16.bounds(array, start, limit, i) != subboundtype3[i]) {\r
 156                   errln("FAILED Subarray bounds in [" + start + ", " + limit +\r
 157               "] expected " + subboundtype3[i] + " at offset " + i);\r
 158         }\r
 159           }\r
 160     }\r
 161 \r
 162     /**\r
 163      * Testing UTF16 class methods charAt and charAtCodePoint\r
 164      */\r
 165     public void TestCharAt()\r
 166     {\r
 167           StringBuffer strbuff =\r
 168         new StringBuffer("12345\ud800\udc0167890\ud800\udc02");\r
 169           if (UTF16.charAt(strbuff, 0) != '1' || UTF16.charAt(strbuff, 2) != '3'\r
 170               || UTF16.charAt(strbuff, 5) != 0x10001 ||\r
 171         UTF16.charAt(strbuff, 6) != 0x10001 ||\r
 172         UTF16.charAt(strbuff, 12) != 0x10002 ||\r
 173         UTF16.charAt(strbuff, 13) != 0x10002) {\r
 174         errln("FAIL Getting character from string buffer error" );\r
 175           }\r
 176           String str = strbuff.toString();\r
 177           if (UTF16.charAt(str, 0) != '1' || UTF16.charAt(str, 2) != '3' ||\r
 178         UTF16.charAt(str, 5) != 0x10001 || UTF16.charAt(str, 6) != 0x10001\r
 179         || UTF16.charAt(str, 12) != 0x10002 ||\r
 180         UTF16.charAt(str, 13) != 0x10002)\r
 181         {\r
 182               errln("FAIL Getting character from string error" );\r
 183         }\r
 184           char array[] = str.toCharArray();\r
 185           int start = 0;\r
 186           int limit = str.length();\r
 187           if (UTF16.charAt(array, start, limit, 0) != '1' ||\r
 188         UTF16.charAt(array, start, limit, 2) != '3' ||\r
 189         UTF16.charAt(array, start, limit, 5) != 0x10001 ||\r
 190         UTF16.charAt(array, start, limit, 6) != 0x10001 ||\r
 191         UTF16.charAt(array, start, limit, 12) != 0x10002 ||\r
 192         UTF16.charAt(array, start, limit, 13) != 0x10002) {\r
 193         errln("FAIL Getting character from array error" );\r
 194           }\r
 195           // check the sub array here.\r
 196           start = 6;\r
 197           limit = 13;\r
 198           try {\r
 199         UTF16.charAt(array, start, limit, -1);\r
 200         errln("FAIL out of bounds error expected");\r
 201           } catch (Exception e) {\r
 202         System.out.print("");\r
 203           }\r
 204           try {\r
 205         UTF16.charAt(array, start, limit, 8);\r
 206         errln("FAIL out of bounds error expected");\r
 207           } catch (Exception e) {\r
 208         System.out.print("");\r
 209           }\r
 210           if (UTF16.charAt(array, start, limit, 0) != 0xdc01) {\r
 211         errln("FAIL Expected result in subarray 0xdc01");\r
 212           }\r
 213           if (UTF16.charAt(array, start, limit, 6) != 0xd800) {\r
 214         errln("FAIL Expected result in subarray 0xd800");\r
 215           }\r
 216           ReplaceableString replaceable = new ReplaceableString(str);\r
 217           if (UTF16.charAt(replaceable, 0) != '1' ||\r
 218               UTF16.charAt(replaceable, 2) != '3' ||\r
 219         UTF16.charAt(replaceable, 5) != 0x10001 ||\r
 220         UTF16.charAt(replaceable, 6) != 0x10001 ||\r
 221         UTF16.charAt(replaceable, 12) != 0x10002 ||\r
 222         UTF16.charAt(replaceable, 13) != 0x10002) {\r
 223         errln("FAIL Getting character from replaceable error" );\r
 224           }\r
 225           \r
 226           StringBuffer strbuffer = new StringBuffer("0xD805");\r
 227           UTF16.charAt((CharSequence)strbuffer, 0);\r
 228     }\r
 229 \r
 230     /**\r
 231      * Testing UTF16 class methods countCodePoint\r
 232      */\r
 233     public void TestCountCodePoint()\r
 234     {\r
 235         StringBuffer strbuff = new StringBuffer("");\r
 236         char         array[] = null;\r
 237         if (UTF16.countCodePoint(strbuff) != 0 ||\r
 238         UTF16.countCodePoint("") != 0 ||\r
 239         UTF16.countCodePoint(array,0 ,0) != 0) {\r
 240         errln("FAIL Counting code points for empty strings");\r
 241         }\r
 242 \r
 243         strbuff = new StringBuffer("this is a string ");\r
 244         String str = strbuff.toString();\r
 245         array = str.toCharArray();\r
 246         int size = str.length();\r
 247 \r
 248         if (UTF16.countCodePoint(array, 0, 0) != 0) {\r
 249         errln("FAIL Counting code points for 0 offset array");\r
 250         }\r
 251 \r
 252         if (UTF16.countCodePoint(str) != size ||\r
 253         UTF16.countCodePoint(strbuff) != size ||\r
 254         UTF16.countCodePoint(array, 0, size) != size) {\r
 255         errln("FAIL Counting code points");\r
 256         }\r
 257 \r
 258         UTF16.append(strbuff, 0x10000);\r
 259         str = strbuff.toString();\r
 260         array = str.toCharArray();\r
 261         if (UTF16.countCodePoint(str) != size + 1 ||\r
 262         UTF16.countCodePoint(strbuff) != size + 1 ||\r
 263         UTF16.countCodePoint(array, 0, size + 1) != size + 1 ||\r
 264         UTF16.countCodePoint(array, 0, size + 2) != size + 1) {\r
 265         errln("FAIL Counting code points");\r
 266         }\r
 267         UTF16.append(strbuff, 0x61);\r
 268         str = strbuff.toString();\r
 269         array = str.toCharArray();\r
 270         if (UTF16.countCodePoint(str) != size + 2 ||\r
 271         UTF16.countCodePoint(strbuff) != size + 2 ||\r
 272         UTF16.countCodePoint(array, 0, size + 1) != size + 1 ||\r
 273         UTF16.countCodePoint(array, 0, size + 2) != size + 1 ||\r
 274         UTF16.countCodePoint(array, 0, size + 3) != size + 2) {\r
 275         errln("FAIL Counting code points");\r
 276         }\r
 277     }\r
 278 \r
 279     /**\r
 280      * Testing UTF16 class methods delete\r
 281      */\r
 282     public void TestDelete()\r
 283     {                                        //01234567890123456\r
 284         StringBuffer strbuff = new StringBuffer("these are strings");\r
 285         int size = strbuff.length();\r
 286         char array[] = strbuff.toString().toCharArray();\r
 287 \r
 288         UTF16.delete(strbuff, 3);\r
 289         UTF16.delete(strbuff, 3);\r
 290         UTF16.delete(strbuff, 3);\r
 291         UTF16.delete(strbuff, 3);\r
 292         UTF16.delete(strbuff, 3);\r
 293         UTF16.delete(strbuff, 3);\r
 294         try {\r
 295         UTF16.delete(strbuff, strbuff.length());\r
 296         errln("FAIL deleting out of bounds character should fail");\r
 297         } catch (Exception e) {\r
 298         System.out.print("");\r
 299         }\r
 300         UTF16.delete(strbuff, strbuff.length() - 1);\r
 301         if (!strbuff.toString().equals("the string")) {\r
 302         errln("FAIL expected result after deleting characters is " +\r
 303           "\"the string\"");\r
 304         }\r
 305 \r
 306         size = UTF16.delete(array, size, 3);\r
 307         size = UTF16.delete(array, size, 3);\r
 308         size = UTF16.delete(array, size, 3);\r
 309         size = UTF16.delete(array, size, 3);\r
 310         size = UTF16.delete(array, size, 3);\r
 311         size = UTF16.delete(array, size, 3);\r
 312         try {\r
 313         UTF16.delete(array, size, size);\r
 314         errln("FAIL deleting out of bounds character should fail");\r
 315         } catch (Exception e) {\r
 316         System.out.print("");\r
 317         }\r
 318         size = UTF16.delete(array, size, size - 1);\r
 319         String str = new String(array, 0, size);\r
 320         if (!str.equals("the string")) {\r
 321         errln("FAIL expected result after deleting characters is " +\r
 322           "\"the string\"");\r
 323         }\r
 324     //012345678     9     01     2      3     4\r
 325         strbuff = new StringBuffer("string: \ud800\udc00 \ud801\udc01 \ud801\udc01");\r
 326         size = strbuff.length();\r
 327         array = strbuff.toString().toCharArray();\r
 328 \r
 329         UTF16.delete(strbuff, 8);\r
 330         UTF16.delete(strbuff, 8);\r
 331         UTF16.delete(strbuff, 9);\r
 332         UTF16.delete(strbuff, 8);\r
 333         UTF16.delete(strbuff, 9);\r
 334         UTF16.delete(strbuff, 6);\r
 335         UTF16.delete(strbuff, 6);\r
 336         if (!strbuff.toString().equals("string")) {\r
 337         errln("FAIL expected result after deleting characters is \"string\"");\r
 338         }\r
 339 \r
 340         size = UTF16.delete(array, size, 8);\r
 341         size = UTF16.delete(array, size, 8);\r
 342         size = UTF16.delete(array, size, 9);\r
 343         size = UTF16.delete(array, size, 8);\r
 344         size = UTF16.delete(array, size, 9);\r
 345         size = UTF16.delete(array, size, 6);\r
 346         size = UTF16.delete(array, size, 6);\r
 347         str = new String(array, 0, size);\r
 348         if (!str.equals("string")) {\r
 349         errln("FAIL expected result after deleting characters is \"string\"");\r
 350         }\r
 351     }\r
 352 \r
 353     /**\r
 354      * Testing findOffsetFromCodePoint and findCodePointOffset\r
 355      */\r
 356     public void TestfindOffset()\r
 357     {\r
 358         // jitterbug 47\r
 359         String str = "a\uD800\uDC00b";\r
 360         StringBuffer strbuff = new StringBuffer(str);\r
 361         char array[] = str.toCharArray();\r
 362         int limit = str.length();\r
 363         if (UTF16.findCodePointOffset(str, 0) != 0 ||\r
 364         UTF16.findOffsetFromCodePoint(str, 0) != 0 ||\r
 365         UTF16.findCodePointOffset(strbuff, 0) != 0 ||\r
 366         UTF16.findOffsetFromCodePoint(strbuff, 0) != 0 ||\r
 367         UTF16.findCodePointOffset(array, 0, limit, 0) != 0 ||\r
 368         UTF16.findOffsetFromCodePoint(array, 0, limit, 0) != 0) {\r
 369         errln("FAIL Getting the first codepoint offset to a string with " +\r
 370           "supplementary characters");\r
 371         }\r
 372         if (UTF16.findCodePointOffset(str, 1) != 1 ||\r
 373         UTF16.findOffsetFromCodePoint(str, 1) != 1 ||\r
 374         UTF16.findCodePointOffset(strbuff, 1) != 1 ||\r
 375         UTF16.findOffsetFromCodePoint(strbuff, 1) != 1 ||\r
 376         UTF16.findCodePointOffset(array, 0, limit, 1) != 1 ||\r
 377         UTF16.findOffsetFromCodePoint(array, 0, limit, 1) != 1) {\r
 378         errln("FAIL Getting the second codepoint offset to a string with " +\r
 379           "supplementary characters");\r
 380         }\r
 381         if (UTF16.findCodePointOffset(str, 2) != 1 ||\r
 382         UTF16.findOffsetFromCodePoint(str, 2) != 3 ||\r
 383         UTF16.findCodePointOffset(strbuff, 2) != 1 ||\r
 384         UTF16.findOffsetFromCodePoint(strbuff, 2) != 3 ||\r
 385         UTF16.findCodePointOffset(array, 0, limit, 2) != 1 ||\r
 386         UTF16.findOffsetFromCodePoint(array, 0, limit, 2) != 3) {\r
 387         errln("FAIL Getting the third codepoint offset to a string with " +\r
 388           "supplementary characters");\r
 389         }\r
 390         if (UTF16.findCodePointOffset(str, 3) != 2 ||\r
 391         UTF16.findOffsetFromCodePoint(str, 3) != 4 ||\r
 392         UTF16.findCodePointOffset(strbuff, 3) != 2 ||\r
 393         UTF16.findOffsetFromCodePoint(strbuff, 3) != 4 ||\r
 394         UTF16.findCodePointOffset(array, 0, limit, 3) != 2 ||\r
 395         UTF16.findOffsetFromCodePoint(array, 0, limit, 3) != 4) {\r
 396         errln("FAIL Getting the last codepoint offset to a string with " +\r
 397           "supplementary characters");\r
 398         }\r
 399         if (UTF16.findCodePointOffset(str, 4) != 3 ||\r
 400         UTF16.findCodePointOffset(strbuff, 4) != 3 ||\r
 401         UTF16.findCodePointOffset(array, 0, limit, 4) != 3) {\r
 402         errln("FAIL Getting the length offset to a string with " +\r
 403           "supplementary characters");\r
 404         }\r
 405         try {\r
 406         UTF16.findCodePointOffset(str, 5);\r
 407         errln("FAIL Getting the a non-existence codepoint to a string " +\r
 408           "with supplementary characters");\r
 409         } catch (Exception e) {\r
 410         // this is a success\r
 411         logln("Passed out of bounds codepoint offset");\r
 412         }\r
 413         try {\r
 414         UTF16.findOffsetFromCodePoint(str, 4);\r
 415         errln("FAIL Getting the a non-existence codepoint to a string " +\r
 416           "with supplementary characters");\r
 417         } catch (Exception e) {\r
 418         // this is a success\r
 419         logln("Passed out of bounds codepoint offset");\r
 420         }\r
 421         try {\r
 422         UTF16.findCodePointOffset(strbuff, 5);\r
 423         errln("FAIL Getting the a non-existence codepoint to a string " +\r
 424           "with supplementary characters");\r
 425         } catch (Exception e) {\r
 426         // this is a success\r
 427         logln("Passed out of bounds codepoint offset");\r
 428         }\r
 429         try {\r
 430         UTF16.findOffsetFromCodePoint(strbuff, 4);\r
 431         errln("FAIL Getting the a non-existence codepoint to a string " +\r
 432           "with supplementary characters");\r
 433         } catch (Exception e) {\r
 434         // this is a success\r
 435         logln("Passed out of bounds codepoint offset");\r
 436         }\r
 437         try {\r
 438         UTF16.findCodePointOffset(array, 0, limit, 5);\r
 439         errln("FAIL Getting the a non-existence codepoint to a string " +\r
 440           "with supplementary characters");\r
 441         } catch (Exception e) {\r
 442         // this is a success\r
 443         logln("Passed out of bounds codepoint offset");\r
 444         }\r
 445         try {\r
 446         UTF16.findOffsetFromCodePoint(array, 0, limit, 4);\r
 447         errln("FAIL Getting the a non-existence codepoint to a string " +\r
 448           "with supplementary characters");\r
 449         } catch (Exception e) {\r
 450         // this is a success\r
 451         logln("Passed out of bounds codepoint offset");\r
 452         }\r
 453 \r
 454         if (UTF16.findCodePointOffset(array, 1, 3, 0) != 0 ||\r
 455         UTF16.findOffsetFromCodePoint(array, 1, 3, 0) != 0 ||\r
 456         UTF16.findCodePointOffset(array, 1, 3, 1) != 0 ||\r
 457         UTF16.findCodePointOffset(array, 1, 3, 2) != 1 ||\r
 458         UTF16.findOffsetFromCodePoint(array, 1, 3, 1) != 2) {\r
 459         errln("FAIL Getting valid codepoint offset in sub array");\r
 460         }\r
 461     }\r
 462 \r
 463     /**\r
 464      * Testing UTF16 class methods getCharCount, *Surrogate\r
 465      */\r
 466     public void TestGetCharCountSurrogate()\r
 467     {\r
 468         if (UTF16.getCharCount(0x61) != 1 ||\r
 469         UTF16.getCharCount(0x10000) != 2) {\r
 470         errln("FAIL getCharCount result failure");\r
 471         }\r
 472         if (UTF16.getLeadSurrogate(0x61) != 0 ||\r
 473         UTF16.getTrailSurrogate(0x61) != 0x61 ||\r
 474         UTF16.isLeadSurrogate((char)0x61) ||\r
 475         UTF16.isTrailSurrogate((char)0x61) ||\r
 476         UTF16.getLeadSurrogate(0x10000) != 0xd800 ||\r
 477         UTF16.getTrailSurrogate(0x10000) != 0xdc00 ||\r
 478         UTF16.isLeadSurrogate((char)0xd800) != true ||\r
 479         UTF16.isTrailSurrogate((char)0xd800) ||\r
 480         UTF16.isLeadSurrogate((char)0xdc00) ||\r
 481         UTF16.isTrailSurrogate((char)0xdc00) != true) {\r
 482         errln("FAIL *Surrogate result failure");\r
 483         }\r
 484 \r
 485         if (UTF16.isSurrogate((char)0x61) || !UTF16.isSurrogate((char)0xd800)\r
 486             || !UTF16.isSurrogate((char)0xdc00)) {\r
 487         errln("FAIL isSurrogate result failure");\r
 488         }\r
 489     }\r
 490 \r
 491     /**\r
 492      * Testing UTF16 class method insert\r
 493      */\r
 494     public void TestInsert()\r
 495     {\r
 496         StringBuffer strbuff = new StringBuffer("0123456789");\r
 497         char array[] = new char[128];\r
 498         int srcEnd = strbuff.length();\r
 499         if (0 != srcEnd) {\r
 500             strbuff.getChars(0, srcEnd, array, 0);\r
 501         }\r
 502         int length = 10;\r
 503         UTF16.insert(strbuff, 5, 't');\r
 504         UTF16.insert(strbuff, 5, 's');\r
 505         UTF16.insert(strbuff, 5, 'e');\r
 506         UTF16.insert(strbuff, 5, 't');\r
 507         if (!(strbuff.toString().equals("01234test56789"))) {\r
 508         errln("FAIL inserting \"test\"");\r
 509         }\r
 510         length = UTF16.insert(array, length, 5, 't');\r
 511         length = UTF16.insert(array, length, 5, 's');\r
 512         length = UTF16.insert(array, length, 5, 'e');\r
 513         length = UTF16.insert(array, length, 5, 't');\r
 514         String str = new String(array, 0, length);\r
 515         if (!(str.equals("01234test56789"))) {\r
 516         errln("FAIL inserting \"test\"");\r
 517         }\r
 518         UTF16.insert(strbuff, 0, 0x10000);\r
 519         UTF16.insert(strbuff, 11, 0x10000);\r
 520         UTF16.insert(strbuff, strbuff.length(), 0x10000);\r
 521         if (!(strbuff.toString().equals(\r
 522                     "\ud800\udc0001234test\ud800\udc0056789\ud800\udc00"))) {\r
 523         errln("FAIL inserting supplementary characters");\r
 524         }\r
 525         length = UTF16.insert(array, length, 0, 0x10000);\r
 526         length = UTF16.insert(array, length, 11, 0x10000);\r
 527         length = UTF16.insert(array, length, length, 0x10000);\r
 528         str = new String(array, 0, length);\r
 529         if (!(str.equals(\r
 530              "\ud800\udc0001234test\ud800\udc0056789\ud800\udc00"))) {\r
 531         errln("FAIL inserting supplementary characters");\r
 532         }\r
 533 \r
 534         try {\r
 535         UTF16.insert(strbuff, -1, 0);\r
 536         errln("FAIL invalid insertion offset");\r
 537         } catch (Exception e) {\r
 538         System.out.print("");\r
 539         }\r
 540         try {\r
 541         UTF16.insert(strbuff, 64, 0);\r
 542         errln("FAIL invalid insertion offset");\r
 543         } catch (Exception e) {\r
 544         System.out.print("");\r
 545         }\r
 546         try {\r
 547         UTF16.insert(array, length, -1, 0);\r
 548         errln("FAIL invalid insertion offset");\r
 549         } catch (Exception e) {\r
 550         System.out.print("");\r
 551         }\r
 552         try {\r
 553         UTF16.insert(array, length, 64, 0);\r
 554         errln("FAIL invalid insertion offset");\r
 555         } catch (Exception e) {\r
 556         System.out.print("");\r
 557         }\r
 558         try {\r
 559         // exceeded array size\r
 560         UTF16.insert(array, array.length, 64, 0);\r
 561         errln("FAIL invalid insertion offset");\r
 562         } catch (Exception e) {\r
 563         System.out.print("");\r
 564         }\r
 565     }\r
 566 \r
 567     /*\r
 568      * Testing moveCodePointOffset APIs\r
 569      */\r
 570 \r
 571     //\r
 572     //   checkMoveCodePointOffset\r
 573     //      Run a single test case through each of the moveCodePointOffset() functions.\r
 574     //          Parameters -\r
 575     //              s               The string to work in.\r
 576     //              startIdx        The starting position within the string.\r
 577     //              amount          The number of code points to move.\r
 578     //              expectedResult  The string index after the move, or -1 if the\r
 579     //                              function should throw an exception.\r
 580     private void checkMoveCodePointOffset(String s, int startIdx, int amount, int expectedResult) {\r
 581         // Test with the String flavor of moveCodePointOffset\r
 582         try {\r
 583             int result = UTF16.moveCodePointOffset(s, startIdx, amount);\r
 584             if (result != expectedResult) {\r
 585                 errln("FAIL: UTF16.moveCodePointOffset(String \"" + s + "\", " + startIdx + ", " + amount + ")" +\r
 586                         " returned "  + result + ", expected result was " +\r
 587                         (expectedResult==-1 ? "exception" : Integer.toString(expectedResult)));\r
 588             }\r
 589         }\r
 590         catch (IndexOutOfBoundsException e) {\r
 591             if (expectedResult != -1) {\r
 592                 errln("FAIL: UTF16.moveCodePointOffset(String \"" + s + "\", " + startIdx + ", " + amount + ")" +\r
 593                         " returned exception" + ", expected result was " + expectedResult);\r
 594             }\r
 595         }\r
 596 \r
 597         // Test with the StringBuffer flavor of moveCodePointOffset\r
 598         StringBuffer sb = new StringBuffer(s);\r
 599         try {\r
 600             int result = UTF16.moveCodePointOffset(sb, startIdx, amount);\r
 601             if (result != expectedResult) {\r
 602                 errln("FAIL: UTF16.moveCodePointOffset(StringBuffer \"" + s + "\", " + startIdx + ", " + amount + ")" +\r
 603                         " returned "  + result + ", expected result was " +\r
 604                         (expectedResult==-1 ? "exception" : Integer.toString(expectedResult)));\r
 605             }\r
 606         }\r
 607         catch (IndexOutOfBoundsException e) {\r
 608             if (expectedResult != -1) {\r
 609                 errln("FAIL: UTF16.moveCodePointOffset(StringBuffer \"" + s + "\", " + startIdx + ", " + amount + ")" +\r
 610                         " returned exception" + ", expected result was " + expectedResult);\r
 611             }\r
 612         }\r
 613 \r
 614         // Test with the char[] flavor of moveCodePointOffset\r
 615         char ca[] = s.toCharArray();\r
 616         try {\r
 617             int result = UTF16.moveCodePointOffset(ca, 0, s.length(), startIdx, amount);\r
 618             if (result != expectedResult) {\r
 619                 errln("FAIL: UTF16.moveCodePointOffset(char[] \"" + s + "\", 0, " + s.length()\r
 620                         + ", " + startIdx + ", " + amount + ")" +\r
 621                         " returned "  + result + ", expected result was " +\r
 622                         (expectedResult==-1 ? "exception" : Integer.toString(expectedResult)));\r
 623             }\r
 624         }\r
 625         catch (IndexOutOfBoundsException e) {\r
 626             if (expectedResult != -1) {\r
 627                 errln("FAIL: UTF16.moveCodePointOffset(char[] \"" + s + "\", 0, " + s.length()\r
 628                         + ", " + startIdx + ", " + amount + ")" +\r
 629                         " returned exception" + ", expected result was " + expectedResult);\r
 630             }\r
 631         }\r
 632 \r
 633         // Put the test string into the interior of a char array,\r
 634         //   run test on the subsection of the array.\r
 635         char ca2[] = new char[s.length()+2];\r
 636         ca2[0] = (char)0xd800;\r
 637         ca2[s.length()+1] = (char)0xd8ff;\r
 638         s.getChars(0, s.length(), ca2, 1);\r
 639         try {\r
 640             int result = UTF16.moveCodePointOffset(ca2, 1, s.length()+1, startIdx, amount);\r
 641             if (result != expectedResult) {\r
 642                 errln("UTF16.moveCodePointOffset(char[] \"" + "." + s + ".\", 1, " + (s.length()+1)\r
 643                         + ", " + startIdx + ", " + amount + ")" +\r
 644                          " returned "  + result + ", expected result was " +\r
 645                         (expectedResult==-1 ? "exception" : Integer.toString(expectedResult)));\r
 646             }\r
 647         }\r
 648         catch (IndexOutOfBoundsException e) {\r
 649             if (expectedResult != -1) {\r
 650                 errln("UTF16.moveCodePointOffset(char[] \"" + "." + s + ".\", 1, " + (s.length()+1)\r
 651                         + ", " + startIdx + ", " + amount + ")" +\r
 652                         " returned exception" + ", expected result was " + expectedResult);\r
 653             }\r
 654         }\r
 655 \r
 656     }\r
 657 \r
 658 \r
 659     public void TestMoveCodePointOffset()\r
 660     {\r
 661         // checkMoveCodePointOffset(String, startIndex, amount, expected );  expected=-1 for exception.\r
 662 \r
 663         // No Supplementary chars\r
 664         checkMoveCodePointOffset("abc", 1,  1, 2);\r
 665         checkMoveCodePointOffset("abc", 1, -1, 0);\r
 666         checkMoveCodePointOffset("abc", 1, -2, -1);\r
 667         checkMoveCodePointOffset("abc", 1,  2, 3);\r
 668         checkMoveCodePointOffset("abc", 1,  3, -1);\r
 669         checkMoveCodePointOffset("abc", 1,  0, 1);\r
 670 \r
 671         checkMoveCodePointOffset("abc", 3, 0, 3);\r
 672         checkMoveCodePointOffset("abc", 4, 0, -1);\r
 673         checkMoveCodePointOffset("abc", 0, 0, 0);\r
 674         checkMoveCodePointOffset("abc", -1, 0, -1);\r
 675 \r
 676         checkMoveCodePointOffset("", 0, 0, 0);\r
 677         checkMoveCodePointOffset("", 0, -1, -1);\r
 678         checkMoveCodePointOffset("", 0, 1, -1);\r
 679 \r
 680         checkMoveCodePointOffset("a", 0, 0, 0);\r
 681         checkMoveCodePointOffset("a", 1, 0, 1);\r
 682         checkMoveCodePointOffset("a", 0, 1, 1);\r
 683         checkMoveCodePointOffset("a", 1, -1, 0);\r
 684 \r
 685 \r
 686         // Supplementary in middle of string\r
 687         checkMoveCodePointOffset("a\ud800\udc00b", 0, 1, 1);\r
 688         checkMoveCodePointOffset("a\ud800\udc00b", 0, 2, 3);\r
 689         checkMoveCodePointOffset("a\ud800\udc00b", 0, 3, 4);\r
 690         checkMoveCodePointOffset("a\ud800\udc00b", 0, 4, -1);\r
 691 \r
 692         checkMoveCodePointOffset("a\ud800\udc00b", 4, -1, 3);\r
 693         checkMoveCodePointOffset("a\ud800\udc00b", 4, -2, 1);\r
 694         checkMoveCodePointOffset("a\ud800\udc00b", 4, -3, 0);\r
 695         checkMoveCodePointOffset("a\ud800\udc00b", 4, -4, -1);\r
 696 \r
 697         // Supplementary at start of string\r
 698         checkMoveCodePointOffset("\ud800\udc00ab", 0, 1, 2);\r
 699         checkMoveCodePointOffset("\ud800\udc00ab", 1, 1, 2);\r
 700         checkMoveCodePointOffset("\ud800\udc00ab", 2, 1, 3);\r
 701         checkMoveCodePointOffset("\ud800\udc00ab", 2, -1, 0);\r
 702         checkMoveCodePointOffset("\ud800\udc00ab", 1, -1, 0);\r
 703         checkMoveCodePointOffset("\ud800\udc00ab", 0, -1, -1);\r
 704 \r
 705 \r
 706         // Supplementary at end of string\r
 707         checkMoveCodePointOffset("ab\ud800\udc00", 1, 1, 2);\r
 708         checkMoveCodePointOffset("ab\ud800\udc00", 2, 1, 4);\r
 709         checkMoveCodePointOffset("ab\ud800\udc00", 3, 1, 4);\r
 710         checkMoveCodePointOffset("ab\ud800\udc00", 4, 1, -1);\r
 711 \r
 712         checkMoveCodePointOffset("ab\ud800\udc00", 5, -2, -1);\r
 713         checkMoveCodePointOffset("ab\ud800\udc00", 4, -1, 2);\r
 714         checkMoveCodePointOffset("ab\ud800\udc00", 3, -1, 2);\r
 715         checkMoveCodePointOffset("ab\ud800\udc00", 2, -1, 1);\r
 716         checkMoveCodePointOffset("ab\ud800\udc00", 1, -1, 0);\r
 717 \r
 718         // Unpaired surrogate in middle\r
 719         checkMoveCodePointOffset("a\ud800b", 0, 1, 1);\r
 720         checkMoveCodePointOffset("a\ud800b", 1, 1, 2);\r
 721         checkMoveCodePointOffset("a\ud800b", 2, 1, 3);\r
 722 \r
 723         checkMoveCodePointOffset("a\udc00b", 0, 1, 1);\r
 724         checkMoveCodePointOffset("a\udc00b", 1, 1, 2);\r
 725         checkMoveCodePointOffset("a\udc00b", 2, 1, 3);\r
 726 \r
 727         checkMoveCodePointOffset("a\udc00\ud800b", 0, 1, 1);\r
 728         checkMoveCodePointOffset("a\udc00\ud800b", 1, 1, 2);\r
 729         checkMoveCodePointOffset("a\udc00\ud800b", 2, 1, 3);\r
 730         checkMoveCodePointOffset("a\udc00\ud800b", 3, 1, 4);\r
 731 \r
 732         checkMoveCodePointOffset("a\ud800b", 1, -1, 0);\r
 733         checkMoveCodePointOffset("a\ud800b", 2, -1, 1);\r
 734         checkMoveCodePointOffset("a\ud800b", 3, -1, 2);\r
 735 \r
 736         checkMoveCodePointOffset("a\udc00b", 1, -1, 0);\r
 737         checkMoveCodePointOffset("a\udc00b", 2, -1, 1);\r
 738         checkMoveCodePointOffset("a\udc00b", 3, -1, 2);\r
 739 \r
 740         checkMoveCodePointOffset("a\udc00\ud800b", 1, -1, 0);\r
 741         checkMoveCodePointOffset("a\udc00\ud800b", 2, -1, 1);\r
 742         checkMoveCodePointOffset("a\udc00\ud800b", 3, -1, 2);\r
 743         checkMoveCodePointOffset("a\udc00\ud800b", 4, -1, 3);\r
 744 \r
 745         // Unpaired surrogate at start\r
 746         checkMoveCodePointOffset("\udc00ab", 0, 1, 1);\r
 747         checkMoveCodePointOffset("\ud800ab", 0, 2, 2);\r
 748         checkMoveCodePointOffset("\ud800\ud800ab", 0, 3, 3);\r
 749         checkMoveCodePointOffset("\udc00\udc00ab", 0, 4, 4);\r
 750 \r
 751         checkMoveCodePointOffset("\udc00ab", 2, -1, 1);\r
 752         checkMoveCodePointOffset("\ud800ab", 1, -1, 0);\r
 753         checkMoveCodePointOffset("\ud800ab", 1, -2, -1);\r
 754         checkMoveCodePointOffset("\ud800\ud800ab", 2, -1, 1);\r
 755         checkMoveCodePointOffset("\udc00\udc00ab", 2, -2, 0);\r
 756         checkMoveCodePointOffset("\udc00\udc00ab", 2, -3, -1);\r
 757 \r
 758         // Unpaired surrogate at end\r
 759         checkMoveCodePointOffset("ab\udc00\udc00ab", 3, 1, 4);\r
 760         checkMoveCodePointOffset("ab\udc00\udc00ab", 2, 1, 3);\r
 761         checkMoveCodePointOffset("ab\udc00\udc00ab", 1, 1, 2);\r
 762 \r
 763         checkMoveCodePointOffset("ab\udc00\udc00ab", 4, -1, 3);\r
 764         checkMoveCodePointOffset("ab\udc00\udc00ab", 3, -1, 2);\r
 765         checkMoveCodePointOffset("ab\udc00\udc00ab", 2, -1, 1);\r
 766 \r
 767 \r
 768                                //01234567890     1     2     3     45678901234\r
 769         String str = new String("0123456789\ud800\udc00\ud801\udc010123456789");\r
 770         int move1[] = { 1,  2,  3,  4,  5,  6,  7,  8,  9, 10,\r
 771                        12, 12, 14, 14, 15, 16, 17, 18, 19, 20,\r
 772                        21, 22, 23, 24};\r
 773         int move2[] = { 2,  3,  4,  5,  6,  7,  8,  9, 10, 12,\r
 774                        14, 14, 15, 15, 16, 17, 18, 19, 20, 21,\r
 775                        22, 23, 24, -1};\r
 776         int move3[] = { 3,  4,  5,  6,  7,  8,  9, 10, 12, 14,\r
 777                        15, 15, 16, 16, 17, 18, 19, 20, 21, 22,\r
 778                        23, 24, -1, -1};\r
 779         int size = str.length();\r
 780         for (int i = 0; i < size; i ++) {\r
 781             checkMoveCodePointOffset(str, i, 1, move1[i]);\r
 782             checkMoveCodePointOffset(str, i, 2, move2[i]);\r
 783             checkMoveCodePointOffset(str, i, 3, move3[i]);\r
 784         }\r
 785 \r
 786         char strarray[] = str.toCharArray();\r
 787         if (UTF16.moveCodePointOffset(strarray, 9, 13, 0, 2) != 3) {\r
 788             errln("FAIL: Moving offset 0 by 2 codepoint in subarray [9, 13] " +\r
 789             "expected result 3");\r
 790         }\r
 791         if (UTF16.moveCodePointOffset(strarray, 9, 13, 1, 2) != 4) {\r
 792             errln("FAIL: Moving offset 1 by 2 codepoint in subarray [9, 13] " +\r
 793             "expected result 4");\r
 794         }\r
 795         if (UTF16.moveCodePointOffset(strarray, 11, 14, 0, 2) != 3) {\r
 796             errln("FAIL: Moving offset 0 by 2 codepoint in subarray [11, 14] "\r
 797                     + "expected result 3");\r
 798         }\r
 799     }\r
 800 \r
 801     /**\r
 802      * Testing UTF16 class methods setCharAt\r
 803      */\r
 804     public void TestSetCharAt()\r
 805     {\r
 806         StringBuffer strbuff = new StringBuffer("012345");\r
 807         char array[] = new char[128];\r
 808         int srcEnd = strbuff.length();\r
 809         if (0 != srcEnd) {\r
 810             strbuff.getChars(0, srcEnd, array, 0);\r
 811         }\r
 812         int length = 6;\r
 813         for (int i = 0; i < length; i ++) {\r
 814         UTF16.setCharAt(strbuff, i, '0');\r
 815         UTF16.setCharAt(array, length, i, '0');\r
 816         }\r
 817         String str = new String(array, 0, length);\r
 818         if (!(strbuff.toString().equals("000000")) ||\r
 819         !(str.equals("000000"))) {\r
 820         errln("FAIL: setChar to '0' failed");\r
 821         }\r
 822         UTF16.setCharAt(strbuff, 0, 0x10000);\r
 823         UTF16.setCharAt(strbuff, 4, 0x10000);\r
 824         UTF16.setCharAt(strbuff, 7, 0x10000);\r
 825         if (!(strbuff.toString().equals(\r
 826                     "\ud800\udc0000\ud800\udc000\ud800\udc00"))) {\r
 827         errln("FAIL: setChar to 0x10000 failed");\r
 828         }\r
 829         length = UTF16.setCharAt(array, length, 0, 0x10000);\r
 830         length = UTF16.setCharAt(array, length, 4, 0x10000);\r
 831         length = UTF16.setCharAt(array, length, 7, 0x10000);\r
 832         str = new String(array, 0, length);\r
 833         if (!(str.equals("\ud800\udc0000\ud800\udc000\ud800\udc00"))) {\r
 834         errln("FAIL: setChar to 0x10000 failed");\r
 835         }\r
 836         UTF16.setCharAt(strbuff, 0, '0');\r
 837         UTF16.setCharAt(strbuff, 1, '1');\r
 838         UTF16.setCharAt(strbuff, 2, '2');\r
 839         UTF16.setCharAt(strbuff, 4, '3');\r
 840         UTF16.setCharAt(strbuff, 4, '4');\r
 841         UTF16.setCharAt(strbuff, 5, '5');\r
 842         if (!strbuff.toString().equals("012345")) {\r
 843         errln("Fail converting supplementaries in StringBuffer to BMP " +\r
 844           "characters");\r
 845         }\r
 846         length = UTF16.setCharAt(array, length, 0, '0');\r
 847         length = UTF16.setCharAt(array, length, 1, '1');\r
 848         length = UTF16.setCharAt(array, length, 2, '2');\r
 849         length = UTF16.setCharAt(array, length, 4, '3');\r
 850         length = UTF16.setCharAt(array, length, 4, '4');\r
 851         length = UTF16.setCharAt(array, length, 5, '5');\r
 852         str = new String(array, 0, length);\r
 853         if (!str.equals("012345")) {\r
 854         errln("Fail converting supplementaries in array to BMP " +\r
 855           "characters");\r
 856         }\r
 857         try {\r
 858         UTF16.setCharAt(strbuff, -1, 0);\r
 859         errln("FAIL: setting character at invalid offset");\r
 860         } catch (Exception e) {\r
 861         System.out.print("");\r
 862         }\r
 863         try {\r
 864         UTF16.setCharAt(array, length, -1, 0);\r
 865         errln("FAIL: setting character at invalid offset");\r
 866         } catch (Exception e) {\r
 867         System.out.print("");\r
 868         }\r
 869         try {\r
 870         UTF16.setCharAt(strbuff, length, 0);\r
 871         errln("FAIL: setting character at invalid offset");\r
 872         } catch (Exception e) {\r
 873         System.out.print("");\r
 874         }\r
 875         try {\r
 876         UTF16.setCharAt(array, length, length, 0);\r
 877         errln("FAIL: setting character at invalid offset");\r
 878         } catch (Exception e) {\r
 879         System.out.print("");\r
 880         }\r
 881     }\r
 882 \r
 883     /**\r
 884      * Testing UTF16 valueof APIs\r
 885      */\r
 886     public void TestValueOf()\r
 887     {\r
 888         if(UCharacter.getCodePoint('\ud800','\udc00')!=0x10000){\r
 889             errln("FAIL: getCodePoint('\ud800','\udc00')");\r
 890         }\r
 891         if (!UTF16.valueOf(0x61).equals("a") ||\r
 892         !UTF16.valueOf(0x10000).equals("\ud800\udc00")) {\r
 893         errln("FAIL: valueof(char32)");\r
 894         }\r
 895         String str = new String("01234\ud800\udc0056789");\r
 896         StringBuffer strbuff = new StringBuffer(str);\r
 897         char array[] = str.toCharArray();\r
 898         int length = str.length();\r
 899 \r
 900         String expected[] = {"0", "1", "2", "3", "4", "\ud800\udc00",\r
 901                  "\ud800\udc00", "5", "6", "7", "8", "9"};\r
 902         for (int i = 0; i < length; i ++) {\r
 903         if (!UTF16.valueOf(str, i).equals(expected[i]) ||\r
 904                 !UTF16.valueOf(strbuff, i).equals(expected[i]) ||\r
 905                 !UTF16.valueOf(array, 0, length, i).equals(expected[i])) {\r
 906                 errln("FAIL: valueOf() expected " + expected[i]);\r
 907         }\r
 908         }\r
 909         try {\r
 910         UTF16.valueOf(str, -1);\r
 911         errln("FAIL: out of bounds error expected");\r
 912         } catch (Exception e) {\r
 913         System.out.print("");\r
 914         }\r
 915         try {\r
 916         UTF16.valueOf(strbuff, -1);\r
 917         errln("FAIL: out of bounds error expected");\r
 918         } catch (Exception e) {\r
 919         System.out.print("");\r
 920         }\r
 921         try {\r
 922         UTF16.valueOf(array, 0, length, -1);\r
 923         errln("FAIL: out of bounds error expected");\r
 924         } catch (Exception e) {\r
 925         System.out.print("");\r
 926         }\r
 927         try {\r
 928         UTF16.valueOf(str, length);\r
 929         errln("FAIL: out of bounds error expected");\r
 930         } catch (Exception e) {\r
 931         System.out.print("");\r
 932         }\r
 933         try {\r
 934         UTF16.valueOf(strbuff, length);\r
 935         errln("FAIL: out of bounds error expected");\r
 936         } catch (Exception e) {\r
 937         System.out.print("");\r
 938         }\r
 939         try {\r
 940         UTF16.valueOf(array, 0, length, length);\r
 941         errln("FAIL: out of bounds error expected");\r
 942         } catch (Exception e) {\r
 943         System.out.print("");\r
 944         }\r
 945         if (!UTF16.valueOf(array, 6, length, 0).equals("\udc00") ||\r
 946         !UTF16.valueOf(array, 0, 6, 5).equals("\ud800")) {\r
 947         errln("FAIL: error getting partial supplementary character");\r
 948         }\r
 949         try {\r
 950         UTF16.valueOf(array, 3, 5, -1);\r
 951         errln("FAIL: out of bounds error expected");\r
 952         } catch (Exception e) {\r
 953         System.out.print("");\r
 954         }\r
 955         try {\r
 956         UTF16.valueOf(array, 3, 5, 3);\r
 957         errln("FAIL: out of bounds error expected");\r
 958         } catch (Exception e) {\r
 959         System.out.print("");\r
 960         }\r
 961     }\r
 962 \r
 963     public void TestIndexOf()\r
 964     {\r
 965     //012345678901234567890123456789012345\r
 966         String test1     = "test test ttest tetest testesteststt";\r
 967         String test2     = "test";\r
 968         int    testChar1 = 0x74;\r
 969         int    testChar2 = 0x20402;\r
 970         // int    testChar3 = 0xdc02;\r
 971         // int    testChar4 = 0xd841;\r
 972         String test3     = "\ud841\udc02\u0071\udc02\ud841\u0071\ud841\udc02\u0071\u0072\ud841\udc02\u0071\ud841\udc02\u0071\udc02\ud841\u0073";\r
 973         String test4     = UCharacter.toString(testChar2);\r
 974 \r
 975         if (UTF16.indexOf(test1, test2) != 0 ||\r
 976             UTF16.indexOf(test1, test2, 0) != 0) {\r
 977             errln("indexOf failed: expected to find '" + test2 +\r
 978                   "' at position 0 in text '" + test1 + "'");\r
 979         }\r
 980         if (UTF16.indexOf(test1, testChar1) != 0 ||\r
 981             UTF16.indexOf(test1, testChar1, 0) != 0) {\r
 982             errln("indexOf failed: expected to find 0x" +\r
 983                   Integer.toHexString(testChar1) +\r
 984                   " at position 0 in text '" + test1 + "'");\r
 985         }\r
 986         if (UTF16.indexOf(test3, testChar2) != 0 ||\r
 987             UTF16.indexOf(test3, testChar2, 0) != 0) {\r
 988             errln("indexOf failed: expected to find 0x" +\r
 989                   Integer.toHexString(testChar2) +\r
 990                   " at position 0 in text '" + Utility.hex(test3) + "'");\r
 991         }\r
 992         String test5 = "\ud841\ud841\udc02";\r
 993         if (UTF16.indexOf(test5, testChar2) != 1 ||\r
 994             UTF16.indexOf(test5, testChar2, 0) != 1) {\r
 995             errln("indexOf failed: expected to find 0x" +\r
 996                   Integer.toHexString(testChar2) +\r
 997                   " at position 0 in text '" + Utility.hex(test3) + "'");\r
 998         }\r
 999         if (UTF16.lastIndexOf(test1, test2) != 29 ||\r
1000             UTF16.lastIndexOf(test1, test2, test1.length()) != 29) {\r
1001             errln("lastIndexOf failed: expected to find '" + test2 +\r
1002                   "' at position 29 in text '" + test1 + "'");\r
1003         }\r
1004         if (UTF16.lastIndexOf(test1, testChar1) != 35 ||\r
1005             UTF16.lastIndexOf(test1, testChar1, test1.length()) != 35) {\r
1006             errln("lastIndexOf failed: expected to find 0x" +\r
1007                   Integer.toHexString(testChar1) +\r
1008                   " at position 35 in text '" + test1 + "'");\r
1009         }\r
1010         if (UTF16.lastIndexOf(test3, testChar2) != 13 ||\r
1011             UTF16.lastIndexOf(test3, testChar2, test3.length()) != 13) {\r
1012             errln("indexOf failed: expected to find 0x" +\r
1013                   Integer.toHexString(testChar2) +\r
1014                   " at position 13 in text '" + Utility.hex(test3) + "'");\r
1015         }\r
1016         int occurrences = 0;\r
1017         for (int startPos = 0; startPos != -1 && startPos < test1.length();)\r
1018         {\r
1019         startPos = UTF16.indexOf(test1, test2, startPos);\r
1020         if (startPos >= 0) {\r
1021             ++ occurrences;\r
1022             startPos += 4;\r
1023         }\r
1024         }\r
1025         if (occurrences != 6) {\r
1026             errln("indexOf failed: expected to find 6 occurrences, found "\r
1027                   + occurrences);\r
1028         }\r
1029 \r
1030         occurrences = 0;\r
1031         for (int startPos = 10; startPos != -1 && startPos < test1.length();)\r
1032         {\r
1033         startPos = UTF16.indexOf(test1, test2, startPos);\r
1034         if (startPos >= 0) {\r
1035             ++ occurrences;\r
1036             startPos += 4;\r
1037         }\r
1038         }\r
1039         if (occurrences != 4) {\r
1040             errln("indexOf with starting offset failed: expected to find 4 occurrences, found "\r
1041                   + occurrences);\r
1042         }\r
1043 \r
1044         occurrences = 0;\r
1045         for (int startPos = 0;\r
1046          startPos != -1 && startPos < test3.length();) {\r
1047             startPos = UTF16.indexOf(test3, test4, startPos);\r
1048             if (startPos != -1) {\r
1049                 ++ occurrences;\r
1050                 startPos += 2;\r
1051             }\r
1052         }\r
1053         if (occurrences != 4) {\r
1054             errln("indexOf failed: expected to find 4 occurrences, found "\r
1055           + occurrences);\r
1056         }\r
1057 \r
1058         occurrences = 0;\r
1059         for (int startPos = 10;\r
1060              startPos != -1 && startPos < test3.length();) {\r
1061             startPos = UTF16.indexOf(test3, test4, startPos);\r
1062             if (startPos != -1) {\r
1063                 ++ occurrences;\r
1064                 startPos += 2;\r
1065             }\r
1066         }\r
1067         if (occurrences != 2) {\r
1068             errln("indexOf failed: expected to find 2 occurrences, found "\r
1069                   + occurrences);\r
1070         }\r
1071 \r
1072         occurrences = 0;\r
1073         for (int startPos = 0;\r
1074          startPos != -1 && startPos < test1.length();) {\r
1075             startPos = UTF16.indexOf(test1, testChar1, startPos);\r
1076             if (startPos != -1) {\r
1077                 ++ occurrences;\r
1078                 startPos += 1;\r
1079             }\r
1080         }\r
1081         if (occurrences != 16) {\r
1082             errln("indexOf with character failed: expected to find 16 occurrences, found "\r
1083                   + occurrences);\r
1084         }\r
1085 \r
1086         occurrences = 0;\r
1087         for (int startPos = 10;\r
1088          startPos != -1 && startPos < test1.length();) {\r
1089             startPos = UTF16.indexOf(test1, testChar1, startPos);\r
1090             if (startPos != -1) {\r
1091                 ++ occurrences;\r
1092                 startPos += 1;\r
1093             }\r
1094         }\r
1095         if (occurrences != 12) {\r
1096             errln("indexOf with character & start offset failed: expected to find 12 occurrences, found "\r
1097           + occurrences);\r
1098         }\r
1099 \r
1100         occurrences = 0;\r
1101         for (int startPos = 0;\r
1102          startPos != -1 && startPos < test3.length();) {\r
1103             startPos = UTF16.indexOf(test3, testChar2, startPos);\r
1104             if (startPos != -1) {\r
1105                 ++ occurrences;\r
1106                 startPos += 1;\r
1107             }\r
1108         }\r
1109         if (occurrences != 4) {\r
1110             errln("indexOf failed: expected to find 4 occurrences, found "\r
1111                   + occurrences);\r
1112         }\r
1113 \r
1114         occurrences = 0;\r
1115         for (int startPos = 5; startPos != -1 && startPos < test3.length();) {\r
1116             startPos = UTF16.indexOf(test3, testChar2, startPos);\r
1117             if (startPos != -1) {\r
1118                 ++ occurrences;\r
1119                 startPos += 1;\r
1120             }\r
1121         }\r
1122         if (occurrences != 3) {\r
1123             errln("indexOf with character & start & end offsets failed: expected to find 2 occurrences, found "\r
1124           + occurrences);\r
1125         }\r
1126         occurrences = 0;\r
1127         for (int startPos = 32; startPos != -1;) {\r
1128             startPos = UTF16.lastIndexOf(test1, test2, startPos);\r
1129             if (startPos != -1) {\r
1130                 ++ occurrences;\r
1131                 startPos -= 5;\r
1132             }\r
1133         }\r
1134         if (occurrences != 6) {\r
1135             errln("lastIndexOf with starting and ending offsets failed: expected to find 4 occurrences, found "\r
1136                   + occurrences);\r
1137         }\r
1138         occurrences = 0;\r
1139         for (int startPos = 32; startPos != -1;) {\r
1140             startPos = UTF16.lastIndexOf(test1, testChar1, startPos);\r
1141             if (startPos != -1) {\r
1142                 ++ occurrences;\r
1143                 startPos -= 5;\r
1144             }\r
1145         }\r
1146         if (occurrences != 7) {\r
1147             errln("lastIndexOf with character & start & end offsets failed: expected to find 11 occurrences, found "\r
1148           + occurrences);\r
1149         }\r
1150 \r
1151         //testing UChar32\r
1152         occurrences = 0;\r
1153         for (int startPos = test3.length(); startPos != -1;) {\r
1154             startPos = UTF16.lastIndexOf(test3, testChar2, startPos - 5);\r
1155             if (startPos != -1) {\r
1156                 ++ occurrences;\r
1157             }\r
1158         }\r
1159         if (occurrences != 3) {\r
1160             errln("lastIndexOf with character & start & end offsets failed: expected to find 3 occurrences, found "\r
1161           + occurrences);\r
1162         }\r
1163 \r
1164         // testing supplementary\r
1165         for (int i = 0; i < INDEXOF_SUPPLEMENTARY_CHAR_.length; i ++) {\r
1166         int ch = INDEXOF_SUPPLEMENTARY_CHAR_[i];\r
1167         for (int j = 0; j < INDEXOF_SUPPLEMENTARY_CHAR_INDEX_[i].length;\r
1168          j ++) {\r
1169         int index = 0;\r
1170         int expected = INDEXOF_SUPPLEMENTARY_CHAR_INDEX_[i][j];\r
1171         if  (j > 0) {\r
1172             index = INDEXOF_SUPPLEMENTARY_CHAR_INDEX_[i][j - 1] + 1;\r
1173         }\r
1174         if (UTF16.indexOf(INDEXOF_SUPPLEMENTARY_STRING_, ch, index) !=\r
1175             expected ||\r
1176             UTF16.indexOf(INDEXOF_SUPPLEMENTARY_STRING_,\r
1177                   UCharacter.toString(ch), index) !=\r
1178             expected) {\r
1179             errln("Failed finding index for supplementary 0x" +\r
1180               Integer.toHexString(ch));\r
1181         }\r
1182         index = INDEXOF_SUPPLEMENTARY_STRING_.length();\r
1183         if (j < INDEXOF_SUPPLEMENTARY_CHAR_INDEX_[i].length - 1) {\r
1184             index = INDEXOF_SUPPLEMENTARY_CHAR_INDEX_[i][j + 1] - 1;\r
1185         }\r
1186         if (UTF16.lastIndexOf(INDEXOF_SUPPLEMENTARY_STRING_, ch,\r
1187                       index) != expected ||\r
1188             UTF16.lastIndexOf(INDEXOF_SUPPLEMENTARY_STRING_,\r
1189                       UCharacter.toString(ch), index)\r
1190             != expected)\r
1191             {\r
1192             errln("Failed finding last index for supplementary 0x" +\r
1193                   Integer.toHexString(ch));\r
1194             }\r
1195         }\r
1196         }\r
1197 \r
1198         for (int i = 0; i < INDEXOF_SUPPLEMENTARY_STR_INDEX_.length; i ++) {\r
1199         int index = 0;\r
1200         int expected = INDEXOF_SUPPLEMENTARY_STR_INDEX_[i];\r
1201         if  (i > 0) {\r
1202         index = INDEXOF_SUPPLEMENTARY_STR_INDEX_[i - 1] + 1;\r
1203         }\r
1204         if (UTF16.indexOf(INDEXOF_SUPPLEMENTARY_STRING_,\r
1205                   INDEXOF_SUPPLEMENTARY_STR_, index) != expected) {\r
1206         errln("Failed finding index for supplementary string " +\r
1207               hex(INDEXOF_SUPPLEMENTARY_STRING_));\r
1208         }\r
1209         index = INDEXOF_SUPPLEMENTARY_STRING_.length();\r
1210         if (i < INDEXOF_SUPPLEMENTARY_STR_INDEX_.length - 1) {\r
1211         index = INDEXOF_SUPPLEMENTARY_STR_INDEX_[i + 1] - 1;\r
1212         }\r
1213         if (UTF16.lastIndexOf(INDEXOF_SUPPLEMENTARY_STRING_,\r
1214                               INDEXOF_SUPPLEMENTARY_STR_, index) != expected) {\r
1215         errln("Failed finding last index for supplementary string " +\r
1216               hex(INDEXOF_SUPPLEMENTARY_STRING_));\r
1217         }\r
1218         }\r
1219     }\r
1220 \r
1221     public void TestReplace()\r
1222     {\r
1223         String test1 = "One potato, two potato, three potato, four\n";\r
1224         String test2 = "potato";\r
1225         String test3 = "MISSISSIPPI";\r
1226 \r
1227         String result = UTF16.replace(test1, test2, test3);\r
1228         String expectedValue =\r
1229             "One MISSISSIPPI, two MISSISSIPPI, three MISSISSIPPI, four\n";\r
1230         if (!result.equals(expectedValue)) {\r
1231             errln("findAndReplace failed: expected \"" + expectedValue +\r
1232                   "\", got \"" + test1 + "\".");\r
1233         }\r
1234         result = UTF16.replace(test1, test3, test2);\r
1235         expectedValue = test1;\r
1236         if (!result.equals(expectedValue)) {\r
1237             errln("findAndReplace failed: expected \"" + expectedValue +\r
1238                   "\", got \"" + test1 + "\".");\r
1239         }\r
1240 \r
1241         result = UTF16.replace(test1, ',', 'e');\r
1242         expectedValue = "One potatoe two potatoe three potatoe four\n";\r
1243         if (!result.equals(expectedValue)) {\r
1244             errln("findAndReplace failed: expected \"" + expectedValue +\r
1245                   "\", got \"" + test1 + "\".");\r
1246         }\r
1247 \r
1248         result = UTF16.replace(test1, ',', 0x10000);\r
1249         expectedValue = "One potato\ud800\udc00 two potato\ud800\udc00 three potato\ud800\udc00 four\n";\r
1250         if (!result.equals(expectedValue)) {\r
1251             errln("findAndReplace failed: expected \"" + expectedValue +\r
1252                   "\", got \"" + test1 + "\".");\r
1253         }\r
1254 \r
1255         result = UTF16.replace(test1, "potato", "\ud800\udc00\ud801\udc01");\r
1256         expectedValue = "One \ud800\udc00\ud801\udc01, two \ud800\udc00\ud801\udc01, three \ud800\udc00\ud801\udc01, four\n";\r
1257         if (!result.equals(expectedValue)) {\r
1258             errln("findAndReplace failed: expected \"" + expectedValue +\r
1259                   "\", got \"" + test1 + "\".");\r
1260         }\r
1261 \r
1262         String test4 = "\ud800\ud800\udc00\ud800\udc00\udc00\ud800\ud800\udc00\ud800\udc00\udc00";\r
1263         result = UTF16.replace(test4, 0xd800, 'A');\r
1264         expectedValue = "A\ud800\udc00\ud800\udc00\udc00A\ud800\udc00\ud800\udc00\udc00";\r
1265         if (!result.equals(expectedValue)) {\r
1266             errln("findAndReplace failed: expected \"" + expectedValue +\r
1267                   "\", got \"" + test1 + "\".");\r
1268         }\r
1269 \r
1270         result = UTF16.replace(test4, 0xdC00, 'A');\r
1271         expectedValue = "\ud800\ud800\udc00\ud800\udc00A\ud800\ud800\udc00\ud800\udc00A";\r
1272         if (!result.equals(expectedValue)) {\r
1273             errln("findAndReplace failed: expected \"" + expectedValue +\r
1274                   "\", got \"" + test1 + "\".");\r
1275         }\r
1276 \r
1277         result = UTF16.replace(test4, 0x10000, 'A');\r
1278         expectedValue = "\ud800AA\udc00\ud800AA\udc00";\r
1279         if (!result.equals(expectedValue)) {\r
1280             errln("findAndReplace failed: expected \"" + expectedValue +\r
1281                   "\", got \"" + test1 + "\".");\r
1282         }\r
1283     }\r
1284 \r
1285     public void TestReverse()\r
1286     {\r
1287         StringBuffer test = new StringBuffer(\r
1288                          "backwards words say to used I");\r
1289 \r
1290         StringBuffer result = UTF16.reverse(test);\r
1291         if (!result.toString().equals("I desu ot yas sdrow sdrawkcab")) {\r
1292             errln("reverse() failed:  Expected \"I desu ot yas sdrow sdrawkcab\",\n got \""\r
1293           + result + "\"");\r
1294         }\r
1295         StringBuffer testbuffer = new StringBuffer();\r
1296         UTF16.append(testbuffer, 0x2f999);\r
1297         UTF16.append(testbuffer, 0x1d15f);\r
1298         UTF16.append(testbuffer, 0x00c4);\r
1299         UTF16.append(testbuffer, 0x1ed0);\r
1300         result = UTF16.reverse(testbuffer);\r
1301         if (result.charAt(0) != 0x1ed0 ||\r
1302             result.charAt(1) != 0xc4 ||\r
1303             UTF16.charAt(result, 2) != 0x1d15f ||\r
1304             UTF16.charAt(result, 4)!=0x2f999) {\r
1305             errln("reverse() failed with supplementary characters");\r
1306         }\r
1307     }\r
1308 \r
1309     /**\r
1310      * Testing the setter and getter apis for StringComparator\r
1311      */\r
1312     public void TestStringComparator()\r
1313     {\r
1314         UTF16.StringComparator compare = new UTF16.StringComparator();\r
1315         if (compare.getCodePointCompare() != false) {\r
1316             errln("Default string comparator should be code unit compare");\r
1317         }\r
1318         if (compare.getIgnoreCase() != false) {\r
1319             errln("Default string comparator should be case sensitive compare");\r
1320         }\r
1321         if (compare.getIgnoreCaseOption()\r
1322             != UTF16.StringComparator.FOLD_CASE_DEFAULT) {\r
1323             errln("Default string comparator should have fold case default compare");\r
1324         }\r
1325         compare.setCodePointCompare(true);\r
1326         if (compare.getCodePointCompare() != true) {\r
1327             errln("Error setting code point compare");\r
1328         }\r
1329         compare.setCodePointCompare(false);\r
1330         if (compare.getCodePointCompare() != false) {\r
1331             errln("Error setting code point compare");\r
1332         }\r
1333         compare.setIgnoreCase(true, UTF16.StringComparator.FOLD_CASE_DEFAULT);\r
1334         if (compare.getIgnoreCase() != true\r
1335             || compare.getIgnoreCaseOption()\r
1336         != UTF16.StringComparator.FOLD_CASE_DEFAULT) {\r
1337             errln("Error setting ignore case and options");\r
1338         }\r
1339         compare.setIgnoreCase(false, UTF16.StringComparator.FOLD_CASE_EXCLUDE_SPECIAL_I);\r
1340         if (compare.getIgnoreCase() != false\r
1341             || compare.getIgnoreCaseOption()\r
1342         != UTF16.StringComparator.FOLD_CASE_EXCLUDE_SPECIAL_I) {\r
1343             errln("Error setting ignore case and options");\r
1344         }\r
1345         compare.setIgnoreCase(true, UTF16.StringComparator.FOLD_CASE_EXCLUDE_SPECIAL_I);\r
1346         if (compare.getIgnoreCase() != true\r
1347             || compare.getIgnoreCaseOption()\r
1348         != UTF16.StringComparator.FOLD_CASE_EXCLUDE_SPECIAL_I) {\r
1349             errln("Error setting ignore case and options");\r
1350         }\r
1351         compare.setIgnoreCase(false, UTF16.StringComparator.FOLD_CASE_DEFAULT);\r
1352         if (compare.getIgnoreCase() != false\r
1353             || compare.getIgnoreCaseOption()\r
1354         != UTF16.StringComparator.FOLD_CASE_DEFAULT) {\r
1355             errln("Error setting ignore case and options");\r
1356         }\r
1357     }\r
1358 \r
1359     public void TestCodePointCompare()\r
1360     {\r
1361         // these strings are in ascending order\r
1362         String str[] = {"\u0061", "\u20ac\ud801", "\u20ac\ud800\udc00",\r
1363                         "\ud800", "\ud800\uff61", "\udfff",\r
1364                         "\uff61\udfff", "\uff61\ud800\udc02", "\ud800\udc02",\r
1365                         "\ud84d\udc56"};\r
1366         UTF16.StringComparator cpcompare\r
1367             = new UTF16.StringComparator(true, false,\r
1368                      UTF16.StringComparator.FOLD_CASE_DEFAULT);\r
1369         UTF16.StringComparator cucompare\r
1370             = new UTF16.StringComparator();\r
1371         for (int i = 0; i < str.length - 1; ++ i) {\r
1372             if (cpcompare.compare(str[i], str[i + 1]) >= 0) {\r
1373                 errln("error: compare() in code point order fails for string "\r
1374                       + Utility.hex(str[i]) + " and "\r
1375                       + Utility.hex(str[i + 1]));\r
1376             }\r
1377             // test code unit compare\r
1378             if (cucompare.compare(str[i], str[i + 1])\r
1379                 != str[i].compareTo(str[i + 1])) {\r
1380                 errln("error: compare() in code unit order fails for string "\r
1381                       + Utility.hex(str[i]) + " and "\r
1382                       + Utility.hex(str[i + 1]));\r
1383             }\r
1384         }\r
1385     }\r
1386 \r
1387     public void TestCaseCompare()\r
1388     {\r
1389         String mixed = "\u0061\u0042\u0131\u03a3\u00df\ufb03\ud93f\udfff";\r
1390         String otherDefault = "\u0041\u0062\u0131\u03c3\u0073\u0053\u0046\u0066\u0049\ud93f\udfff";\r
1391         String otherExcludeSpecialI = "\u0041\u0062\u0131\u03c3\u0053\u0073\u0066\u0046\u0069\ud93f\udfff";\r
1392         String different = "\u0041\u0062\u0131\u03c3\u0073\u0053\u0046\u0066\u0049\ud93f\udffd";\r
1393 \r
1394         UTF16.StringComparator compare = new UTF16.StringComparator();\r
1395         compare.setIgnoreCase(true, UTF16.StringComparator.FOLD_CASE_DEFAULT);\r
1396         // test u_strcasecmp()\r
1397         int result = compare.compare(mixed, otherDefault);\r
1398         if (result != 0) {\r
1399             errln("error: default compare(mixed, other) = " + result\r
1400                   + " instead of 0");\r
1401         }\r
1402 \r
1403         // test u_strcasecmp() - exclude special i\r
1404         compare.setIgnoreCase(true,\r
1405                   UTF16.StringComparator.FOLD_CASE_EXCLUDE_SPECIAL_I);\r
1406         result = compare.compare(mixed, otherExcludeSpecialI);\r
1407         if (result != 0) {\r
1408             errln("error: exclude_i compare(mixed, other) = " + result\r
1409                   + " instead of 0");\r
1410         }\r
1411 \r
1412         // test u_strcasecmp()\r
1413         compare.setIgnoreCase(true,\r
1414                               UTF16.StringComparator.FOLD_CASE_DEFAULT);\r
1415         result = compare.compare(mixed, different);\r
1416         if (result <= 0) {\r
1417             errln("error: default compare(mixed, different) = " + result\r
1418                   + " instead of positive");\r
1419         }\r
1420 \r
1421         // test substrings - stop before the sharp s (U+00df)\r
1422         compare.setIgnoreCase(true,\r
1423                               UTF16.StringComparator.FOLD_CASE_DEFAULT);\r
1424         result = compare.compare(mixed.substring(0, 4),\r
1425                                  different.substring(0, 4));\r
1426         if (result != 0) {\r
1427             errln("error: default compare(mixed substring, different substring) = "\r
1428           + result + " instead of 0");\r
1429         }\r
1430         // test substrings - stop in the middle of the sharp s (U+00df)\r
1431         compare.setIgnoreCase(true,\r
1432                               UTF16.StringComparator.FOLD_CASE_DEFAULT);\r
1433         result = compare.compare(mixed.substring(0, 5),\r
1434                                  different.substring(0, 5));\r
1435         if (result <= 0) {\r
1436             errln("error: default compare(mixed substring, different substring) = "\r
1437           + result + " instead of positive");\r
1438         }\r
1439     }\r
1440 \r
1441     public void TestHasMoreCodePointsThan()\r
1442     {\r
1443         String str = "\u0061\u0062\ud800\udc00\ud801\udc01\u0063\ud802\u0064"\r
1444         + "\udc03\u0065\u0066\ud804\udc04\ud805\udc05\u0067";\r
1445         int length = str.length();\r
1446         while (length >= 0) {\r
1447             for (int i = 0; i <= length; ++ i) {\r
1448                 String s = str.substring(0, i);\r
1449                 for (int number = -1; number <= ((length - i) + 2); ++ number) {\r
1450                     boolean flag = UTF16.hasMoreCodePointsThan(s, number);\r
1451                     if (flag != (UTF16.countCodePoint(s) > number)) {\r
1452                         errln("hasMoreCodePointsThan(" + Utility.hex(s)\r
1453                               + ", " + number + ") = " + flag + " is wrong");\r
1454                     }\r
1455                 }\r
1456             }\r
1457             -- length;\r
1458         }\r
1459 \r
1460         // testing for null bad input\r
1461         for(length = -1; length <= 1; ++ length) {\r
1462             for (int i = 0; i <= length; ++ i) {\r
1463                 for (int number = -2; number <= 2; ++ number) {\r
1464                     boolean flag = UTF16.hasMoreCodePointsThan((String)null,\r
1465                                                                number);\r
1466                     if (flag != (UTF16.countCodePoint((String)null) > number)) {\r
1467                         errln("hasMoreCodePointsThan(null, " + number + ") = "\r
1468                   + flag + " is wrong");\r
1469                     }\r
1470                 }\r
1471             }\r
1472         }\r
1473 \r
1474         length = str.length();\r
1475         while (length >= 0) {\r
1476             for (int i = 0; i <= length; ++ i) {\r
1477                 StringBuffer s = new StringBuffer(str.substring(0, i));\r
1478                 for (int number = -1; number <= ((length - i) + 2); ++ number) {\r
1479                     boolean flag = UTF16.hasMoreCodePointsThan(s, number);\r
1480                     if (flag != (UTF16.countCodePoint(s) > number)) {\r
1481                         errln("hasMoreCodePointsThan(" + Utility.hex(s)\r
1482                               + ", " + number + ") = " + flag + " is wrong");\r
1483                     }\r
1484                 }\r
1485             }\r
1486             -- length;\r
1487         }\r
1488 \r
1489         // testing for null bad input\r
1490         for (length = -1; length <= 1; ++ length) {\r
1491             for (int i = 0; i <= length; ++ i) {\r
1492                 for (int number = -2; number <= 2; ++ number) {\r
1493                     boolean flag = UTF16.hasMoreCodePointsThan(\r
1494                                    (StringBuffer)null, number);\r
1495                     if (flag\r
1496                         != (UTF16.countCodePoint((StringBuffer)null) > number))\r
1497             {\r
1498                 errln("hasMoreCodePointsThan(null, " + number + ") = "\r
1499                   + flag + " is wrong");\r
1500             }\r
1501                 }\r
1502             }\r
1503         }\r
1504 \r
1505         char strarray[] = str.toCharArray();\r
1506         while (length >= 0) {\r
1507             for (int limit = 0; limit <= length; ++ limit) {\r
1508                 for (int start = 0; start <= limit; ++ start) {\r
1509                     for (int number = -1; number <= ((limit - start) + 2);\r
1510                          ++ number) {\r
1511                         boolean flag = UTF16.hasMoreCodePointsThan(strarray,\r
1512                                    start, limit, number);\r
1513                         if (flag != (UTF16.countCodePoint(strarray, start,\r
1514                                                           limit) > number)) {\r
1515                             errln("hasMoreCodePointsThan("\r
1516                                   + Utility.hex(str.substring(start, limit))\r
1517                                   + ", " + start + ", " + limit + ", " + number\r
1518                                   + ") = " + flag + " is wrong");\r
1519                         }\r
1520                     }\r
1521                 }\r
1522             }\r
1523             -- length;\r
1524         }\r
1525 \r
1526         // testing for null bad input\r
1527         for (length = -1; length <= 1; ++ length) {\r
1528             for (int i = 0; i <= length; ++ i) {\r
1529                 for (int number = -2; number <= 2; ++ number) {\r
1530                     boolean flag = UTF16.hasMoreCodePointsThan(\r
1531                                    (StringBuffer)null, number);\r
1532                     if (flag\r
1533                         != (UTF16.countCodePoint((StringBuffer)null) > number))\r
1534             {\r
1535                 errln("hasMoreCodePointsThan(null, " + number + ") = "\r
1536                   + flag + " is wrong");\r
1537             }\r
1538                 }\r
1539             }\r
1540         }\r
1541 \r
1542         // bad input\r
1543         try {\r
1544             UTF16.hasMoreCodePointsThan(strarray, -2, -1, 5);\r
1545             errln("hasMoreCodePointsThan(chararray) with negative indexes has to throw an exception");\r
1546         } catch (Exception e) {\r
1547             logln("PASS: UTF16.hasMoreCodePointsThan failed as expected");\r
1548         }\r
1549         try {\r
1550             UTF16.hasMoreCodePointsThan(strarray, 5, 2, 5);\r
1551             errln("hasMoreCodePointsThan(chararray) with limit less than start index has to throw an exception");\r
1552         } catch (Exception e) {\r
1553             logln("PASS: UTF16.hasMoreCodePointsThan failed as expected");\r
1554         }\r
1555         try {\r
1556             if (UTF16.hasMoreCodePointsThan(strarray, -2, 2, 5)) {\r
1557                 errln("hasMoreCodePointsThan(chararray) with negative start indexes can't return true");\r
1558             }\r
1559         } catch (Exception e) {\r
1560         }\r
1561     }\r
1562 \r
1563     public void TestNewString() {\r
1564     final int[] codePoints = {\r
1565         UCharacter.toCodePoint(UCharacter.MIN_HIGH_SURROGATE, UCharacter.MAX_LOW_SURROGATE),\r
1566         UCharacter.toCodePoint(UCharacter.MAX_HIGH_SURROGATE, UCharacter.MIN_LOW_SURROGATE),\r
1567         UCharacter.MAX_HIGH_SURROGATE,\r
1568         'A',\r
1569         -1,\r
1570     };\r
1571 \r
1572     final String cpString = "" +\r
1573         UCharacter.MIN_HIGH_SURROGATE +\r
1574         UCharacter.MAX_LOW_SURROGATE +\r
1575         UCharacter.MAX_HIGH_SURROGATE +\r
1576         UCharacter.MIN_LOW_SURROGATE +\r
1577         UCharacter.MAX_HIGH_SURROGATE +\r
1578         'A';\r
1579 \r
1580     final int[][] tests = {\r
1581         { 0, 1, 0, 2 },\r
1582         { 0, 2, 0, 4 },\r
1583         { 1, 1, 2, 2 },\r
1584         { 1, 2, 2, 3 },\r
1585         { 1, 3, 2, 4 },\r
1586         { 2, 2, 4, 2 },\r
1587         { 2, 3, 0, -1 },\r
1588         { 4, 5, 0, -1 },\r
1589         { 3, -1, 0, -1 }\r
1590     };\r
1591 \r
1592      for (int i = 0; i < tests.length; ++i) {\r
1593         int[] t = tests[i];\r
1594         int s = t[0];\r
1595         int c = t[1];\r
1596         int rs = t[2];\r
1597         int rc = t[3];\r
1598 \r
1599         Exception e = null;\r
1600         try {\r
1601         String str = UTF16.newString(codePoints, s, c);\r
1602         if (rc == -1 || !str.equals(cpString.substring(rs, rs+rc))) {\r
1603             errln("failed codePoints iter: " + i + " start: " + s + " len: " + c);\r
1604         }\r
1605         continue;\r
1606         }\r
1607         catch (IndexOutOfBoundsException e1) {\r
1608         e = e1;\r
1609         }\r
1610         catch (IllegalArgumentException e2) {\r
1611         e = e2;\r
1612         }\r
1613         if (rc != -1) {\r
1614         errln(e.getMessage());\r
1615         }\r
1616     }\r
1617     }\r
1618 \r
1619     public static void main(String[] arg)\r
1620     {\r
1621         try\r
1622         {\r
1623         UTF16Test test = new UTF16Test();\r
1624         test.run(arg);\r
1625         // test.TestCaseCompare();\r
1626         }\r
1627         catch (Exception e)\r
1628         {\r
1629         e.printStackTrace();\r
1630         }\r
1631     }\r
1632 \r
1633 \r
1634     // private data members ----------------------------------------------\r
1635 \r
1636     private final static String INDEXOF_SUPPLEMENTARY_STRING_ =\r
1637         "\ud841\udc02\u0071\udc02\ud841\u0071\ud841\udc02\u0071\u0072" +\r
1638         "\ud841\udc02\u0071\ud841\udc02\u0071\udc02\ud841\u0073";\r
1639     private final static int INDEXOF_SUPPLEMENTARY_CHAR_[] =\r
1640     {0x71, 0xd841, 0xdc02,\r
1641      UTF16Util.getRawSupplementary((char)0xd841,\r
1642                  (char)0xdc02)};\r
1643     private final static int INDEXOF_SUPPLEMENTARY_CHAR_INDEX_[][] =\r
1644     {{2, 5, 8, 12, 15},\r
1645      {4, 17},\r
1646      {3, 16},\r
1647      {0, 6, 10, 13}\r
1648     };\r
1649     private final static String INDEXOF_SUPPLEMENTARY_STR_ = "\udc02\ud841";\r
1650     private final static int INDEXOF_SUPPLEMENTARY_STR_INDEX_[] =\r
1651     {3, 16};\r
1652 \r
1653     // private methods ---------------------------------------------------\r
1654 }\r
1655 \r