jars/icu4j-4_2_1-src/src/com/ibm/icu/dev/test/lang/UTF16Test.java

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