icuSources/test/intltest/regcoll.cpp

   1 /********************************************************************
   2  * COPYRIGHT:
   3  * Copyright (c) 1997-2014, International Business Machines Corporation and
   4  * others. All Rights Reserved.
   5  ********************************************************************/
   6
   7 #include "unicode/utypes.h"
   8
   9 #if !UCONFIG_NO_COLLATION
  10
  11 #include "unicode/coll.h"
  12 #include "unicode/localpointer.h"
  13 #include "unicode/tblcoll.h"
  14 #include "unicode/unistr.h"
  15 #include "unicode/sortkey.h"
  16 #include "regcoll.h"
  17 #include "sfwdchit.h"
  18 #include "testutil.h"
  19 #include "cmemory.h"
  20
  21 #define ARRAY_LENGTH(array) ((int32_t)(sizeof array / sizeof array[0]))
  22
  23 CollationRegressionTest::CollationRegressionTest()
  24 {
  25     UErrorCode status = U_ZERO_ERROR;
  26
  27     en_us = (RuleBasedCollator *)Collator::createInstance(Locale::getUS(), status);
  28     if(U_FAILURE(status)) {
  29       delete en_us;
  30       en_us = 0;
  31       errcheckln(status, "Collator creation failed with %s", u_errorName(status));
  32       return;
  33     }
  34 }
  35
  36 CollationRegressionTest::~CollationRegressionTest()
  37 {
  38     delete en_us;
  39 }
  40
  41
  42     // @bug 4048446
  43 //
  44 // CollationElementIterator.reset() doesn't work
  45 //
  46 void CollationRegressionTest::Test4048446(/* char* par */)
  47 {
  48     const UnicodeString test1 = "XFILE What subset of all possible test cases has the highest probability of detecting the most errors?";
  49     const UnicodeString test2 = "Xf_ile What subset of all possible test cases has the lowest probability of detecting the least errors?";
  50     CollationElementIterator *i1 = en_us->createCollationElementIterator(test1);
  51     CollationElementIterator *i2 = en_us->createCollationElementIterator(test1);
  52     UErrorCode status = U_ZERO_ERROR;
  53
  54     if (i1 == NULL|| i2 == NULL)
  55     {
  56         errln("Could not create CollationElementIterator's");
  57         delete i1;
  58         delete i2;
  59         return;
  60     }
  61
  62     while (i1->next(status) != CollationElementIterator::NULLORDER)
  63     {
  64         if (U_FAILURE(status))
  65         {
  66             errln("error calling next()");
  67
  68             delete i1;
  69             delete i2;
  70             return;
  71         }
  72     }
  73
  74     i1->reset();
  75
  76     assertEqual(*i1, *i2);
  77
  78     delete i1;
  79     delete i2;
  80 }
  81
  82 // @bug 4051866
  83 //
  84 // Collator -> rules -> Collator round-trip broken for expanding characters
  85 //
  86 void CollationRegressionTest::Test4051866(/* char* par */)
  87 {
  88     UnicodeString rules;
  89     UErrorCode status = U_ZERO_ERROR;
  90
  91     rules += "&n < o ";
  92     rules += "& oe ,o";
  93     rules += (UChar)0x3080;
  94     rules += "& oe ,";
  95     rules += (UChar)0x1530;
  96     rules += " ,O";
  97     rules += "& OE ,O";
  98     rules += (UChar)0x3080;
  99     rules += "& OE ,";
 100     rules += (UChar)0x1520;
 101     rules += "< p ,P";
 102
 103     // Build a collator containing expanding characters
 104     LocalPointer<RuleBasedCollator> c1(new RuleBasedCollator(rules, status));
 105
 106     // Build another using the rules from  the first
 107     LocalPointer<RuleBasedCollator> c2(new RuleBasedCollator(c1->getRules(), status));
 108     if (U_FAILURE(status)) {
 109         errln("RuleBasedCollator(rule string) failed - %s", u_errorName(status));
 110         return;
 111     }
 112
 113     // Make sure they're the same
 114     if (!(c1->getRules() == c2->getRules()))
 115     {
 116         errln("Rules are not equal");
 117     }
 118 }
 119
 120 // @bug 4053636
 121 //
 122 // Collator thinks "black-bird" == "black"
 123 //
 124 void CollationRegressionTest::Test4053636(/* char* par */)
 125 {
 126     if (en_us->equals("black_bird", "black"))
 127     {
 128         errln("black-bird == black");
 129     }
 130 }
 131
 132 // @bug 4054238
 133 //
 134 // CollationElementIterator will not work correctly if the associated
 135 // Collator object's mode is changed
 136 //
 137 void CollationRegressionTest::Test4054238(/* char* par */)
 138 {
 139     const UChar chars3[] = {0x61, 0x00FC, 0x62, 0x65, 0x63, 0x6b, 0x20, 0x47, 0x72, 0x00F6, 0x00DF, 0x65, 0x20, 0x4c, 0x00FC, 0x62, 0x63, 0x6b, 0};
 140     const UnicodeString test3(chars3);
 141     RuleBasedCollator *c = (RuleBasedCollator *) en_us->clone();
 142
 143     // NOTE: The Java code uses en_us to create the CollationElementIterators
 144     // but I'm pretty sure that's wrong, so I've changed this to use c.
 145     UErrorCode status = U_ZERO_ERROR;
 146     c->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
 147     CollationElementIterator *i1 = c->createCollationElementIterator(test3);
 148     delete i1;
 149     delete c;
 150 }
 151
 152 // @bug 4054734
 153 //
 154 // Collator::IDENTICAL documented but not implemented
 155 //
 156 void CollationRegressionTest::Test4054734(/* char* par */)
 157 {
 158     /*
 159         Here's the original Java:
 160
 161         String[] decomp = {
 162             "\u0001",   "<",    "\u0002",
 163             "\u0001",   "=",    "\u0001",
 164             "A\u0001",  ">",    "~\u0002",      // Ensure A and ~ are not compared bitwise
 165             "\u00C0",   "=",    "A\u0300"       // Decomp should make these equal
 166         };
 167
 168         String[] nodecomp = {
 169             "\u00C0",   ">",    "A\u0300"       // A-grave vs. A combining-grave
 170         };
 171     */
 172
 173     static const UChar decomp[][CollationRegressionTest::MAX_TOKEN_LEN] =
 174     {
 175         {0x0001, 0},      {0x3c, 0}, {0x0002, 0},
 176         {0x0001, 0},      {0x3d, 0}, {0x0001, 0},
 177         {0x41, 0x0001, 0}, {0x3e, 0}, {0x7e, 0x0002, 0},
 178         {0x00c0, 0},      {0x3d, 0}, {0x41, 0x0300, 0}
 179     };
 180
 181
 182     UErrorCode status = U_ZERO_ERROR;
 183     RuleBasedCollator *c = (RuleBasedCollator *) en_us->clone();
 184
 185     c->setStrength(Collator::IDENTICAL);
 186
 187     c->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
 188     compareArray(*c, decomp, ARRAY_LENGTH(decomp));
 189
 190     delete c;
 191 }
 192
 193 // @bug 4054736
 194 //
 195 // Full Decomposition mode not implemented
 196 //
 197 void CollationRegressionTest::Test4054736(/* char* par */)
 198 {
 199     UErrorCode status = U_ZERO_ERROR;
 200     RuleBasedCollator *c = (RuleBasedCollator *) en_us->clone();
 201
 202     c->setStrength(Collator::SECONDARY);
 203     c->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
 204
 205     static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] =
 206     {
 207         {0xFB4F, 0}, {0x3d, 0}, {0x05D0, 0x05DC}  // Alef-Lamed vs. Alef, Lamed
 208     };
 209
 210     compareArray(*c, tests, ARRAY_LENGTH(tests));
 211
 212     delete c;
 213 }
 214
 215 // @bug 4058613
 216 //
 217 // Collator::createInstance() causes an ArrayIndexOutofBoundsException for Korean
 218 //
 219 void CollationRegressionTest::Test4058613(/* char* par */)
 220 {
 221     // Creating a default collator doesn't work when Korean is the default
 222     // locale
 223
 224     Locale oldDefault = Locale::getDefault();
 225     UErrorCode status = U_ZERO_ERROR;
 226
 227     Locale::setDefault(Locale::getKorean(), status);
 228
 229     if (U_FAILURE(status))
 230     {
 231         errln("Could not set default locale to Locale::KOREAN");
 232         return;
 233     }
 234
 235     Collator *c = NULL;
 236
 237     c = Collator::createInstance("en_US", status);
 238
 239     if (c == NULL || U_FAILURE(status))
 240     {
 241         errln("Could not create a Korean collator");
 242         Locale::setDefault(oldDefault, status);
 243         delete c;
 244         return;
 245     }
 246
 247     // Since the fix to this bug was to turn off decomposition for Korean collators,
 248     // ensure that's what we got
 249     if (c->getAttribute(UCOL_NORMALIZATION_MODE, status) != UCOL_OFF)
 250     {
 251       errln("Decomposition is not set to NO_DECOMPOSITION for Korean collator");
 252     }
 253
 254     delete c;
 255
 256     Locale::setDefault(oldDefault, status);
 257 }
 258
 259 // @bug 4059820
 260 //
 261 // RuleBasedCollator.getRules does not return the exact pattern as input
 262 // for expanding character sequences
 263 //
 264 void CollationRegressionTest::Test4059820(/* char* par */)
 265 {
 266     UErrorCode status = U_ZERO_ERROR;
 267
 268     RuleBasedCollator *c = NULL;
 269     UnicodeString rules = "&9 < a < b , c/a < d < z";
 270
 271     c = new RuleBasedCollator(rules, status);
 272
 273     if (c == NULL || U_FAILURE(status))
 274     {
 275         errln("Failure building a collator.");
 276         delete c;
 277         return;
 278     }
 279
 280     if ( c->getRules().indexOf("c/a") == -1)
 281     {
 282         errln("returned rules do not contain 'c/a'");
 283     }
 284
 285     delete c;
 286 }
 287
 288 // @bug 4060154
 289 //
 290 // MergeCollation::fixEntry broken for "& H < \u0131, \u0130, i, I"
 291 //
 292 void CollationRegressionTest::Test4060154(/* char* par */)
 293 {
 294     UErrorCode status = U_ZERO_ERROR;
 295     UnicodeString rules;
 296
 297     rules += "&f < g, G < h, H < i, I < j, J";
 298     rules +=  " & H < ";
 299     rules += (UChar)0x0131;
 300     rules += ", ";
 301     rules += (UChar)0x0130;
 302     rules += ", i, I";
 303
 304     RuleBasedCollator *c = NULL;
 305
 306     c = new RuleBasedCollator(rules, status);
 307
 308     if (c == NULL || U_FAILURE(status))
 309     {
 310         errln("failure building collator.");
 311         delete c;
 312         return;
 313     }
 314
 315     c->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
 316
 317  /*
 318     String[] tertiary = {
 319         "A",        "<",    "B",
 320         "H",        "<",    "\u0131",
 321         "H",        "<",    "I",
 322         "\u0131",   "<",    "\u0130",
 323         "\u0130",   "<",    "i",
 324         "\u0130",   ">",    "H",
 325     };
 326 */
 327
 328     static const UChar tertiary[][CollationRegressionTest::MAX_TOKEN_LEN] =
 329     {
 330         {0x41, 0},    {0x3c, 0}, {0x42, 0},
 331         {0x48, 0},    {0x3c, 0}, {0x0131, 0},
 332         {0x48, 0},    {0x3c, 0}, {0x49, 0},
 333         {0x0131, 0}, {0x3c, 0}, {0x0130, 0},
 334         {0x0130, 0}, {0x3c, 0}, {0x69, 0},
 335         {0x0130, 0}, {0x3e, 0}, {0x48, 0}
 336     };
 337
 338     c->setStrength(Collator::TERTIARY);
 339     compareArray(*c, tertiary, ARRAY_LENGTH(tertiary));
 340
 341     /*
 342     String[] secondary = {
 343         "H",        "<",    "I",
 344         "\u0131",   "=",    "\u0130",
 345     };
 346 */
 347     static const UChar secondary[][CollationRegressionTest::MAX_TOKEN_LEN] =
 348     {
 349         {0x48, 0},    {0x3c, 0}, {0x49, 0},
 350         {0x0131, 0}, {0x3d, 0}, {0x0130, 0}
 351     };
 352
 353     c->setStrength(Collator::PRIMARY);
 354     compareArray(*c, secondary, ARRAY_LENGTH(secondary));
 355
 356     delete c;
 357 }
 358
 359 // @bug 4062418
 360 //
 361 // Secondary/Tertiary comparison incorrect in French Secondary
 362 //
 363 void CollationRegressionTest::Test4062418(/* char* par */)
 364 {
 365     UErrorCode status = U_ZERO_ERROR;
 366
 367     RuleBasedCollator *c = NULL;
 368
 369     c = (RuleBasedCollator *) Collator::createInstance(Locale::getCanadaFrench(), status);
 370
 371     if (c == NULL || U_FAILURE(status))
 372     {
 373         errln("Failed to create collator for Locale::getCanadaFrench()");
 374         delete c;
 375         return;
 376     }
 377
 378     c->setStrength(Collator::SECONDARY);
 379
 380 /*
 381     String[] tests = {
 382             "p\u00eache",    "<",    "p\u00e9ch\u00e9",    // Comparing accents from end, p\u00e9ch\u00e9 is greater
 383     };
 384 */
 385     static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] =
 386     {
 387         {0x70, 0x00EA, 0x63, 0x68, 0x65, 0}, {0x3c, 0}, {0x70, 0x00E9, 0x63, 0x68, 0x00E9, 0}
 388     };
 389
 390     compareArray(*c, tests, ARRAY_LENGTH(tests));
 391
 392     delete c;
 393 }
 394
 395 // @bug 4065540
 396 //
 397 // Collator::compare() method broken if either string contains spaces
 398 //
 399 void CollationRegressionTest::Test4065540(/* char* par */)
 400 {
 401     if (en_us->compare("abcd e", "abcd f") == 0)
 402     {
 403         errln("'abcd e' == 'abcd f'");
 404     }
 405 }
 406
 407 // @bug 4066189
 408 //
 409 // Unicode characters need to be recursively decomposed to get the
 410 // correct result. For example,
 411 // u1EB1 -> \u0103 + \u0300 -> a + \u0306 + \u0300.
 412 //
 413 void CollationRegressionTest::Test4066189(/* char* par */)
 414 {
 415     static const UChar chars1[] = {0x1EB1, 0};
 416     static const UChar chars2[] = {0x61, 0x0306, 0x0300, 0};
 417     const UnicodeString test1(chars1);
 418     const UnicodeString test2(chars2);
 419     UErrorCode status = U_ZERO_ERROR;
 420
 421     // NOTE: The java code used en_us to create the
 422     // CollationElementIterator's. I'm pretty sure that
 423     // was wrong, so I've change the code to use c1 and c2
 424     RuleBasedCollator *c1 = (RuleBasedCollator *) en_us->clone();
 425     c1->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
 426     CollationElementIterator *i1 = c1->createCollationElementIterator(test1);
 427
 428     RuleBasedCollator *c2 = (RuleBasedCollator *) en_us->clone();
 429     c2->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_OFF, status);
 430     CollationElementIterator *i2 = c2->createCollationElementIterator(test2);
 431
 432     assertEqual(*i1, *i2);
 433
 434     delete i2;
 435     delete c2;
 436     delete i1;
 437     delete c1;
 438 }
 439
 440 // @bug 4066696
 441 //
 442 // French secondary collation checking at the end of compare iteration fails
 443 //
 444 void CollationRegressionTest::Test4066696(/* char* par */)
 445 {
 446     UErrorCode status = U_ZERO_ERROR;
 447     RuleBasedCollator *c = NULL;
 448
 449     c = (RuleBasedCollator *)Collator::createInstance(Locale::getCanadaFrench(), status);
 450
 451     if (c == NULL || U_FAILURE(status))
 452     {
 453         errln("Failure creating collator for Locale::getCanadaFrench()");
 454         delete c;
 455         return;
 456     }
 457
 458     c->setStrength(Collator::SECONDARY);
 459
 460 /*
 461     String[] tests = {
 462         "\u00e0",   "<",     "\u01fa",       // a-grave <  A-ring-acute
 463     };
 464
 465   should be:
 466
 467     String[] tests = {
 468         "\u00e0",   ">",     "\u01fa",       // a-grave <  A-ring-acute
 469     };
 470
 471 */
 472
 473     static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] =
 474     {
 475         {0x00E0, 0}, {0x3e, 0}, {0x01FA, 0}
 476     };
 477
 478     compareArray(*c, tests, ARRAY_LENGTH(tests));
 479
 480     delete c;
 481 }
 482
 483 // @bug 4076676
 484 //
 485 // Bad canonicalization of same-class combining characters
 486 //
 487 void CollationRegressionTest::Test4076676(/* char* par */)
 488 {
 489     // These combining characters are all in the same class, so they should not
 490     // be reordered, and they should compare as unequal.
 491     static const UChar s1[] = {0x41, 0x0301, 0x0302, 0x0300, 0};
 492     static const UChar s2[] = {0x41, 0x0302, 0x0300, 0x0301, 0};
 493
 494     RuleBasedCollator *c = (RuleBasedCollator *) en_us->clone();
 495     c->setStrength(Collator::TERTIARY);
 496
 497     if (c->compare(s1,s2) == 0)
 498     {
 499         errln("Same-class combining chars were reordered");
 500     }
 501
 502     delete c;
 503 }
 504
 505 // @bug 4079231
 506 //
 507 // RuleBasedCollator::operator==(NULL) throws NullPointerException
 508 //
 509 void CollationRegressionTest::Test4079231(/* char* par */)
 510 {
 511     // I don't think there's any way to write this test
 512     // in C++. The following is equivalent to the Java,
 513     // but doesn't compile 'cause NULL can't be converted
 514     // to Collator&
 515     //
 516     // if (en_us->operator==(NULL))
 517     // {
 518     //     errln("en_us->operator==(NULL) returned TRUE");
 519     // }
 520
 521  /*
 522    try {
 523         if (en_us->equals(null)) {
 524             errln("en_us->equals(null) returned true");
 525         }
 526     }
 527     catch (Exception e) {
 528         errln("en_us->equals(null) threw " + e.toString());
 529     }
 530 */
 531 }
 532
 533 // @bug 4078588
 534 //
 535 // RuleBasedCollator breaks on "< a < bb" rule
 536 //
 537 void CollationRegressionTest::Test4078588(/* char *par */)
 538 {
 539     UErrorCode status = U_ZERO_ERROR;
 540     RuleBasedCollator *rbc = new RuleBasedCollator("&9 < a < bb", status);
 541
 542     if (rbc == NULL || U_FAILURE(status))
 543     {
 544         errln("Failed to create RuleBasedCollator.");
 545         delete rbc;
 546         return;
 547     }
 548
 549     Collator::EComparisonResult result = rbc->compare("a","bb");
 550
 551     if (result != Collator::LESS)
 552     {
 553         errln((UnicodeString)"Compare(a,bb) returned " + (int)result
 554             + (UnicodeString)"; expected -1");
 555     }
 556
 557     delete rbc;
 558 }
 559
 560 // @bug 4081866
 561 //
 562 // Combining characters in different classes not reordered properly.
 563 //
 564 void CollationRegressionTest::Test4081866(/* char* par */)
 565 {
 566     // These combining characters are all in different classes,
 567     // so they should be reordered and the strings should compare as equal.
 568     static const UChar s1[] = {0x41, 0x0300, 0x0316, 0x0327, 0x0315, 0};
 569     static const UChar s2[] = {0x41, 0x0327, 0x0316, 0x0315, 0x0300, 0};
 570
 571     UErrorCode status = U_ZERO_ERROR;
 572     RuleBasedCollator *c = (RuleBasedCollator *) en_us->clone();
 573     c->setStrength(Collator::TERTIARY);
 574
 575     // Now that the default collators are set to NO_DECOMPOSITION
 576     // (as a result of fixing bug 4114077), we must set it explicitly
 577     // when we're testing reordering behavior.  -- lwerner, 5/5/98
 578     c->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
 579
 580     if (c->compare(s1,s2) != 0)
 581     {
 582         errln("Combining chars were not reordered");
 583     }
 584
 585     delete c;
 586 }
 587
 588 // @bug 4087241
 589 //
 590 // string comparison errors in Scandinavian collators
 591 //
 592 void CollationRegressionTest::Test4087241(/* char* par */)
 593 {
 594     UErrorCode status = U_ZERO_ERROR;
 595     Locale da_DK("da", "DK");
 596     RuleBasedCollator *c = NULL;
 597
 598     c = (RuleBasedCollator *) Collator::createInstance(da_DK, status);
 599
 600     if (c == NULL || U_FAILURE(status))
 601     {
 602         errln("Failed to create collator for da_DK locale");
 603         delete c;
 604         return;
 605     }
 606
 607     c->setStrength(Collator::SECONDARY);
 608
 609     static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] =
 610     {
 611         {0x7a, 0},          {0x3c, 0}, {0x00E6, 0},            // z        < ae
 612         {0x61, 0x0308, 0},  {0x3c, 0}, {0x61, 0x030A, 0},      // a-umlaut < a-ring
 613         {0x59, 0},          {0x3c, 0}, {0x75, 0x0308, 0},      // Y        < u-umlaut
 614     };
 615
 616     compareArray(*c, tests, ARRAY_LENGTH(tests));
 617
 618     delete c;
 619 }
 620
 621 // @bug 4087243
 622 //
 623 // CollationKey takes ignorable strings into account when it shouldn't
 624 //
 625 void CollationRegressionTest::Test4087243(/* char* par */)
 626 {
 627     RuleBasedCollator *c = (RuleBasedCollator *) en_us->clone();
 628     c->setStrength(Collator::TERTIARY);
 629
 630     static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] =
 631     {
 632         {0x31, 0x32, 0x33, 0}, {0x3d, 0}, {0x31, 0x32, 0x33, 0x0001, 0}    // 1 2 3  =  1 2 3 ctrl-A
 633     };
 634
 635     compareArray(*c, tests, ARRAY_LENGTH(tests));
 636
 637     delete c;
 638 }
 639
 640 // @bug 4092260
 641 //
 642 // Mu/micro conflict
 643 // Micro symbol and greek lowercase letter Mu should sort identically
 644 //
 645 void CollationRegressionTest::Test4092260(/* char* par */)
 646 {
 647     UErrorCode status = U_ZERO_ERROR;
 648     Locale el("el", "");
 649     Collator *c = NULL;
 650
 651     c = Collator::createInstance(el, status);
 652
 653     if (c == NULL || U_FAILURE(status))
 654     {
 655         errln("Failed to create collator for el locale.");
 656         delete c;
 657         return;
 658     }
 659
 660     // These now have tertiary differences in UCA
 661     c->setAttribute(UCOL_STRENGTH, UCOL_SECONDARY, status);
 662
 663     static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] =
 664     {
 665         {0x00B5, 0}, {0x3d, 0}, {0x03BC, 0}
 666     };
 667
 668     compareArray(*c, tests, ARRAY_LENGTH(tests));
 669
 670     delete c;
 671 }
 672
 673 // @bug 4095316
 674 //
 675 void CollationRegressionTest::Test4095316(/* char* par */)
 676 {
 677     UErrorCode status = U_ZERO_ERROR;
 678     Locale el_GR("el", "GR");
 679     Collator *c = Collator::createInstance(el_GR, status);
 680
 681     if (c == NULL || U_FAILURE(status))
 682     {
 683         errln("Failed to create collator for el_GR locale");
 684         delete c;
 685         return;
 686     }
 687     // These now have tertiary differences in UCA
 688     //c->setStrength(Collator::TERTIARY);
 689     c->setAttribute(UCOL_STRENGTH, UCOL_SECONDARY, status);
 690
 691     static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] =
 692     {
 693         {0x03D4, 0}, {0x3d, 0}, {0x03AB, 0}
 694     };
 695
 696     compareArray(*c, tests, ARRAY_LENGTH(tests));
 697
 698     delete c;
 699 }
 700
 701 // @bug 4101940
 702 //
 703 void CollationRegressionTest::Test4101940(/* char* par */)
 704 {
 705     UErrorCode status = U_ZERO_ERROR;
 706     RuleBasedCollator *c = NULL;
 707     UnicodeString rules = "&9 < a < b";
 708     UnicodeString nothing = "";
 709
 710     c = new RuleBasedCollator(rules, status);
 711
 712     if (c == NULL || U_FAILURE(status))
 713     {
 714         errln("Failed to create RuleBasedCollator");
 715         delete c;
 716         return;
 717     }
 718
 719     CollationElementIterator *i = c->createCollationElementIterator(nothing);
 720     i->reset();
 721
 722     if (i->next(status) != CollationElementIterator::NULLORDER)
 723     {
 724         errln("next did not return NULLORDER");
 725     }
 726
 727     delete i;
 728     delete c;
 729 }
 730
 731 // @bug 4103436
 732 //
 733 // Collator::compare not handling spaces properly
 734 //
 735 void CollationRegressionTest::Test4103436(/* char* par */)
 736 {
 737     RuleBasedCollator *c = (RuleBasedCollator *) en_us->clone();
 738     c->setStrength(Collator::TERTIARY);
 739
 740     static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] =
 741     {
 742         {0x66, 0x69, 0x6c, 0x65, 0}, {0x3c, 0}, {0x66, 0x69, 0x6c, 0x65, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0},
 743         {0x66, 0x69, 0x6c, 0x65, 0}, {0x3c, 0}, {0x66, 0x69, 0x6c, 0x65, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0}
 744     };
 745
 746     compareArray(*c, tests, ARRAY_LENGTH(tests));
 747
 748     delete c;
 749 }
 750
 751 // @bug 4114076
 752 //
 753 // Collation not Unicode conformant with Hangul syllables
 754 //
 755 void CollationRegressionTest::Test4114076(/* char* par */)
 756 {
 757     UErrorCode status = U_ZERO_ERROR;
 758     RuleBasedCollator *c = (RuleBasedCollator *) en_us->clone();
 759     c->setStrength(Collator::TERTIARY);
 760
 761     //
 762     // With Canonical decomposition, Hangul syllables should get decomposed
 763     // into Jamo, but Jamo characters should not be decomposed into
 764     // conjoining Jamo
 765     //
 766     static const UChar test1[][CollationRegressionTest::MAX_TOKEN_LEN] =
 767     {
 768         {0xd4db, 0}, {0x3d, 0}, {0x1111, 0x1171, 0x11b6, 0}
 769     };
 770
 771     c->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
 772     compareArray(*c, test1, ARRAY_LENGTH(test1));
 773
 774     // From UTR #15:
 775     // *In earlier versions of Unicode, jamo characters like ksf
 776     //  had compatibility mappings to kf + sf. These mappings were
 777     //  removed in Unicode 2.1.9 to ensure that Hangul syllables are maintained.)
 778     // That is, the following test is obsolete as of 2.1.9
 779
 780 //obsolete-    // With Full decomposition, it should go all the way down to
 781 //obsolete-    // conjoining Jamo characters.
 782 //obsolete-    //
 783 //obsolete-    static const UChar test2[][CollationRegressionTest::MAX_TOKEN_LEN] =
 784 //obsolete-    {
 785 //obsolete-        {0xd4db, 0}, {0x3d, 0}, {0x1111, 0x116e, 0x1175, 0x11af, 0x11c2, 0}
 786 //obsolete-    };
 787 //obsolete-
 788 //obsolete-    c->setDecomposition(Normalizer::DECOMP_COMPAT);
 789 //obsolete-    compareArray(*c, test2, ARRAY_LENGTH(test2));
 790
 791     delete c;
 792 }
 793
 794
 795 // @bug 4124632
 796 //
 797 // Collator::getCollationKey was hanging on certain character sequences
 798 //
 799 void CollationRegressionTest::Test4124632(/* char* par */)
 800 {
 801     UErrorCode status = U_ZERO_ERROR;
 802     Collator *coll = NULL;
 803
 804     coll = Collator::createInstance(Locale::getJapan(), status);
 805
 806     if (coll == NULL || U_FAILURE(status))
 807     {
 808         errln("Failed to create collator for Locale::JAPAN");
 809         delete coll;
 810         return;
 811     }
 812
 813     static const UChar test[] = {0x41, 0x0308, 0x62, 0x63, 0};
 814     CollationKey key;
 815
 816     coll->getCollationKey(test, key, status);
 817
 818     if (key.isBogus() || U_FAILURE(status))
 819     {
 820         errln("CollationKey creation failed.");
 821     }
 822
 823     delete coll;
 824 }
 825
 826 // @bug 4132736
 827 //
 828 // sort order of french words with multiple accents has errors
 829 //
 830 void CollationRegressionTest::Test4132736(/* char* par */)
 831 {
 832     UErrorCode status = U_ZERO_ERROR;
 833
 834     Collator *c = NULL;
 835
 836     c = Collator::createInstance(Locale::getCanadaFrench(), status);
 837     c->setStrength(Collator::TERTIARY);
 838
 839     if (c == NULL || U_FAILURE(status))
 840     {
 841         errln("Failed to create a collator for Locale::getCanadaFrench()");
 842         delete c;
 843         return;
 844     }
 845
 846     static const UChar test1[][CollationRegressionTest::MAX_TOKEN_LEN] =
 847     {
 848         {0x65, 0x0300, 0x65, 0x0301, 0}, {0x3c, 0}, {0x65, 0x0301, 0x65, 0x0300, 0},
 849         {0x65, 0x0300, 0x0301, 0},       {0x3c, 0}, {0x65, 0x0301, 0x0300, 0}
 850     };
 851
 852     compareArray(*c, test1, ARRAY_LENGTH(test1));
 853
 854     delete c;
 855 }
 856
 857 // @bug 4133509
 858 //
 859 // The sorting using java.text.CollationKey is not in the exact order
 860 //
 861 void CollationRegressionTest::Test4133509(/* char* par */)
 862 {
 863     static const UChar test1[][CollationRegressionTest::MAX_TOKEN_LEN] =
 864     {
 865         {0x45, 0x78, 0x63, 0x65, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0}, {0x3c, 0}, {0x45, 0x78, 0x63, 0x65, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x72, 0x45, 0x72, 0x72, 0x6f, 0x72, 0},
 866         {0x47, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x73, 0},      {0x3c, 0}, {0x47, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x73, 0x45, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0},
 867         {0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0},                  {0x3c, 0}, {0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x75, 0x66, 0x66, 0x65, 0x72, 0}
 868     };
 869
 870     compareArray(*en_us, test1, ARRAY_LENGTH(test1));
 871 }
 872
 873 // @bug 4114077
 874 //
 875 // Collation with decomposition off doesn't work for Europe
 876 //
 877 void CollationRegressionTest::Test4114077(/* char* par */)
 878 {
 879     // Ensure that we get the same results with decomposition off
 880     // as we do with it on....
 881
 882     UErrorCode status = U_ZERO_ERROR;
 883     RuleBasedCollator *c = (RuleBasedCollator *) en_us->clone();
 884     c->setStrength(Collator::TERTIARY);
 885
 886     static const UChar test1[][CollationRegressionTest::MAX_TOKEN_LEN] =
 887     {
 888         {0x00C0, 0},                     {0x3d, 0}, {0x41, 0x0300, 0},            // Should be equivalent
 889         {0x70, 0x00ea, 0x63, 0x68, 0x65, 0}, {0x3e, 0}, {0x70, 0x00e9, 0x63, 0x68, 0x00e9, 0},
 890         {0x0204, 0},                     {0x3d, 0}, {0x45, 0x030F, 0},
 891         {0x01fa, 0},                     {0x3d, 0}, {0x41, 0x030a, 0x0301, 0},    // a-ring-acute -> a-ring, acute
 892                                                 //   -> a, ring, acute
 893         {0x41, 0x0300, 0x0316, 0},         {0x3c, 0}, {0x41, 0x0316, 0x0300, 0}        // No reordering --> unequal
 894     };
 895
 896     c->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_OFF, status);
 897     compareArray(*c, test1, ARRAY_LENGTH(test1));
 898
 899     static const UChar test2[][CollationRegressionTest::MAX_TOKEN_LEN] =
 900     {
 901         {0x41, 0x0300, 0x0316, 0}, {0x3d, 0}, {0x41, 0x0316, 0x0300, 0}      // Reordering --> equal
 902     };
 903
 904     c->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
 905     compareArray(*c, test2, ARRAY_LENGTH(test2));
 906
 907     delete c;
 908 }
 909
 910 // @bug 4141640
 911 //
 912 // Support for Swedish gone in 1.1.6 (Can't create Swedish collator)
 913 //
 914 void CollationRegressionTest::Test4141640(/* char* par */)
 915 {
 916     //
 917     // Rather than just creating a Swedish collator, we might as well
 918     // try to instantiate one for every locale available on the system
 919     // in order to prevent this sort of bug from cropping up in the future
 920     //
 921     UErrorCode status = U_ZERO_ERROR;
 922     int32_t i, localeCount;
 923     const Locale *locales = Locale::getAvailableLocales(localeCount);
 924
 925     for (i = 0; i < localeCount; i += 1)
 926     {
 927         Collator *c = NULL;
 928
 929         status = U_ZERO_ERROR;
 930         c = Collator::createInstance(locales[i], status);
 931
 932         if (c == NULL || U_FAILURE(status))
 933         {
 934             UnicodeString msg, localeName;
 935
 936             msg += "Could not create collator for locale ";
 937             msg += locales[i].getName();
 938
 939             errln(msg);
 940         }
 941
 942         delete c;
 943     }
 944 }
 945
 946 // @bug 4139572
 947 //
 948 // getCollationKey throws exception for spanish text
 949 // Cannot reproduce this bug on 1.2, however it DOES fail on 1.1.6
 950 //
 951 void CollationRegressionTest::Test4139572(/* char* par */)
 952 {
 953     //
 954     // Code pasted straight from the bug report
 955     // (and then translated to C++ ;-)
 956     //
 957     // create spanish locale and collator
 958     UErrorCode status = U_ZERO_ERROR;
 959     Locale l("es", "es");
 960     Collator *col = NULL;
 961
 962     col = Collator::createInstance(l, status);
 963
 964     if (col == NULL || U_FAILURE(status))
 965     {
 966         errln("Failed to create a collator for es_es locale.");
 967         delete col;
 968         return;
 969     }
 970
 971     CollationKey key;
 972
 973     // this spanish phrase kills it!
 974     col->getCollationKey("Nombre De Objeto", key, status);
 975
 976     if (key.isBogus() || U_FAILURE(status))
 977     {
 978         errln("Error creating CollationKey for \"Nombre De Ojbeto\"");
 979     }
 980
 981     delete col;
 982 }
 983 /* HSYS : RuleBasedCollator::compare() performance enhancements
 984           compare() does not create CollationElementIterator() anymore.*/
 985
 986 class My4146160Collator : public RuleBasedCollator
 987 {
 988 public:
 989     My4146160Collator(RuleBasedCollator &rbc, UErrorCode &status);
 990     ~My4146160Collator();
 991
 992     CollationElementIterator *createCollationElementIterator(const UnicodeString &text) const;
 993
 994     CollationElementIterator *createCollationElementIterator(const CharacterIterator &text) const;
 995
 996     static int32_t count;
 997 };
 998
 999 int32_t My4146160Collator::count = 0;
1000
1001 My4146160Collator::My4146160Collator(RuleBasedCollator &rbc, UErrorCode &status)
1002   : RuleBasedCollator(rbc.getRules(), status)
1003 {
1004 }
1005
1006 My4146160Collator::~My4146160Collator()
1007 {
1008 }
1009
1010 CollationElementIterator *My4146160Collator::createCollationElementIterator(const UnicodeString &text) const
1011 {
1012     count += 1;
1013     return RuleBasedCollator::createCollationElementIterator(text);
1014 }
1015
1016 CollationElementIterator *My4146160Collator::createCollationElementIterator(const CharacterIterator &text) const
1017 {
1018     count += 1;
1019     return RuleBasedCollator::createCollationElementIterator(text);
1020 }
1021
1022 // @bug 4146160
1023 //
1024 // RuleBasedCollator doesn't use createCollationElementIterator internally
1025 //
1026 void CollationRegressionTest::Test4146160(/* char* par */)
1027 {
1028 #if 0
1029     //
1030     // Use a custom collator class whose createCollationElementIterator
1031     // methods increment a count....
1032     //
1033     UErrorCode status = U_ZERO_ERROR;
1034     CollationKey key;
1035
1036     My4146160Collator::count = 0;
1037     My4146160Collator *mc = NULL;
1038
1039     mc = new My4146160Collator(*en_us, status);
1040
1041     if (mc == NULL || U_FAILURE(status))
1042     {
1043         errln("Failed to create a My4146160Collator.");
1044         delete mc;
1045         return;
1046     }
1047
1048     mc->getCollationKey("1", key, status);
1049
1050     if (key.isBogus() || U_FAILURE(status))
1051     {
1052         errln("Failure to get a CollationKey from a My4146160Collator.");
1053         delete mc;
1054         return;
1055     }
1056
1057     if (My4146160Collator::count < 1)
1058     {
1059         errln("My4146160Collator::createCollationElementIterator not called for getCollationKey");
1060     }
1061
1062     My4146160Collator::count = 0;
1063     mc->compare("1", "2");
1064
1065     if (My4146160Collator::count < 1)
1066     {
1067         errln("My4146160Collator::createtCollationElementIterator not called for compare");
1068     }
1069
1070     delete mc;
1071 #endif
1072 }
1073
1074 void CollationRegressionTest::Test4179216() {
1075     // you can position a CollationElementIterator in the middle of
1076     // a contracting character sequence, yielding a bogus collation
1077     // element
1078     IcuTestErrorCode errorCode(*this, "Test4179216");
1079     RuleBasedCollator coll(en_us->getRules() + " & C < ch , cH , Ch , CH < cat < crunchy", errorCode);
1080     UnicodeString testText = "church church catcatcher runcrunchynchy";
1081     CollationElementIterator *iter = coll.createCollationElementIterator(testText);
1082
1083     // test that the "ch" combination works properly
1084     iter->setOffset(4, errorCode);
1085     int32_t elt4 = CollationElementIterator::primaryOrder(iter->next(errorCode));
1086
1087     iter->reset();
1088     int32_t elt0 = CollationElementIterator::primaryOrder(iter->next(errorCode));
1089
1090     iter->setOffset(5, errorCode);
1091     int32_t elt5 = CollationElementIterator::primaryOrder(iter->next(errorCode));
1092
1093     // Compares and prints only 16-bit primary weights.
1094     if (elt4 != elt0 || elt5 != elt0) {
1095         errln("The collation elements at positions 0 (0x%04x), "
1096                 "4 (0x%04x), and 5 (0x%04x) don't match.",
1097                 elt0, elt4, elt5);
1098     }
1099
1100     // test that the "cat" combination works properly
1101     iter->setOffset(14, errorCode);
1102     int32_t elt14 = CollationElementIterator::primaryOrder(iter->next(errorCode));
1103
1104     iter->setOffset(15, errorCode);
1105     int32_t elt15 = CollationElementIterator::primaryOrder(iter->next(errorCode));
1106
1107     iter->setOffset(16, errorCode);
1108     int32_t elt16 = CollationElementIterator::primaryOrder(iter->next(errorCode));
1109
1110     iter->setOffset(17, errorCode);
1111     int32_t elt17 = CollationElementIterator::primaryOrder(iter->next(errorCode));
1112
1113     iter->setOffset(18, errorCode);
1114     int32_t elt18 = CollationElementIterator::primaryOrder(iter->next(errorCode));
1115
1116     iter->setOffset(19, errorCode);
1117     int32_t elt19 = CollationElementIterator::primaryOrder(iter->next(errorCode));
1118
1119     // Compares and prints only 16-bit primary weights.
1120     if (elt14 != elt15 || elt14 != elt16 || elt14 != elt17
1121             || elt14 != elt18 || elt14 != elt19) {
1122         errln("\"cat\" elements don't match: elt14 = 0x%04x, "
1123                 "elt15 = 0x%04x, elt16 = 0x%04x, elt17 = 0x%04x, "
1124                 "elt18 = 0x%04x, elt19 = 0x%04x",
1125                 elt14, elt15, elt16, elt17, elt18, elt19);
1126     }
1127
1128     // now generate a complete list of the collation elements,
1129     // first using next() and then using setOffset(), and
1130     // make sure both interfaces return the same set of elements
1131     iter->reset();
1132
1133     int32_t elt = iter->next(errorCode);
1134     int32_t count = 0;
1135     while (elt != CollationElementIterator::NULLORDER) {
1136         ++count;
1137         elt = iter->next(errorCode);
1138     }
1139
1140     LocalArray<UnicodeString> nextElements(new UnicodeString[count]);
1141     LocalArray<UnicodeString> setOffsetElements(new UnicodeString[count]);
1142     int32_t lastPos = 0;
1143
1144     iter->reset();
1145     elt = iter->next(errorCode);
1146     count = 0;
1147     while (elt != CollationElementIterator::NULLORDER) {
1148         nextElements[count++] = testText.tempSubStringBetween(lastPos, iter->getOffset());
1149         lastPos = iter->getOffset();
1150         elt = iter->next(errorCode);
1151     }
1152     int32_t nextElementsLength = count;
1153     count = 0;
1154     for (int32_t i = 0; i < testText.length(); ) {
1155         iter->setOffset(i, errorCode);
1156         lastPos = iter->getOffset();
1157         elt = iter->next(errorCode);
1158         setOffsetElements[count++] = testText.tempSubStringBetween(lastPos, iter->getOffset());
1159         i = iter->getOffset();
1160     }
1161     for (int32_t i = 0; i < nextElementsLength; i++) {
1162         if (nextElements[i] == setOffsetElements[i]) {
1163             logln(nextElements[i]);
1164         } else {
1165             errln(UnicodeString("Error: next() yielded ") + nextElements[i] +
1166                 ", but setOffset() yielded " + setOffsetElements[i]);
1167         }
1168     }
1169     delete iter;
1170 }
1171
1172 // Ticket 7189
1173 //
1174 // nextSortKeyPart incorrect for EO_S1 collation
1175 static int32_t calcKeyIncremental(UCollator *coll, const UChar* text, int32_t len, uint8_t *keyBuf, int32_t /*keyBufLen*/, UErrorCode& status) {
1176     UCharIterator uiter;
1177     uint32_t state[2] = { 0, 0 };
1178     int32_t keyLen;
1179     int32_t count = 8;
1180
1181     uiter_setString(&uiter, text, len);
1182     keyLen = 0;
1183     while (TRUE) {
1184         int32_t keyPartLen = ucol_nextSortKeyPart(coll, &uiter, state, &keyBuf[keyLen], count, &status);
1185         if (U_FAILURE(status)) {
1186             return -1;
1187         }
1188         if (keyPartLen == 0) {
1189             break;
1190         }
1191         keyLen += keyPartLen;
1192     }
1193     return keyLen;
1194 }
1195
1196 void CollationRegressionTest::TestT7189() {
1197     UErrorCode status = U_ZERO_ERROR;
1198     UCollator *coll;
1199     uint32_t i;
1200
1201     static const UChar text1[][CollationRegressionTest::MAX_TOKEN_LEN] = {
1202     // "Achter De Hoven"
1203         { 0x41, 0x63, 0x68, 0x74, 0x65, 0x72, 0x20, 0x44, 0x65, 0x20, 0x48, 0x6F, 0x76, 0x65, 0x6E, 0x00 },
1204         // "ABC"
1205         { 0x41, 0x42, 0x43, 0x00 },
1206         // "HELLO world!"
1207         { 0x48, 0x45, 0x4C, 0x4C, 0x4F, 0x20, 0x77, 0x6F, 0x72, 0x6C, 0x64, 0x21, 0x00 }
1208     };
1209
1210     static const UChar text2[][CollationRegressionTest::MAX_TOKEN_LEN] = {
1211     // "Achter de Hoven"
1212         { 0x41, 0x63, 0x68, 0x74, 0x65, 0x72, 0x20, 0x64, 0x65, 0x20, 0x48, 0x6F, 0x76, 0x65, 0x6E, 0x00 },
1213         // "abc"
1214         { 0x61, 0x62, 0x63, 0x00 },
1215         // "hello world!"
1216         { 0x68, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x77, 0x6F, 0x72, 0x6C, 0x64, 0x21, 0x00 }
1217     };
1218
1219     // Open the collator
1220     coll = ucol_openFromShortString("EO_S1", FALSE, NULL, &status);
1221     if (U_FAILURE(status)) {
1222         errln("Failed to create a collator for short string EO_S1");
1223         return;
1224     }
1225
1226     for (i = 0; i < sizeof(text1) / (CollationRegressionTest::MAX_TOKEN_LEN * sizeof(UChar)); i++) {
1227         uint8_t key1[100], key2[100];
1228         int32_t len1, len2;
1229
1230         len1 = calcKeyIncremental(coll, text1[i], -1, key1, sizeof(key1), status);
1231         if (U_FAILURE(status)) {
1232             errln(UnicodeString("Failed to get a partial collation key for ") + text1[i]);
1233             break;
1234         }
1235         len2 = calcKeyIncremental(coll, text2[i], -1, key2, sizeof(key2), status);
1236         if (U_FAILURE(status)) {
1237             errln(UnicodeString("Failed to get a partial collation key for ") + text2[i]);
1238             break;
1239         }
1240
1241         if (len1 == len2 && uprv_memcmp(key1, key2, len1) == 0) {
1242             errln(UnicodeString("Failed: Identical key\n") + "    text1: " + text1[i] + "\n" + "    text2: " + text2[i] + "\n" + "    key  : " + TestUtility::hex(key1, len1));
1243         } else {
1244             logln(UnicodeString("Keys produced -\n") + "    text1: " + text1[i] + "\n" + "    key1 : " + TestUtility::hex(key1, len1) + "\n" + "    text2: " + text2[i] + "\n" + "    key2 : "
1245                     + TestUtility::hex(key2, len2));
1246         }
1247     }
1248     ucol_close(coll);
1249 }
1250
1251 void CollationRegressionTest::TestCaseFirstCompression() {
1252     RuleBasedCollator *col = (RuleBasedCollator *) en_us->clone();
1253     UErrorCode status = U_ZERO_ERROR;
1254
1255     // default
1256     caseFirstCompressionSub(col, "default");
1257
1258     // Upper first
1259     col->setAttribute(UCOL_CASE_FIRST, UCOL_UPPER_FIRST, status);
1260     if (U_FAILURE(status)) {
1261         errln("Failed to set UCOL_UPPER_FIRST");
1262         return;
1263     }
1264     caseFirstCompressionSub(col, "upper first");
1265
1266     // Lower first
1267     col->setAttribute(UCOL_CASE_FIRST, UCOL_LOWER_FIRST, status);
1268     if (U_FAILURE(status)) {
1269         errln("Failed to set UCOL_LOWER_FIRST");
1270         return;
1271     }
1272     caseFirstCompressionSub(col, "lower first");
1273
1274     delete col;
1275 }
1276
1277 void CollationRegressionTest::caseFirstCompressionSub(Collator *col, UnicodeString opt) {
1278     const int32_t maxLength = 50;
1279
1280     UChar str1[maxLength];
1281     UChar str2[maxLength];
1282
1283     CollationKey key1, key2;
1284
1285     for (int32_t len = 1; len <= maxLength; len++) {
1286         int32_t i = 0;
1287         for (; i < len - 1; i++) {
1288             str1[i] = str2[i] = (UChar)0x61; // 'a'
1289         }
1290         str1[i] = (UChar)0x41; // 'A'
1291         str2[i] = (UChar)0x61; // 'a'
1292
1293         UErrorCode status = U_ZERO_ERROR;
1294         col->getCollationKey(str1, len, key1, status);
1295         col->getCollationKey(str2, len, key2, status);
1296
1297         UCollationResult cmpKey = key1.compareTo(key2, status);
1298         UCollationResult cmpCol = col->compare(str1, len, str2, len, status);
1299
1300         if (U_FAILURE(status)) {
1301             errln("Error in caseFirstCompressionSub");
1302         } else if (cmpKey != cmpCol) {
1303             errln((UnicodeString)"Inconsistent comparison(" + opt
1304                 + "): str1=" + UnicodeString(str1, len) + ", str2=" + UnicodeString(str2, len)
1305                 + ", cmpKey=" + cmpKey + ", cmpCol=" + cmpCol);
1306         }
1307     }
1308 }
1309
1310 void CollationRegressionTest::TestTrailingComment() {
1311     // ICU ticket #8070:
1312     // Check that the rule parser handles a comment without terminating end-of-line.
1313     IcuTestErrorCode errorCode(*this, "TestTrailingComment");
1314     RuleBasedCollator coll(UNICODE_STRING_SIMPLE("&c<b#comment1\n<a#comment2"), errorCode);
1315     UnicodeString a((UChar)0x61), b((UChar)0x62), c((UChar)0x63);
1316     assertTrue("c<b", coll.compare(c, b) < 0);
1317     assertTrue("b<a", coll.compare(b, a) < 0);
1318 }
1319
1320 void CollationRegressionTest::TestBeforeWithTooStrongAfter() {
1321     // ICU ticket #9959:
1322     // Forbid rules with a before-reset followed by a stronger relation.
1323     IcuTestErrorCode errorCode(*this, "TestBeforeWithTooStrongAfter");
1324     RuleBasedCollator before2(UNICODE_STRING_SIMPLE("&[before 2]x<<q<p"), errorCode);
1325     if(errorCode.isSuccess()) {
1326         errln("should forbid before-2-reset followed by primary relation");
1327     } else {
1328         errorCode.reset();
1329     }
1330     RuleBasedCollator before3(UNICODE_STRING_SIMPLE("&[before 3]x<<<q<<s<p"), errorCode);
1331     if(errorCode.isSuccess()) {
1332         errln("should forbid before-3-reset followed by primary or secondary relation");
1333     } else {
1334         errorCode.reset();
1335     }
1336 }
1337
1338 void CollationRegressionTest::compareArray(Collator &c,
1339                                            const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN],
1340                                            int32_t testCount)
1341 {
1342     int32_t i;
1343     Collator::EComparisonResult expectedResult = Collator::EQUAL;
1344
1345     for (i = 0; i < testCount; i += 3)
1346     {
1347         UnicodeString source(tests[i]);
1348         UnicodeString comparison(tests[i + 1]);
1349         UnicodeString target(tests[i + 2]);
1350
1351         if (comparison == "<")
1352         {
1353             expectedResult = Collator::LESS;
1354         }
1355         else if (comparison == ">")
1356         {
1357             expectedResult = Collator::GREATER;
1358         }
1359         else if (comparison == "=")
1360         {
1361             expectedResult = Collator::EQUAL;
1362         }
1363         else
1364         {
1365             UnicodeString bogus1("Bogus comparison string \"");
1366             UnicodeString bogus2("\"");
1367             errln(bogus1 + comparison + bogus2);
1368         }
1369
1370         Collator::EComparisonResult compareResult = c.compare(source, target);
1371
1372         CollationKey sourceKey, targetKey;
1373         UErrorCode status = U_ZERO_ERROR;
1374
1375         c.getCollationKey(source, sourceKey, status);
1376
1377         if (U_FAILURE(status))
1378         {
1379             errln("Couldn't get collationKey for source");
1380             continue;
1381         }
1382
1383         c.getCollationKey(target, targetKey, status);
1384
1385         if (U_FAILURE(status))
1386         {
1387             errln("Couldn't get collationKey for target");
1388             continue;
1389         }
1390
1391         Collator::EComparisonResult keyResult = sourceKey.compareTo(targetKey);
1392
1393         reportCResult( source, target, sourceKey, targetKey, compareResult, keyResult, compareResult, expectedResult );
1394
1395     }
1396 }
1397
1398 void CollationRegressionTest::assertEqual(CollationElementIterator &i1, CollationElementIterator &i2)
1399 {
1400     int32_t c1, c2, count = 0;
1401     UErrorCode status = U_ZERO_ERROR;
1402
1403     do
1404     {
1405         c1 = i1.next(status);
1406         c2 = i2.next(status);
1407
1408         if (c1 != c2)
1409         {
1410             UnicodeString msg, msg1("    ");
1411
1412             msg += msg1 + count;
1413             msg += ": strength(0x";
1414             appendHex(c1, 8, msg);
1415             msg += ") != strength(0x";
1416             appendHex(c2, 8, msg);
1417             msg += ")";
1418
1419             errln(msg);
1420             break;
1421         }
1422
1423         count += 1;
1424     }
1425     while (c1 != CollationElementIterator::NULLORDER);
1426 }
1427
1428 void CollationRegressionTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /* par */)
1429 {
1430     if (exec)
1431     {
1432         logln("Collation Regression Tests: ");
1433     }
1434
1435     if(en_us == NULL) {
1436         dataerrln("Class collator not instantiated");
1437         name = "";
1438         return;
1439     }
1440     TESTCASE_AUTO_BEGIN;
1441     TESTCASE_AUTO(Test4048446);
1442     TESTCASE_AUTO(Test4051866);
1443     TESTCASE_AUTO(Test4053636);
1444     TESTCASE_AUTO(Test4054238);
1445     TESTCASE_AUTO(Test4054734);
1446     TESTCASE_AUTO(Test4054736);
1447     TESTCASE_AUTO(Test4058613);
1448     TESTCASE_AUTO(Test4059820);
1449     TESTCASE_AUTO(Test4060154);
1450     TESTCASE_AUTO(Test4062418);
1451     TESTCASE_AUTO(Test4065540);
1452     TESTCASE_AUTO(Test4066189);
1453     TESTCASE_AUTO(Test4066696);
1454     TESTCASE_AUTO(Test4076676);
1455     TESTCASE_AUTO(Test4078588);
1456     TESTCASE_AUTO(Test4079231);
1457     TESTCASE_AUTO(Test4081866);
1458     TESTCASE_AUTO(Test4087241);
1459     TESTCASE_AUTO(Test4087243);
1460     TESTCASE_AUTO(Test4092260);
1461     TESTCASE_AUTO(Test4095316);
1462     TESTCASE_AUTO(Test4101940);
1463     TESTCASE_AUTO(Test4103436);
1464     TESTCASE_AUTO(Test4114076);
1465     TESTCASE_AUTO(Test4114077);
1466     TESTCASE_AUTO(Test4124632);
1467     TESTCASE_AUTO(Test4132736);
1468     TESTCASE_AUTO(Test4133509);
1469     TESTCASE_AUTO(Test4139572);
1470     TESTCASE_AUTO(Test4141640);
1471     TESTCASE_AUTO(Test4146160);
1472     TESTCASE_AUTO(Test4179216);
1473     TESTCASE_AUTO(TestT7189);
1474     TESTCASE_AUTO(TestCaseFirstCompression);
1475     TESTCASE_AUTO(TestTrailingComment);
1476     TESTCASE_AUTO(TestBeforeWithTooStrongAfter);
1477     TESTCASE_AUTO_END;
1478 }
1479
1480 #endif /* #if !UCONFIG_NO_COLLATION */