source/test/intltest/apicoll.cpp

   1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /********************************************************************
   4  * COPYRIGHT:
   5  * Copyright (c) 1997-2016, International Business Machines Corporation and
   6  * others. All Rights Reserved.
   7  ********************************************************************/
   8 //===============================================================================
   9 //
  10 // File apicoll.cpp
  11 //
  12 //
  13 //
  14 // Created by: Helena Shih
  15 //
  16 // Modification History:
  17 //
  18 //  Date         Name          Description
  19 //  2/5/97      aliu        Added streamIn and streamOut methods.  Added
  20 //                          constructor which reads RuleBasedCollator object from
  21 //                          a binary file.  Added writeToFile method which streams
  22 //                          RuleBasedCollator out to a binary file.  The streamIn
  23 //                          and streamOut methods use istream and ostream objects
  24 //                          in binary mode.
  25 //  6/30/97     helena      Added tests for CollationElementIterator::setText, getOffset
  26 //                          setOffset and DecompositionIterator::getOffset, setOffset.
  27 //                          DecompositionIterator is made public so add class scope
  28 //                          testing.
  29 //  02/10/98    damiba      Added test for compare(UnicodeString&, UnicodeString&, int32_t)
  30 //===============================================================================
  31
  32 #include "unicode/utypes.h"
  33
  34 #if !UCONFIG_NO_COLLATION
  35
  36 #include "unicode/localpointer.h"
  37 #include "unicode/coll.h"
  38 #include "unicode/tblcoll.h"
  39 #include "unicode/coleitr.h"
  40 #include "unicode/sortkey.h"
  41 #include "apicoll.h"
  42 #include "unicode/chariter.h"
  43 #include "unicode/schriter.h"
  44 #include "unicode/ustring.h"
  45 #include "unicode/ucol.h"
  46
  47 #include "sfwdchit.h"
  48 #include "cmemory.h"
  49 #include <stdlib.h>
  50
  51 void
  52 CollationAPITest::doAssert(UBool condition, const char *message)
  53 {
  54     if (!condition) {
  55         errln(UnicodeString("ERROR : ") + message);
  56     }
  57 }
  58
  59 // Collator Class Properties
  60 // ctor, dtor, createInstance, compare, getStrength/setStrength
  61 // getDecomposition/setDecomposition, getDisplayName
  62 void
  63 CollationAPITest::TestProperty(/* char* par */)
  64 {
  65     UErrorCode success = U_ZERO_ERROR;
  66     Collator *col = 0;
  67     /*
  68      * Expected version of the English collator.
  69      * Currently, the major/minor version numbers change when the builder code
  70      * changes,
  71      * number 2 is from the tailoring data version and
  72      * number 3 is the UCA version.
  73      * This changes with every UCA version change, and the expected value
  74      * needs to be adjusted.
  75      * Same in cintltst/capitst.c.
  76      */
  77     UVersionInfo currVersionArray = {0x31, 0xC0, 0x05, 0x2A};  // from ICU 4.4/UCA 5.2
  78     UVersionInfo versionArray;
  79
  80     logln("The property tests begin : ");
  81     logln("Test ctors : ");
  82     col = Collator::createInstance(Locale::getEnglish(), success);
  83     if (U_FAILURE(success)){
  84         errcheckln(success, "Default Collator creation failed. - %s", u_errorName(success));
  85         return;
  86     }
  87
  88     StringEnumeration* kwEnum = col->getKeywordValuesForLocale("", Locale::getEnglish(),true,success);
  89     if (U_FAILURE(success)){
  90         errcheckln(success, "Get Keyword Values for Locale failed. - %s", u_errorName(success));
  91         return;
  92     }
  93     delete kwEnum;
  94
  95     col->getVersion(versionArray);
  96     // Check for a version greater than some value rather than equality
  97     // so that we need not update the expected version each time.
  98     if (uprv_memcmp(versionArray, currVersionArray, 4)<0) {
  99       errln("Testing Collator::getVersion() - unexpected result: %02x.%02x.%02x.%02x",
 100             versionArray[0], versionArray[1], versionArray[2], versionArray[3]);
 101     } else {
 102       logln("Collator::getVersion() result: %02x.%02x.%02x.%02x",
 103             versionArray[0], versionArray[1], versionArray[2], versionArray[3]);
 104     }
 105
 106     doAssert((col->compare("ab", "abc") == Collator::LESS), "ab < abc comparison failed");
 107     doAssert((col->compare("ab", "AB") == Collator::LESS), "ab < AB comparison failed");
 108     doAssert((col->compare("blackbird", "black-bird") == Collator::GREATER), "black-bird > blackbird comparison failed");
 109     doAssert((col->compare("black bird", "black-bird") == Collator::LESS), "black bird > black-bird comparison failed");
 110     doAssert((col->compare("Hello", "hello") == Collator::GREATER), "Hello > hello comparison failed");
 111     doAssert((col->compare("","",success) == UCOL_EQUAL), "Comparison between empty strings failed");
 112
 113     doAssert((col->compareUTF8("\x61\x62\xc3\xa4", "\x61\x62\xc3\x9f", success) == UCOL_LESS), "ab a-umlaut < ab sharp-s UTF-8 comparison failed");
 114     success = U_ZERO_ERROR;
 115     {
 116         UnicodeString abau=UNICODE_STRING_SIMPLE("\\x61\\x62\\xe4").unescape();
 117         UnicodeString abss=UNICODE_STRING_SIMPLE("\\x61\\x62\\xdf").unescape();
 118         UCharIterator abauIter, abssIter;
 119         uiter_setReplaceable(&abauIter, &abau);
 120         uiter_setReplaceable(&abssIter, &abss);
 121         doAssert((col->compare(abauIter, abssIter, success) == UCOL_LESS), "ab a-umlaut < ab sharp-s UCharIterator comparison failed");
 122         success = U_ZERO_ERROR;
 123     }
 124
 125     /*start of update [Bertrand A. D. 02/10/98]*/
 126     doAssert((col->compare("ab", "abc", 2) == Collator::EQUAL), "ab = abc with length 2 comparison failed");
 127     doAssert((col->compare("ab", "AB", 2) == Collator::LESS), "ab < AB  with length 2 comparison failed");
 128     doAssert((col->compare("ab", "Aa", 1) == Collator::LESS), "ab < Aa  with length 1 comparison failed");
 129     doAssert((col->compare("ab", "Aa", 2) == Collator::GREATER), "ab > Aa  with length 2 comparison failed");
 130     doAssert((col->compare("black-bird", "blackbird", 5) == Collator::EQUAL), "black-bird = blackbird with length of 5 comparison failed");
 131     doAssert((col->compare("black bird", "black-bird", 10) == Collator::LESS), "black bird < black-bird with length 10 comparison failed");
 132     doAssert((col->compare("Hello", "hello", 5) == Collator::GREATER), "Hello > hello with length 5 comparison failed");
 133     /*end of update [Bertrand A. D. 02/10/98]*/
 134
 135
 136     logln("Test ctors ends.");
 137     logln("testing Collator::getStrength() method ...");
 138     doAssert((col->getStrength() == Collator::TERTIARY), "collation object has the wrong strength");
 139     doAssert((col->getStrength() != Collator::PRIMARY), "collation object's strength is primary difference");
 140
 141
 142     logln("testing Collator::setStrength() method ...");
 143     col->setStrength(Collator::SECONDARY);
 144     doAssert((col->getStrength() != Collator::TERTIARY), "collation object's strength is secondary difference");
 145     doAssert((col->getStrength() != Collator::PRIMARY), "collation object's strength is primary difference");
 146     doAssert((col->getStrength() == Collator::SECONDARY), "collation object has the wrong strength");
 147
 148     UnicodeString name;
 149
 150     logln("Get display name for the US English collation in German : ");
 151     logln(Collator::getDisplayName(Locale::getUS(), Locale::getGerman(), name));
 152     doAssert((name == UnicodeString("Englisch (Vereinigte Staaten)")), "getDisplayName failed");
 153
 154     logln("Get display name for the US English collation in English : ");
 155     logln(Collator::getDisplayName(Locale::getUS(), Locale::getEnglish(), name));
 156     doAssert((name == UnicodeString("English (United States)")), "getDisplayName failed");
 157 #if 0
 158     // weiv : this test is bogus if we're running on any machine that has different default locale than English.
 159     // Therefore, it is banned!
 160     logln("Get display name for the US English in default locale language : ");
 161     logln(Collator::getDisplayName(Locale::US, name));
 162     doAssert((name == UnicodeString("English (United States)")), "getDisplayName failed if this is an English machine");
 163 #endif
 164     delete col; col = 0;
 165     RuleBasedCollator *rcol = (RuleBasedCollator *)Collator::createInstance("da_DK",
 166                                                                             success);
 167     if (U_FAILURE(success)) {
 168         errcheckln(success, "Collator::createInstance(\"da_DK\") failed - %s", u_errorName(success));
 169         return;
 170     }
 171     const UnicodeString &daRules = rcol->getRules();
 172     if(daRules.isEmpty()) {
 173         dataerrln("missing da_DK tailoring rule string");
 174     } else {
 175         doAssert(daRules.indexOf("aa") >= 0, "da_DK rules do not contain 'aa'");
 176     }
 177     delete rcol;
 178
 179     col = Collator::createInstance(Locale::getFrench(), success);
 180     if (U_FAILURE(success))
 181     {
 182         errln("Creating French collation failed.");
 183         return;
 184     }
 185
 186     col->setStrength(Collator::PRIMARY);
 187     logln("testing Collator::getStrength() method again ...");
 188     doAssert((col->getStrength() != Collator::TERTIARY), "collation object has the wrong strength");
 189     doAssert((col->getStrength() == Collator::PRIMARY), "collation object's strength is not primary difference");
 190
 191     logln("testing French Collator::setStrength() method ...");
 192     col->setStrength(Collator::TERTIARY);
 193     doAssert((col->getStrength() == Collator::TERTIARY), "collation object's strength is not tertiary difference");
 194     doAssert((col->getStrength() != Collator::PRIMARY), "collation object's strength is primary difference");
 195     doAssert((col->getStrength() != Collator::SECONDARY), "collation object's strength is secondary difference");
 196     delete col;
 197
 198     logln("Create junk collation: ");
 199     Locale abcd("ab", "CD", "");
 200     success = U_ZERO_ERROR;
 201     Collator *junk = 0;
 202     junk = Collator::createInstance(abcd, success);
 203
 204     if (U_FAILURE(success))
 205     {
 206         errln("Junk collation creation failed, should at least return default.");
 207         return;
 208     }
 209
 210     doAssert(((RuleBasedCollator *)junk)->getRules().isEmpty(),
 211                "The root collation should be returned for an unsupported language.");
 212     Collator *frCol = Collator::createInstance(Locale::getCanadaFrench(), success);
 213     if (U_FAILURE(success))
 214     {
 215         errln("Creating fr_CA collator failed.");
 216         delete junk;
 217         return;
 218     }
 219
 220     // If the default locale isn't French, the French and non-French collators
 221     // should be different
 222     if (frCol->getLocale(ULOC_ACTUAL_LOCALE, success) != Locale::getCanadaFrench()) {
 223         doAssert((*frCol != *junk), "The junk is the same as the fr_CA collator.");
 224     }
 225     Collator *aFrCol = frCol->clone();
 226     doAssert((*frCol == *aFrCol), "The cloning of a fr_CA collator failed.");
 227     logln("Collator property test ended.");
 228
 229     delete frCol;
 230     delete aFrCol;
 231     delete junk;
 232 }
 233
 234 void
 235 CollationAPITest::TestRuleBasedColl()
 236 {
 237     RuleBasedCollator *col1, *col2, *col3, *col4;
 238     UErrorCode status = U_ZERO_ERROR;
 239
 240     UnicodeString ruleset1("&9 < a, A < b, B < c, C; ch, cH, Ch, CH < d, D, e, E");
 241     UnicodeString ruleset2("&9 < a, A < b, B < c, C < d, D, e, E");
 242
 243     col1 = new RuleBasedCollator(ruleset1, status);
 244     if (U_FAILURE(status)) {
 245         errcheckln(status, "RuleBased Collator creation failed. - %s", u_errorName(status));
 246         return;
 247     }
 248     else {
 249         logln("PASS: RuleBased Collator creation passed\n");
 250     }
 251
 252     status = U_ZERO_ERROR;
 253     col2 = new RuleBasedCollator(ruleset2, status);
 254     if (U_FAILURE(status)) {
 255         errln("RuleBased Collator creation failed.\n");
 256         return;
 257     }
 258     else {
 259         logln("PASS: RuleBased Collator creation passed\n");
 260     }
 261
 262     status = U_ZERO_ERROR;
 263     Locale locale("aa", "AA");
 264     col3 = (RuleBasedCollator *)Collator::createInstance(locale, status);
 265     if (U_FAILURE(status)) {
 266         errln("Fallback Collator creation failed.: %s\n");
 267         return;
 268     }
 269     else {
 270         logln("PASS: Fallback Collator creation passed\n");
 271     }
 272     delete col3;
 273
 274     status = U_ZERO_ERROR;
 275     col3 = (RuleBasedCollator *)Collator::createInstance(status);
 276     if (U_FAILURE(status)) {
 277         errln("Default Collator creation failed.: %s\n");
 278         return;
 279     }
 280     else {
 281         logln("PASS: Default Collator creation passed\n");
 282     }
 283
 284     UnicodeString rule1 = col1->getRules();
 285     UnicodeString rule2 = col2->getRules();
 286     UnicodeString rule3 = col3->getRules();
 287
 288     doAssert(rule1 != rule2, "Default collator getRules failed");
 289     doAssert(rule2 != rule3, "Default collator getRules failed");
 290     doAssert(rule1 != rule3, "Default collator getRules failed");
 291
 292     col4 = new RuleBasedCollator(rule2, status);
 293     if (U_FAILURE(status)) {
 294         errln("RuleBased Collator creation failed.\n");
 295         return;
 296     }
 297
 298     UnicodeString rule4 = col4->getRules();
 299     doAssert(rule2 == rule4, "Default collator getRules failed");
 300     int32_t length4 = 0;
 301     uint8_t *clonedrule4 = col4->cloneRuleData(length4, status);
 302     if (U_FAILURE(status)) {
 303         errln("Cloned rule data failed.\n");
 304         return;
 305     }
 306
 307  //   free(clonedrule4);     BAD API!!!!
 308     uprv_free(clonedrule4);
 309
 310
 311     delete col1;
 312     delete col2;
 313     delete col3;
 314     delete col4;
 315 }
 316
 317 void
 318 CollationAPITest::TestRules()
 319 {
 320     RuleBasedCollator *coll;
 321     UErrorCode status = U_ZERO_ERROR;
 322     UnicodeString rules;
 323
 324     coll = (RuleBasedCollator *)Collator::createInstance(Locale::getEnglish(), status);
 325     if (U_FAILURE(status)) {
 326         errcheckln(status, "English Collator creation failed. - %s", u_errorName(status));
 327         return;
 328     }
 329     else {
 330         logln("PASS: RuleBased Collator creation passed\n");
 331     }
 332
 333     coll->getRules(UCOL_TAILORING_ONLY, rules);
 334     if (rules.length() != 0x00) {
 335       errln("English tailored rules failed - length is 0x%x expected 0x%x", rules.length(), 0x00);
 336     }
 337
 338     coll->getRules(UCOL_FULL_RULES, rules);
 339     if (rules.length() < 0) {
 340         errln("English full rules failed");
 341     }
 342     delete coll;
 343 }
 344
 345 void
 346 CollationAPITest::TestDecomposition() {
 347   UErrorCode status = U_ZERO_ERROR;
 348   Collator *en_US = Collator::createInstance("en_US", status),
 349     *el_GR = Collator::createInstance("el_GR", status),
 350     *vi_VN = Collator::createInstance("vi_VN", status);
 351
 352   if (U_FAILURE(status)) {
 353     errcheckln(status, "ERROR: collation creation failed. - %s", u_errorName(status));
 354     return;
 355   }
 356
 357   /* there is no reason to have canonical decomposition in en_US OR default locale */
 358   if (vi_VN->getAttribute(UCOL_NORMALIZATION_MODE, status) != UCOL_ON)
 359   {
 360     errln("ERROR: vi_VN collation did not have canonical decomposition for normalization!\n");
 361   }
 362
 363   if (el_GR->getAttribute(UCOL_NORMALIZATION_MODE, status) != UCOL_ON)
 364   {
 365     errln("ERROR: el_GR collation did not have canonical decomposition for normalization!\n");
 366   }
 367
 368   if (en_US->getAttribute(UCOL_NORMALIZATION_MODE, status) != UCOL_OFF)
 369   {
 370     errln("ERROR: en_US collation had canonical decomposition for normalization!\n");
 371   }
 372
 373   delete en_US;
 374   delete el_GR;
 375   delete vi_VN;
 376 }
 377
 378 void
 379 CollationAPITest::TestSafeClone() {
 380     static const int CLONETEST_COLLATOR_COUNT = 3;
 381     Collator *someCollators [CLONETEST_COLLATOR_COUNT];
 382     Collator *col;
 383     UErrorCode err = U_ZERO_ERROR;
 384     int index;
 385
 386     UnicodeString test1("abCda");
 387     UnicodeString test2("abcda");
 388
 389     /* one default collator & two complex ones */
 390     someCollators[0] = Collator::createInstance("en_US", err);
 391     someCollators[1] = Collator::createInstance("ko", err);
 392     someCollators[2] = Collator::createInstance("ja_JP", err);
 393     if(U_FAILURE(err)) {
 394       errcheckln(err, "Couldn't instantiate collators. Error: %s", u_errorName(err));
 395       delete someCollators[0];
 396       delete someCollators[1];
 397       delete someCollators[2];
 398       return;
 399     }
 400
 401     /* change orig & clone & make sure they are independent */
 402
 403     for (index = 0; index < CLONETEST_COLLATOR_COUNT; index++)
 404     {
 405         col = someCollators[index]->safeClone();
 406         if (col == 0) {
 407             errln("SafeClone of collator should not return null\n");
 408             break;
 409         }
 410         col->setStrength(Collator::TERTIARY);
 411         someCollators[index]->setStrength(Collator::PRIMARY);
 412         col->setAttribute(UCOL_CASE_LEVEL, UCOL_OFF, err);
 413         someCollators[index]->setAttribute(UCOL_CASE_LEVEL, UCOL_OFF, err);
 414
 415         doAssert(col->greater(test1, test2), "Result should be \"abCda\" >>> \"abcda\" ");
 416         doAssert(someCollators[index]->equals(test1, test2), "Result should be \"abcda\" == \"abCda\"");
 417         delete col;
 418         delete someCollators[index];
 419     }
 420 }
 421
 422 void
 423 CollationAPITest::TestHashCode(/* char* par */)
 424 {
 425     logln("hashCode tests begin.");
 426     UErrorCode success = U_ZERO_ERROR;
 427     Collator *col1 = 0;
 428     col1 = Collator::createInstance(Locale::getEnglish(), success);
 429     if (U_FAILURE(success))
 430     {
 431         errcheckln(success, "Default collation creation failed. - %s", u_errorName(success));
 432         return;
 433     }
 434
 435     Collator *col2 = 0;
 436     Locale dk("da", "DK", "");
 437     col2 = Collator::createInstance(dk, success);
 438     if (U_FAILURE(success))
 439     {
 440         errln("Danish collation creation failed.");
 441         return;
 442     }
 443
 444     Collator *col3 = 0;
 445     col3 = Collator::createInstance(Locale::getEnglish(), success);
 446     if (U_FAILURE(success))
 447     {
 448         errln("2nd default collation creation failed.");
 449         return;
 450     }
 451
 452     logln("Collator::hashCode() testing ...");
 453
 454     doAssert(col1->hashCode() != col2->hashCode(), "Hash test1 result incorrect" );
 455     doAssert(!(col1->hashCode() == col2->hashCode()), "Hash test2 result incorrect" );
 456     doAssert(col1->hashCode() == col3->hashCode(), "Hash result not equal" );
 457
 458     logln("hashCode tests end.");
 459     delete col1;
 460     delete col2;
 461
 462     UnicodeString test1("Abcda");
 463     UnicodeString test2("abcda");
 464
 465     CollationKey sortk1, sortk2, sortk3;
 466     UErrorCode status = U_ZERO_ERROR;
 467
 468     col3->getCollationKey(test1, sortk1, status);
 469     col3->getCollationKey(test2, sortk2, status);
 470     col3->getCollationKey(test2, sortk3, status);
 471
 472     doAssert(sortk1.hashCode() != sortk2.hashCode(), "Hash test1 result incorrect");
 473     doAssert(sortk2.hashCode() == sortk3.hashCode(), "Hash result not equal" );
 474
 475     delete col3;
 476 }
 477
 478 //----------------------------------------------------------------------------
 479 // CollationKey -- Tests the CollationKey methods
 480 //
 481 void
 482 CollationAPITest::TestCollationKey(/* char* par */)
 483 {
 484     logln("testing CollationKey begins...");
 485     Collator *col = 0;
 486     UErrorCode success=U_ZERO_ERROR;
 487     col = Collator::createInstance(Locale::getEnglish(), success);
 488     if (U_FAILURE(success))
 489     {
 490         errcheckln(success, "Default collation creation failed. - %s", u_errorName(success));
 491         return;
 492     }
 493     col->setStrength(Collator::TERTIARY);
 494
 495     CollationKey sortk1, sortk2;
 496     UnicodeString test1("Abcda"), test2("abcda");
 497     UErrorCode key1Status = U_ZERO_ERROR, key2Status = U_ZERO_ERROR;
 498
 499     logln("Testing weird arguments");
 500     // No string vs. empty string vs. completely-ignorable string:
 501     // See ICU ticket #10495.
 502     CollationKey sortkNone;
 503     int32_t length;
 504     sortkNone.getByteArray(length);
 505     doAssert(!sortkNone.isBogus() && length == 0,
 506              "Default-constructed collation key should be empty");
 507     CollationKey sortkEmpty;
 508     col->getCollationKey(NULL, 0, sortkEmpty, key1Status);
 509     // key gets reset here
 510     const uint8_t* byteArrayEmpty = sortkEmpty.getByteArray(length);
 511     doAssert(sortkEmpty.isBogus() == FALSE && length == 3 &&
 512              byteArrayEmpty[0] == 1 && byteArrayEmpty[1] == 1 && byteArrayEmpty[2] == 0,
 513              "Empty string should return a collation key with empty levels");
 514     doAssert(sortkNone.compareTo(sortkEmpty) == Collator::LESS,
 515              "Expected no collation key < collation key for empty string");
 516     doAssert(sortkEmpty.compareTo(sortkNone) == Collator::GREATER,
 517              "Expected collation key for empty string > no collation key");
 518
 519     CollationKey sortkIgnorable;
 520     // Most control codes and CGJ are completely ignorable.
 521     // A string with only completely ignorables must compare equal to an empty string.
 522     col->getCollationKey(UnicodeString((UChar)1).append((UChar)0x34f), sortkIgnorable, key1Status);
 523     sortkIgnorable.getByteArray(length);
 524     doAssert(!sortkIgnorable.isBogus() && length == 3,
 525              "Completely ignorable string should return a collation key with empty levels");
 526     doAssert(sortkIgnorable.compareTo(sortkEmpty) == Collator::EQUAL,
 527              "Completely ignorable string should compare equal to empty string");
 528
 529     // bogus key returned here
 530     key1Status = U_ILLEGAL_ARGUMENT_ERROR;
 531     col->getCollationKey(NULL, 0, sortk1, key1Status);
 532     doAssert(sortk1.isBogus() && (sortk1.getByteArray(length), length) == 0,
 533         "Error code should return bogus collation key");
 534
 535     key1Status = U_ZERO_ERROR;
 536     logln("Use tertiary comparison level testing ....");
 537
 538     col->getCollationKey(test1, sortk1, key1Status);
 539     if (U_FAILURE(key1Status)) {
 540         errln("getCollationKey(Abcda) failed - %s", u_errorName(key1Status));
 541         return;
 542     }
 543     doAssert((sortk1.compareTo(col->getCollationKey(test2, sortk2, key2Status)))
 544                  == Collator::GREATER,
 545                 "Result should be \"Abcda\" >>> \"abcda\"");
 546
 547     CollationKey sortk3(sortk2), sortkNew;
 548
 549     sortkNew = sortk1;
 550     doAssert((sortk1 != sortk2), "The sort keys should be different");
 551     doAssert((sortk1.hashCode() != sortk2.hashCode()), "sort key hashCode() failed");
 552     doAssert((sortk2 == sortk3), "The sort keys should be the same");
 553     doAssert((sortk1 == sortkNew), "The sort keys assignment failed");
 554     doAssert((sortk1.hashCode() == sortkNew.hashCode()), "sort key hashCode() failed");
 555     doAssert((sortkNew != sortk3), "The sort keys should be different");
 556     doAssert(sortk1.compareTo(sortk3) == Collator::GREATER, "Result should be \"Abcda\" >>> \"abcda\"");
 557     doAssert(sortk2.compareTo(sortk3) == Collator::EQUAL, "Result should be \"abcda\" == \"abcda\"");
 558     doAssert(sortkEmpty.compareTo(sortk1) == Collator::LESS, "Result should be (empty key) <<< \"Abcda\"");
 559     doAssert(sortk1.compareTo(sortkEmpty) == Collator::GREATER, "Result should be \"Abcda\" >>> (empty key)");
 560     doAssert(sortkEmpty.compareTo(sortkEmpty) == Collator::EQUAL, "Result should be (empty key) == (empty key)");
 561     doAssert(sortk1.compareTo(sortk3, success) == UCOL_GREATER, "Result should be \"Abcda\" >>> \"abcda\"");
 562     doAssert(sortk2.compareTo(sortk3, success) == UCOL_EQUAL, "Result should be \"abcda\" == \"abcda\"");
 563     doAssert(sortkEmpty.compareTo(sortk1, success) == UCOL_LESS, "Result should be (empty key) <<< \"Abcda\"");
 564     doAssert(sortk1.compareTo(sortkEmpty, success) == UCOL_GREATER, "Result should be \"Abcda\" >>> (empty key)");
 565     doAssert(sortkEmpty.compareTo(sortkEmpty, success) == UCOL_EQUAL, "Result should be (empty key) == (empty key)");
 566
 567     int32_t    cnt1, cnt2, cnt3, cnt4;
 568
 569     const uint8_t* byteArray1 = sortk1.getByteArray(cnt1);
 570     const uint8_t* byteArray2 = sortk2.getByteArray(cnt2);
 571
 572     const uint8_t* byteArray3 = 0;
 573     byteArray3 = sortk1.getByteArray(cnt3);
 574
 575     const uint8_t* byteArray4 = 0;
 576     byteArray4 = sortk2.getByteArray(cnt4);
 577
 578     CollationKey sortk4(byteArray1, cnt1), sortk5(byteArray2, cnt2);
 579     CollationKey sortk6(byteArray3, cnt3), sortk7(byteArray4, cnt4);
 580
 581     doAssert(sortk1.compareTo(sortk4) == Collator::EQUAL, "CollationKey::toByteArray(sortk1) Failed.");
 582     doAssert(sortk2.compareTo(sortk5) == Collator::EQUAL, "CollationKey::toByteArray(sortk2) Failed.");
 583     doAssert(sortk4.compareTo(sortk5) == Collator::GREATER, "sortk4 >>> sortk5 Failed");
 584     doAssert(sortk1.compareTo(sortk6) == Collator::EQUAL, "CollationKey::getByteArray(sortk1) Failed.");
 585     doAssert(sortk2.compareTo(sortk7) == Collator::EQUAL, "CollationKey::getByteArray(sortk2) Failed.");
 586     doAssert(sortk6.compareTo(sortk7) == Collator::GREATER, "sortk6 >>> sortk7 Failed");
 587
 588     logln("Equality tests : ");
 589     doAssert(sortk1 == sortk4, "sortk1 == sortk4 Failed.");
 590     doAssert(sortk2 == sortk5, "sortk2 == sortk5 Failed.");
 591     doAssert(sortk1 != sortk5, "sortk1 != sortk5 Failed.");
 592     doAssert(sortk1 == sortk6, "sortk1 == sortk6 Failed.");
 593     doAssert(sortk2 == sortk7, "sortk2 == sortk7 Failed.");
 594     doAssert(sortk1 != sortk7, "sortk1 != sortk7 Failed.");
 595
 596     byteArray1 = 0;
 597     byteArray2 = 0;
 598
 599     sortk3 = sortk1;
 600     doAssert(sortk1 == sortk3, "sortk1 = sortk3 assignment Failed.");
 601     doAssert(sortk2 != sortk3, "sortk2 != sortk3 Failed.");
 602     logln("testing sortkey ends...");
 603
 604     col->setStrength(Collator::SECONDARY);
 605     doAssert(col->getCollationKey(test1, sortk1, key1Status).compareTo(
 606                                   col->getCollationKey(test2, sortk2, key2Status))
 607                                   == Collator::EQUAL,
 608                                   "Result should be \"Abcda\" == \"abcda\"");
 609     delete col;
 610 }
 611
 612 //----------------------------------------------------------------------------
 613 // Tests the CollatorElementIterator class.
 614 // ctor, RuleBasedCollator::createCollationElementIterator(), operator==, operator!=
 615 //
 616 void
 617 CollationAPITest::TestElemIter(/* char* par */)
 618 {
 619     logln("testing sortkey begins...");
 620     Collator *col = 0;
 621     UErrorCode success = U_ZERO_ERROR;
 622     col = Collator::createInstance(Locale::getEnglish(), success);
 623     if (U_FAILURE(success))
 624     {
 625         errcheckln(success, "Default collation creation failed. - %s", u_errorName(success));
 626         return;
 627     }
 628
 629     UnicodeString testString1("XFILE What subset of all possible test cases has the highest probability of detecting the most errors?");
 630     UnicodeString testString2("Xf_ile What subset of all possible test cases has the lowest probability of detecting the least errors?");
 631     logln("Constructors and comparison testing....");
 632     CollationElementIterator *iterator1 = ((RuleBasedCollator*)col)->createCollationElementIterator(testString1);
 633
 634     CharacterIterator *chariter=new StringCharacterIterator(testString1);
 635     CollationElementIterator *coliter=((RuleBasedCollator*)col)->createCollationElementIterator(*chariter);
 636
 637     // copy ctor
 638     CollationElementIterator *iterator2 = ((RuleBasedCollator*)col)->createCollationElementIterator(testString1);
 639     CollationElementIterator *iterator3 = ((RuleBasedCollator*)col)->createCollationElementIterator(testString2);
 640
 641     int32_t offset = iterator1->getOffset();
 642     if (offset != 0) {
 643         errln("Error in getOffset for collation element iterator\n");
 644         return;
 645     }
 646     iterator1->setOffset(6, success);
 647     if (U_FAILURE(success)) {
 648         errln("Error in setOffset for collation element iterator\n");
 649         return;
 650     }
 651     iterator1->setOffset(0, success);
 652     int32_t order1, order2, order3;
 653     doAssert((*iterator1 == *iterator2), "The two iterators should be the same");
 654     doAssert((*iterator1 != *iterator3), "The two iterators should be different");
 655
 656     doAssert((*coliter == *iterator1), "The two iterators should be the same");
 657     doAssert((*coliter == *iterator2), "The two iterators should be the same");
 658     doAssert((*coliter != *iterator3), "The two iterators should be different");
 659
 660     order1 = iterator1->next(success);
 661     if (U_FAILURE(success))
 662     {
 663         errln("Somehow ran out of memory stepping through the iterator.");
 664         return;
 665     }
 666
 667     doAssert((*iterator1 != *iterator2), "The first iterator advance failed");
 668     order2 = iterator2->getOffset();
 669     doAssert((order1 != order2), "The order result should not be the same");
 670     order2 = iterator2->next(success);
 671     if (U_FAILURE(success))
 672     {
 673         errln("Somehow ran out of memory stepping through the iterator.");
 674         return;
 675     }
 676
 677     doAssert((*iterator1 == *iterator2), "The second iterator advance failed");
 678     doAssert((order1 == order2), "The order result should be the same");
 679     order3 = iterator3->next(success);
 680     if (U_FAILURE(success))
 681     {
 682         errln("Somehow ran out of memory stepping through the iterator.");
 683         return;
 684     }
 685
 686     doAssert((CollationElementIterator::primaryOrder(order1) ==
 687         CollationElementIterator::primaryOrder(order3)), "The primary orders should be the same");
 688     doAssert((CollationElementIterator::secondaryOrder(order1) ==
 689         CollationElementIterator::secondaryOrder(order3)), "The secondary orders should be the same");
 690     doAssert((CollationElementIterator::tertiaryOrder(order1) ==
 691         CollationElementIterator::tertiaryOrder(order3)), "The tertiary orders should be the same");
 692
 693     order1 = iterator1->next(success); order3 = iterator3->next(success);
 694     if (U_FAILURE(success))
 695     {
 696         errln("Somehow ran out of memory stepping through the iterator.");
 697         return;
 698     }
 699
 700     doAssert((CollationElementIterator::primaryOrder(order1) ==
 701         CollationElementIterator::primaryOrder(order3)), "The primary orders should be identical");
 702     doAssert((CollationElementIterator::tertiaryOrder(order1) !=
 703         CollationElementIterator::tertiaryOrder(order3)), "The tertiary orders should be different");
 704
 705     order1 = iterator1->next(success);
 706     order3 = iterator3->next(success);
 707     /* NO! Secondary orders of two CEs are not related, especially in the case of '_' vs 'I' */
 708     /*
 709     doAssert((CollationElementIterator::secondaryOrder(order1) !=
 710         CollationElementIterator::secondaryOrder(order3)), "The secondary orders should not be the same");
 711     */
 712     doAssert((order1 != CollationElementIterator::NULLORDER), "Unexpected end of iterator reached");
 713
 714     iterator1->reset(); iterator2->reset(); iterator3->reset();
 715     order1 = iterator1->next(success);
 716     if (U_FAILURE(success))
 717     {
 718         errln("Somehow ran out of memory stepping through the iterator.");
 719         return;
 720     }
 721
 722     doAssert((*iterator1 != *iterator2), "The first iterator advance failed");
 723
 724     order2 = iterator2->next(success);
 725     if (U_FAILURE(success))
 726     {
 727         errln("Somehow ran out of memory stepping through the iterator.");
 728         return;
 729     }
 730
 731     doAssert((*iterator1 == *iterator2), "The second iterator advance failed");
 732     doAssert((order1 == order2), "The order result should be the same");
 733
 734     order3 = iterator3->next(success);
 735     if (U_FAILURE(success))
 736     {
 737         errln("Somehow ran out of memory stepping through the iterator.");
 738         return;
 739     }
 740
 741     doAssert((CollationElementIterator::primaryOrder(order1) ==
 742         CollationElementIterator::primaryOrder(order3)), "The primary orders should be the same");
 743     doAssert((CollationElementIterator::secondaryOrder(order1) ==
 744         CollationElementIterator::secondaryOrder(order3)), "The secondary orders should be the same");
 745     doAssert((CollationElementIterator::tertiaryOrder(order1) ==
 746         CollationElementIterator::tertiaryOrder(order3)), "The tertiary orders should be the same");
 747
 748     order1 = iterator1->next(success); order2 = iterator2->next(success); order3 = iterator3->next(success);
 749     if (U_FAILURE(success))
 750     {
 751         errln("Somehow ran out of memory stepping through the iterator.");
 752         return;
 753     }
 754
 755     doAssert((CollationElementIterator::primaryOrder(order1) ==
 756         CollationElementIterator::primaryOrder(order3)), "The primary orders should be identical");
 757     doAssert((CollationElementIterator::tertiaryOrder(order1) !=
 758         CollationElementIterator::tertiaryOrder(order3)), "The tertiary orders should be different");
 759
 760     order1 = iterator1->next(success); order3 = iterator3->next(success);
 761     if (U_FAILURE(success))
 762     {
 763         errln("Somehow ran out of memory stepping through the iterator.");
 764         return;
 765     }
 766
 767     /* NO! Secondary orders of two CEs are not related, especially in the case of '_' vs 'I' */
 768     /*
 769     doAssert((CollationElementIterator::secondaryOrder(order1) !=
 770         CollationElementIterator::secondaryOrder(order3)), "The secondary orders should not be the same");
 771     */
 772     doAssert((order1 != CollationElementIterator::NULLORDER), "Unexpected end of iterator reached");
 773     doAssert((*iterator2 != *iterator3), "The iterators should be different");
 774
 775
 776     //test error values
 777     success=U_UNSUPPORTED_ERROR;
 778     Collator *colerror=NULL;
 779     colerror=Collator::createInstance(Locale::getEnglish(), success);
 780     if (colerror != 0 || success == U_ZERO_ERROR){
 781         errln("Error: createInstance(UErrorCode != U_ZERO_ERROR) should just return and not create an instance\n");
 782     }
 783     int32_t position=coliter->previous(success);
 784     if(position != CollationElementIterator::NULLORDER){
 785         errln((UnicodeString)"Expected NULLORDER got" + position);
 786     }
 787     coliter->reset();
 788     coliter->setText(*chariter, success);
 789     if(!U_FAILURE(success)){
 790         errln("Expeceted error");
 791     }
 792     iterator1->setText((UnicodeString)"hello there", success);
 793     if(!U_FAILURE(success)){
 794         errln("Expeceted error");
 795     }
 796
 797     delete chariter;
 798     delete coliter;
 799     delete iterator1;
 800     delete iterator2;
 801     delete iterator3;
 802     delete col;
 803
 804
 805
 806     logln("testing CollationElementIterator ends...");
 807 }
 808
 809 // Test RuleBasedCollator ctor, dtor, operator==, operator!=, clone, copy, and getRules
 810 void
 811 CollationAPITest::TestOperators(/* char* par */)
 812 {
 813     UErrorCode success = U_ZERO_ERROR;
 814     UnicodeString ruleset1("&9 < a, A < b, B < c, C; ch, cH, Ch, CH < d, D, e, E");
 815     UnicodeString ruleset2("&9 < a, A < b, B < c, C < d, D, e, E");
 816     RuleBasedCollator *col1 = new RuleBasedCollator(ruleset1, success);
 817     if (U_FAILURE(success)) {
 818         errcheckln(success, "RuleBasedCollator creation failed. - %s", u_errorName(success));
 819         return;
 820     }
 821     success = U_ZERO_ERROR;
 822     RuleBasedCollator *col2 = new RuleBasedCollator(ruleset2, success);
 823     if (U_FAILURE(success)) {
 824         errln("The RuleBasedCollator constructor failed when building with the 2nd rule set.");
 825         return;
 826     }
 827     logln("The operator tests begin : ");
 828     logln("testing operator==, operator!=, clone  methods ...");
 829     doAssert((*col1 != *col2), "The two different table collations compared equal");
 830     *col1 = *col2;
 831     doAssert((*col1 == *col2), "Collator objects not equal after assignment (operator=)");
 832
 833     success = U_ZERO_ERROR;
 834     Collator *col3 = Collator::createInstance(Locale::getEnglish(), success);
 835     if (U_FAILURE(success)) {
 836         errln("Default collation creation failed.");
 837         return;
 838     }
 839     doAssert((*col1 != *col3), "The two different table collations compared equal");
 840     Collator* col4 = col1->clone();
 841     Collator* col5 = col3->clone();
 842     doAssert((*col1 == *col4), "Cloned collation objects not equal");
 843     doAssert((*col3 != *col4), "Two different table collations compared equal");
 844     doAssert((*col3 == *col5), "Cloned collation objects not equal");
 845     doAssert((*col4 != *col5), "Two cloned collations compared equal");
 846
 847     const UnicodeString& defRules = ((RuleBasedCollator*)col3)->getRules();
 848     RuleBasedCollator* col6 = new RuleBasedCollator(defRules, success);
 849     if (U_FAILURE(success)) {
 850         errln("Creating default collation with rules failed.");
 851         return;
 852     }
 853     doAssert((((RuleBasedCollator*)col3)->getRules() == col6->getRules()), "Default collator getRules failed");
 854
 855     success = U_ZERO_ERROR;
 856     RuleBasedCollator *col7 = new RuleBasedCollator(ruleset2, Collator::TERTIARY, success);
 857     if (U_FAILURE(success)) {
 858         errln("The RuleBasedCollator constructor failed when building with the 2nd rule set with tertiary strength.");
 859         return;
 860     }
 861     success = U_ZERO_ERROR;
 862     RuleBasedCollator *col8 = new RuleBasedCollator(ruleset2, UCOL_OFF, success);
 863     if (U_FAILURE(success)) {
 864         errln("The RuleBasedCollator constructor failed when building with the 2nd rule set with Normalizer::NO_OP.");
 865         return;
 866     }
 867     success = U_ZERO_ERROR;
 868     RuleBasedCollator *col9 = new RuleBasedCollator(ruleset2, Collator::PRIMARY, UCOL_ON, success);
 869     if (U_FAILURE(success)) {
 870         errln("The RuleBasedCollator constructor failed when building with the 2nd rule set with tertiary strength and Normalizer::NO_OP.");
 871         return;
 872     }
 873   //  doAssert((*col7 == *col8), "The two equal table collations compared different");
 874     doAssert((*col7 != *col9), "The two different table collations compared equal");
 875     doAssert((*col8 != *col9), "The two different table collations compared equal");
 876
 877     logln("operator tests ended.");
 878     delete col1;
 879     delete col2;
 880     delete col3;
 881     delete col4;
 882     delete col5;
 883     delete col6;
 884     delete col7;
 885     delete col8;
 886     delete col9;
 887 }
 888
 889 // test clone and copy
 890 void
 891 CollationAPITest::TestDuplicate(/* char* par */)
 892 {
 893     UErrorCode status = U_ZERO_ERROR;
 894     Collator *col1 = Collator::createInstance(Locale::getEnglish(), status);
 895     if (U_FAILURE(status)) {
 896         logln("Default collator creation failed.");
 897         return;
 898     }
 899     Collator *col2 = col1->clone();
 900     doAssert((*col1 == *col2), "Cloned object is not equal to the orginal");
 901     UnicodeString ruleset("&9 < a, A < b, B < c, C < d, D, e, E");
 902     RuleBasedCollator *col3 = new RuleBasedCollator(ruleset, status);
 903     if (U_FAILURE(status)) {
 904         logln("Collation tailoring failed.");
 905         return;
 906     }
 907     doAssert((*col1 != *col3), "Cloned object is equal to some dummy");
 908     *col3 = *((RuleBasedCollator*)col1);
 909     doAssert((*col1 == *col3), "Copied object is not equal to the orginal");
 910
 911     UCollationResult res;
 912     UnicodeString first((UChar)0x0061);
 913     UnicodeString second((UChar)0x0062);
 914     UnicodeString copiedEnglishRules(((RuleBasedCollator*)col1)->getRules());
 915
 916     delete col1;
 917
 918     // Try using the cloned collators after deleting the original data
 919     res = col2->compare(first, second, status);
 920     if(res != UCOL_LESS) {
 921         errln("a should be less then b after tailoring");
 922     }
 923     if (((RuleBasedCollator*)col2)->getRules() != copiedEnglishRules) {
 924         errln(UnicodeString("English rule difference. ")
 925             + copiedEnglishRules + UnicodeString("\ngetRules=") + ((RuleBasedCollator*)col2)->getRules());
 926     }
 927     res = col3->compare(first, second, status);
 928     if(res != UCOL_LESS) {
 929         errln("a should be less then b after tailoring");
 930     }
 931     if (col3->getRules() != copiedEnglishRules) {
 932         errln(UnicodeString("English rule difference. ")
 933             + copiedEnglishRules + UnicodeString("\ngetRules=") + col3->getRules());
 934     }
 935
 936     delete col2;
 937     delete col3;
 938 }
 939
 940 void
 941 CollationAPITest::TestCompare(/* char* par */)
 942 {
 943     logln("The compare tests begin : ");
 944     Collator *col = 0;
 945     UErrorCode success = U_ZERO_ERROR;
 946     col = Collator::createInstance(Locale::getEnglish(), success);
 947     if (U_FAILURE(success)) {
 948         errcheckln(success, "Default collation creation failed. - %s", u_errorName(success));
 949         return;
 950     }
 951     UnicodeString test1("Abcda"), test2("abcda");
 952     logln("Use tertiary comparison level testing ....");
 953
 954     doAssert((!col->equals(test1, test2) ), "Result should be \"Abcda\" != \"abcda\"");
 955     doAssert((col->greater(test1, test2) ), "Result should be \"Abcda\" >>> \"abcda\"");
 956     doAssert((col->greaterOrEqual(test1, test2) ), "Result should be \"Abcda\" >>> \"abcda\"");
 957
 958     col->setStrength(Collator::SECONDARY);
 959     logln("Use secondary comparison level testing ....");
 960
 961     doAssert((col->equals(test1, test2) ), "Result should be \"Abcda\" == \"abcda\"");
 962     doAssert((!col->greater(test1, test2) ), "Result should be \"Abcda\" == \"abcda\"");
 963     doAssert((col->greaterOrEqual(test1, test2) ), "Result should be \"Abcda\" == \"abcda\"");
 964
 965     col->setStrength(Collator::PRIMARY);
 966     logln("Use primary comparison level testing ....");
 967
 968     doAssert((col->equals(test1, test2) ), "Result should be \"Abcda\" == \"abcda\"");
 969     doAssert((!col->greater(test1, test2) ), "Result should be \"Abcda\" == \"abcda\"");
 970     doAssert((col->greaterOrEqual(test1, test2) ), "Result should be \"Abcda\" == \"abcda\"");
 971
 972     // Test different APIs
 973     const UChar* t1 = test1.getBuffer();
 974     int32_t t1Len = test1.length();
 975     const UChar* t2 = test2.getBuffer();
 976     int32_t t2Len = test2.length();
 977
 978     doAssert((col->compare(test1, test2) == Collator::EQUAL), "Problem");
 979     doAssert((col->compare(test1, test2, success) == UCOL_EQUAL), "Problem");
 980     doAssert((col->compare(t1, t1Len, t2, t2Len) == Collator::EQUAL), "Problem");
 981     doAssert((col->compare(t1, t1Len, t2, t2Len, success) == UCOL_EQUAL), "Problem");
 982     doAssert((col->compare(test1, test2, t1Len) == Collator::EQUAL), "Problem");
 983     doAssert((col->compare(test1, test2, t1Len, success) == UCOL_EQUAL), "Problem");
 984
 985     col->setAttribute(UCOL_STRENGTH, UCOL_TERTIARY, success);
 986     doAssert((col->compare(test1, test2) == Collator::GREATER), "Problem");
 987     doAssert((col->compare(test1, test2, success) == UCOL_GREATER), "Problem");
 988     doAssert((col->compare(t1, t1Len, t2, t2Len) == Collator::GREATER), "Problem");
 989     doAssert((col->compare(t1, t1Len, t2, t2Len, success) == UCOL_GREATER), "Problem");
 990     doAssert((col->compare(test1, test2, t1Len) == Collator::GREATER), "Problem");
 991     doAssert((col->compare(test1, test2, t1Len, success) == UCOL_GREATER), "Problem");
 992
 993
 994
 995     logln("The compare tests end.");
 996     delete col;
 997 }
 998
 999 void
1000 CollationAPITest::TestGetAll(/* char* par */)
1001 {
1002     int32_t count1, count2;
1003     UErrorCode status = U_ZERO_ERROR;
1004
1005     logln("Trying Collator::getAvailableLocales(int&)");
1006
1007     const Locale* list = Collator::getAvailableLocales(count1);
1008     for (int32_t i = 0; i < count1; ++i) {
1009         UnicodeString dispName;
1010         logln(UnicodeString("Locale name: ")
1011             + UnicodeString(list[i].getName())
1012             + UnicodeString(" , the display name is : ")
1013             + UnicodeString(list[i].getDisplayName(dispName)));
1014     }
1015
1016     if (count1 == 0 || list == NULL) {
1017         dataerrln("getAvailableLocales(int&) returned an empty list");
1018     }
1019
1020     logln("Trying Collator::getAvailableLocales()");
1021     StringEnumeration* localeEnum = Collator::getAvailableLocales();
1022     const UnicodeString* locStr;
1023     const char *locCStr;
1024     count2 = 0;
1025
1026     if (localeEnum == NULL) {
1027         dataerrln("getAvailableLocales() returned NULL");
1028         return;
1029     }
1030
1031     while ((locStr = localeEnum->snext(status)) != NULL)
1032     {
1033         logln(UnicodeString("Locale name is: ") + *locStr);
1034         count2++;
1035     }
1036     if (count1 != count2) {
1037         errln("getAvailableLocales(int&) returned %d and getAvailableLocales() returned %d", count1, count2);
1038     }
1039
1040     logln("Trying Collator::getAvailableLocales() clone");
1041     count1 = 0;
1042     StringEnumeration* localeEnum2 = localeEnum->clone();
1043     localeEnum2->reset(status);
1044     while ((locCStr = localeEnum2->next(NULL, status)) != NULL)
1045     {
1046         logln(UnicodeString("Locale name is: ") + UnicodeString(locCStr));
1047         count1++;
1048     }
1049     if (count1 != count2) {
1050         errln("getAvailableLocales(3rd time) returned %d and getAvailableLocales(2nd time) returned %d", count1, count2);
1051     }
1052     if (localeEnum->count(status) != count1) {
1053         errln("localeEnum->count() returned %d and getAvailableLocales() returned %d", localeEnum->count(status), count1);
1054     }
1055     delete localeEnum;
1056     delete localeEnum2;
1057 }
1058
1059 void CollationAPITest::TestSortKey()
1060 {
1061     UErrorCode status = U_ZERO_ERROR;
1062     /*
1063     this is supposed to open default date format, but later on it treats
1064     it like it is "en_US"
1065     - very bad if you try to run the tests on machine where default
1066       locale is NOT "en_US"
1067     */
1068     Collator *col = Collator::createInstance(Locale::getEnglish(), status);
1069     if (U_FAILURE(status)) {
1070         errcheckln(status, "ERROR: Default collation creation failed.: %s\n", u_errorName(status));
1071         return;
1072     }
1073
1074     if (col->getStrength() != Collator::TERTIARY)
1075     {
1076         errln("ERROR: default collation did not have UCOL_DEFAULT_STRENGTH !\n");
1077     }
1078
1079     /* Need to use identical strength */
1080     col->setAttribute(UCOL_STRENGTH, UCOL_IDENTICAL, status);
1081
1082     UChar test1[6] = {0x41, 0x62, 0x63, 0x64, 0x61, 0},
1083           test2[6] = {0x61, 0x62, 0x63, 0x64, 0x61, 0},
1084           test3[6] = {0x61, 0x62, 0x63, 0x64, 0x61, 0};
1085
1086     uint8_t sortkey1[64];
1087     uint8_t sortkey2[64];
1088     uint8_t sortkey3[64];
1089
1090     logln("Use tertiary comparison level testing ....\n");
1091
1092     CollationKey key1;
1093     col->getCollationKey(test1, u_strlen(test1), key1, status);
1094
1095     CollationKey key2;
1096     col->getCollationKey(test2, u_strlen(test2), key2, status);
1097
1098     CollationKey key3;
1099     col->getCollationKey(test3, u_strlen(test3), key3, status);
1100
1101     doAssert(key1.compareTo(key2) == Collator::GREATER,
1102         "Result should be \"Abcda\" > \"abcda\"");
1103     doAssert(key2.compareTo(key1) == Collator::LESS,
1104         "Result should be \"abcda\" < \"Abcda\"");
1105     doAssert(key2.compareTo(key3) == Collator::EQUAL,
1106         "Result should be \"abcda\" ==  \"abcda\"");
1107
1108     // Clone the key2 sortkey for later.
1109     int32_t keylength = 0;
1110     const uint8_t *key2primary_alias = key2.getByteArray(keylength);
1111     LocalArray<uint8_t> key2primary(new uint8_t[keylength]);
1112     memcpy(key2primary.getAlias(), key2primary_alias, keylength);
1113
1114     col->getSortKey(test1, sortkey1, 64);
1115     col->getSortKey(test2, sortkey2, 64);
1116     col->getSortKey(test3, sortkey3, 64);
1117
1118     const uint8_t *tempkey = key1.getByteArray(keylength);
1119     doAssert(memcmp(tempkey, sortkey1, keylength) == 0,
1120         "Test1 string should have the same collation key and sort key");
1121     tempkey = key2.getByteArray(keylength);
1122     doAssert(memcmp(tempkey, sortkey2, keylength) == 0,
1123         "Test2 string should have the same collation key and sort key");
1124     tempkey = key3.getByteArray(keylength);
1125     doAssert(memcmp(tempkey, sortkey3, keylength) == 0,
1126         "Test3 string should have the same collation key and sort key");
1127
1128     col->getSortKey(test1, 5, sortkey1, 64);
1129     col->getSortKey(test2, 5, sortkey2, 64);
1130     col->getSortKey(test3, 5, sortkey3, 64);
1131
1132     tempkey = key1.getByteArray(keylength);
1133     doAssert(memcmp(tempkey, sortkey1, keylength) == 0,
1134         "Test1 string should have the same collation key and sort key");
1135     tempkey = key2.getByteArray(keylength);
1136     doAssert(memcmp(tempkey, sortkey2, keylength) == 0,
1137         "Test2 string should have the same collation key and sort key");
1138     tempkey = key3.getByteArray(keylength);
1139     doAssert(memcmp(tempkey, sortkey3, keylength) == 0,
1140         "Test3 string should have the same collation key and sort key");
1141
1142     UnicodeString strtest1(test1);
1143     col->getSortKey(strtest1, sortkey1, 64);
1144     UnicodeString strtest2(test2);
1145     col->getSortKey(strtest2, sortkey2, 64);
1146     UnicodeString strtest3(test3);
1147     col->getSortKey(strtest3, sortkey3, 64);
1148
1149     tempkey = key1.getByteArray(keylength);
1150     doAssert(memcmp(tempkey, sortkey1, keylength) == 0,
1151         "Test1 string should have the same collation key and sort key");
1152     tempkey = key2.getByteArray(keylength);
1153     doAssert(memcmp(tempkey, sortkey2, keylength) == 0,
1154         "Test2 string should have the same collation key and sort key");
1155     tempkey = key3.getByteArray(keylength);
1156     doAssert(memcmp(tempkey, sortkey3, keylength) == 0,
1157         "Test3 string should have the same collation key and sort key");
1158
1159     logln("Use secondary comparision level testing ...\n");
1160     col->setStrength(Collator::SECONDARY);
1161
1162     col->getCollationKey(test1, u_strlen(test1), key1, status);
1163     col->getCollationKey(test2, u_strlen(test2), key2, status);
1164     col->getCollationKey(test3, u_strlen(test3), key3, status);
1165
1166     doAssert(key1.compareTo(key2) == Collator::EQUAL,
1167         "Result should be \"Abcda\" == \"abcda\"");
1168     doAssert(key2.compareTo(key3) == Collator::EQUAL,
1169         "Result should be \"abcda\" ==  \"abcda\"");
1170
1171     tempkey = key2.getByteArray(keylength);
1172     doAssert(memcmp(tempkey, key2primary.getAlias(), keylength - 1) == 0,
1173              "Binary format for 'abcda' sortkey different for secondary strength!");
1174
1175     col->getSortKey(test1, sortkey1, 64);
1176     col->getSortKey(test2, sortkey2, 64);
1177     col->getSortKey(test3, sortkey3, 64);
1178
1179     tempkey = key1.getByteArray(keylength);
1180     doAssert(memcmp(tempkey, sortkey1, keylength) == 0,
1181         "Test1 string should have the same collation key and sort key");
1182     tempkey = key2.getByteArray(keylength);
1183     doAssert(memcmp(tempkey, sortkey2, keylength) == 0,
1184         "Test2 string should have the same collation key and sort key");
1185     tempkey = key3.getByteArray(keylength);
1186     doAssert(memcmp(tempkey, sortkey3, keylength) == 0,
1187         "Test3 string should have the same collation key and sort key");
1188
1189     col->getSortKey(test1, 5, sortkey1, 64);
1190     col->getSortKey(test2, 5, sortkey2, 64);
1191     col->getSortKey(test3, 5, sortkey3, 64);
1192
1193     tempkey = key1.getByteArray(keylength);
1194     doAssert(memcmp(tempkey, sortkey1, keylength) == 0,
1195         "Test1 string should have the same collation key and sort key");
1196     tempkey = key2.getByteArray(keylength);
1197     doAssert(memcmp(tempkey, sortkey2, keylength) == 0,
1198         "Test2 string should have the same collation key and sort key");
1199     tempkey = key3.getByteArray(keylength);
1200     doAssert(memcmp(tempkey, sortkey3, keylength) == 0,
1201         "Test3 string should have the same collation key and sort key");
1202
1203     col->getSortKey(strtest1, sortkey1, 64);
1204     col->getSortKey(strtest2, sortkey2, 64);
1205     col->getSortKey(strtest3, sortkey3, 64);
1206
1207     tempkey = key1.getByteArray(keylength);
1208     doAssert(memcmp(tempkey, sortkey1, keylength) == 0,
1209         "Test1 string should have the same collation key and sort key");
1210     tempkey = key2.getByteArray(keylength);
1211     doAssert(memcmp(tempkey, sortkey2, keylength) == 0,
1212         "Test2 string should have the same collation key and sort key");
1213     tempkey = key3.getByteArray(keylength);
1214     doAssert(memcmp(tempkey, sortkey3, keylength) == 0,
1215         "Test3 string should have the same collation key and sort key");
1216
1217     logln("testing sortkey ends...");
1218     delete col;
1219 }
1220
1221 void CollationAPITest::TestSortKeyOverflow() {
1222     IcuTestErrorCode errorCode(*this, "TestSortKeyOverflow()");
1223     LocalPointer<Collator> col(Collator::createInstance(Locale::getEnglish(), errorCode));
1224     if (errorCode.logDataIfFailureAndReset("Collator::createInstance(English) failed")) {
1225         return;
1226     }
1227     col->setAttribute(UCOL_STRENGTH, UCOL_PRIMARY, errorCode);
1228     UChar i_and_phi[] = { 0x438, 0x3c6 };  // Cyrillic small i & Greek small phi.
1229     // The sort key should be 6 bytes:
1230     // 2 bytes for the Cyrillic i, 1 byte for the primary-compression terminator,
1231     // 2 bytes for the Greek phi, and 1 byte for the NUL terminator.
1232     uint8_t sortKey[12];
1233     int32_t length = col->getSortKey(i_and_phi, 2, sortKey, UPRV_LENGTHOF(sortKey));
1234     uint8_t sortKey2[12];
1235     for (int32_t capacity = 0; capacity < length; ++capacity) {
1236         uprv_memset(sortKey2, 2, UPRV_LENGTHOF(sortKey2));
1237         int32_t length2 = col->getSortKey(i_and_phi, 2, sortKey2, capacity);
1238         if (length2 != length || 0 != uprv_memcmp(sortKey, sortKey2, capacity)) {
1239             errln("getSortKey(i_and_phi, capacity=%d) failed to write proper prefix", capacity);
1240         } else if (sortKey2[capacity] != 2 || sortKey2[capacity + 1] != 2) {
1241             errln("getSortKey(i_and_phi, capacity=%d) wrote beyond capacity", capacity);
1242         }
1243     }
1244
1245     // Now try to break getCollationKey().
1246     // Internally, it always starts with a large stack buffer.
1247     // Since we cannot control the initial capacity, we throw an increasing number
1248     // of characters at it, with the problematic part at the end.
1249     const int32_t longCapacity = 2000;
1250     // Each 'a' in the prefix should result in one primary sort key byte.
1251     // For i_and_phi we expect 6 bytes, then the NUL terminator.
1252     const int32_t maxPrefixLength = longCapacity - 6 - 1;
1253     LocalArray<uint8_t> longSortKey(new uint8_t[longCapacity]);
1254     UnicodeString s(FALSE, i_and_phi, 2);
1255     for (int32_t prefixLength = 0; prefixLength < maxPrefixLength; ++prefixLength) {
1256         length = col->getSortKey(s, longSortKey.getAlias(), longCapacity);
1257         CollationKey collKey;
1258         col->getCollationKey(s, collKey, errorCode);
1259         int32_t collKeyLength;
1260         const uint8_t *collSortKey = collKey.getByteArray(collKeyLength);
1261         if (collKeyLength != length || 0 != uprv_memcmp(longSortKey.getAlias(), collSortKey, length)) {
1262             errln("getCollationKey(prefix[%d]+i_and_phi) failed to write proper sort key", prefixLength);
1263         }
1264
1265         // Insert an 'a' to match ++prefixLength.
1266         s.insert(prefixLength, (UChar)0x61);
1267     }
1268 }
1269
1270 void CollationAPITest::TestMaxExpansion()
1271 {
1272     UErrorCode          status = U_ZERO_ERROR;
1273     UChar               ch     = 0;
1274     UChar32             unassigned = 0xEFFFD;
1275     uint32_t            sorder = 0;
1276     uint32_t            temporder = 0;
1277
1278     UnicodeString rule("&a < ab < c/aba < d < z < ch");
1279     RuleBasedCollator coll(rule, status);
1280     if(U_FAILURE(status)) {
1281       errcheckln(status, "Collator creation failed with error %s", u_errorName(status));
1282       return;
1283     }
1284     UnicodeString str(ch);
1285     CollationElementIterator *iter =
1286                                   coll.createCollationElementIterator(str);
1287
1288     while (ch < 0xFFFF && U_SUCCESS(status)) {
1289         int      count = 1;
1290         uint32_t order;
1291         int32_t  size = 0;
1292
1293         ch ++;
1294
1295         str.setCharAt(0, ch);
1296         iter->setText(str, status);
1297         order = iter->previous(status);
1298
1299         /* thai management */
1300         if (order == 0)
1301             order = iter->previous(status);
1302
1303         while (U_SUCCESS(status) && iter->previous(status) != CollationElementIterator::NULLORDER) {
1304             count ++;
1305         }
1306
1307         size = coll.getMaxExpansion(order);
1308         if (U_FAILURE(status) || size < count) {
1309             errln("Failure at codepoint U+%04X, maximum expansion count %d < %d",
1310                   ch, size, count);
1311         }
1312     }
1313
1314     /* testing for exact max expansion */
1315     int32_t size;
1316     ch = 0;
1317     while (ch < 0x61) {
1318         uint32_t order;
1319         str.setCharAt(0, ch);
1320         iter->setText(str, status);
1321         order = iter->previous(status);
1322         size  = coll.getMaxExpansion(order);
1323         if (U_FAILURE(status) || size != 1) {
1324             errln("Failure at codepoint U+%04X, maximum expansion count %d < %d",
1325                   ch, size, 1);
1326         }
1327         ch ++;
1328     }
1329
1330     ch = 0x63;
1331     str.setTo(ch);
1332     iter->setText(str, status);
1333     temporder = iter->previous(status);
1334     size = coll.getMaxExpansion(temporder);
1335     if (U_FAILURE(status) || size != 3) {
1336         errln("Failure at codepoint U+%04X, CE %08x, maximum expansion count %d != %d",
1337               ch, temporder, size, 3);
1338     }
1339
1340     ch = 0x64;
1341     str.setTo(ch);
1342     iter->setText(str, status);
1343     temporder = iter->previous(status);
1344     size = coll.getMaxExpansion(temporder);
1345     if (U_FAILURE(status) || size != 1) {
1346         errln("Failure at codepoint U+%04X, CE %08x, maximum expansion count %d != %d",
1347               ch, temporder, size, 1);
1348     }
1349
1350     str.setTo(unassigned);
1351     iter->setText(str, status);
1352     sorder = iter->previous(status);
1353     size = coll.getMaxExpansion(sorder);
1354     if (U_FAILURE(status) || size != 2) {
1355         errln("Failure at supplementary codepoints, maximum expansion count %d < %d",
1356               size, 2);
1357     }
1358
1359     /* testing jamo */
1360     ch = 0x1165;
1361     str.setTo(ch);
1362     iter->setText(str, status);
1363     temporder = iter->previous(status);
1364     size = coll.getMaxExpansion(temporder);
1365     if (U_FAILURE(status) || size > 3) {
1366         errln("Failure at codepoint U+%04X, maximum expansion count %d > %d",
1367               ch, size, 3);
1368     }
1369
1370     delete iter;
1371
1372     /* testing special jamo &a<\u1160 */
1373     rule = CharsToUnicodeString("\\u0026\\u0071\\u003c\\u1165\\u002f\\u0071\\u0071\\u0071\\u0071");
1374
1375     RuleBasedCollator jamocoll(rule, status);
1376     iter = jamocoll.createCollationElementIterator(str);
1377     temporder = iter->previous(status);
1378     size = iter->getMaxExpansion(temporder);
1379     if (U_FAILURE(status) || size != 6) {
1380         errln("Failure at codepoint U+%04X, maximum expansion count %d > %d",
1381               ch, size, 5);
1382     }
1383
1384     delete iter;
1385 }
1386
1387 void CollationAPITest::TestDisplayName()
1388 {
1389     UErrorCode error = U_ZERO_ERROR;
1390     Collator *coll = Collator::createInstance("en_US", error);
1391     if (U_FAILURE(error)) {
1392         errcheckln(error, "Failure creating english collator - %s", u_errorName(error));
1393         return;
1394     }
1395     UnicodeString name;
1396     UnicodeString result;
1397     coll->getDisplayName(Locale::getCanadaFrench(), result);
1398     Locale::getCanadaFrench().getDisplayName(name);
1399     if (result.compare(name)) {
1400         errln("Failure getting the correct name for locale en_US");
1401     }
1402
1403     coll->getDisplayName(Locale::getSimplifiedChinese(), result);
1404     Locale::getSimplifiedChinese().getDisplayName(name);
1405     if (result.compare(name)) {
1406         errln("Failure getting the correct name for locale zh_SG");
1407     }
1408     delete coll;
1409 }
1410
1411 void CollationAPITest::TestAttribute()
1412 {
1413     UErrorCode error = U_ZERO_ERROR;
1414     Collator *coll = Collator::createInstance(error);
1415
1416     if (U_FAILURE(error)) {
1417         errcheckln(error, "Creation of default collator failed - %s", u_errorName(error));
1418         return;
1419     }
1420
1421     coll->setAttribute(UCOL_FRENCH_COLLATION, UCOL_OFF, error);
1422     if (coll->getAttribute(UCOL_FRENCH_COLLATION, error) != UCOL_OFF ||
1423         U_FAILURE(error)) {
1424         errln("Setting and retrieving of the french collation failed");
1425     }
1426
1427     coll->setAttribute(UCOL_FRENCH_COLLATION, UCOL_ON, error);
1428     if (coll->getAttribute(UCOL_FRENCH_COLLATION, error) != UCOL_ON ||
1429         U_FAILURE(error)) {
1430         errln("Setting and retrieving of the french collation failed");
1431     }
1432
1433     coll->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, error);
1434     if (coll->getAttribute(UCOL_ALTERNATE_HANDLING, error) != UCOL_SHIFTED ||
1435         U_FAILURE(error)) {
1436         errln("Setting and retrieving of the alternate handling failed");
1437     }
1438
1439     coll->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_NON_IGNORABLE, error);
1440     if (coll->getAttribute(UCOL_ALTERNATE_HANDLING, error) != UCOL_NON_IGNORABLE ||
1441         U_FAILURE(error)) {
1442         errln("Setting and retrieving of the alternate handling failed");
1443     }
1444
1445     coll->setAttribute(UCOL_CASE_FIRST, UCOL_LOWER_FIRST, error);
1446     if (coll->getAttribute(UCOL_CASE_FIRST, error) != UCOL_LOWER_FIRST ||
1447         U_FAILURE(error)) {
1448         errln("Setting and retrieving of the case first attribute failed");
1449     }
1450
1451     coll->setAttribute(UCOL_CASE_FIRST, UCOL_UPPER_FIRST, error);
1452     if (coll->getAttribute(UCOL_CASE_FIRST, error) != UCOL_UPPER_FIRST ||
1453         U_FAILURE(error)) {
1454         errln("Setting and retrieving of the case first attribute failed");
1455     }
1456
1457     coll->setAttribute(UCOL_CASE_LEVEL, UCOL_ON, error);
1458     if (coll->getAttribute(UCOL_CASE_LEVEL, error) != UCOL_ON ||
1459         U_FAILURE(error)) {
1460         errln("Setting and retrieving of the case level attribute failed");
1461     }
1462
1463     coll->setAttribute(UCOL_CASE_LEVEL, UCOL_OFF, error);
1464     if (coll->getAttribute(UCOL_CASE_LEVEL, error) != UCOL_OFF ||
1465         U_FAILURE(error)) {
1466         errln("Setting and retrieving of the case level attribute failed");
1467     }
1468
1469     coll->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, error);
1470     if (coll->getAttribute(UCOL_NORMALIZATION_MODE, error) != UCOL_ON ||
1471         U_FAILURE(error)) {
1472         errln("Setting and retrieving of the normalization on/off attribute failed");
1473     }
1474
1475     coll->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_OFF, error);
1476     if (coll->getAttribute(UCOL_NORMALIZATION_MODE, error) != UCOL_OFF ||
1477         U_FAILURE(error)) {
1478         errln("Setting and retrieving of the normalization on/off attribute failed");
1479     }
1480
1481     coll->setAttribute(UCOL_STRENGTH, UCOL_PRIMARY, error);
1482     if (coll->getAttribute(UCOL_STRENGTH, error) != UCOL_PRIMARY ||
1483         U_FAILURE(error)) {
1484         errln("Setting and retrieving of the collation strength failed");
1485     }
1486
1487     coll->setAttribute(UCOL_STRENGTH, UCOL_SECONDARY, error);
1488     if (coll->getAttribute(UCOL_STRENGTH, error) != UCOL_SECONDARY ||
1489         U_FAILURE(error)) {
1490         errln("Setting and retrieving of the collation strength failed");
1491     }
1492
1493     coll->setAttribute(UCOL_STRENGTH, UCOL_TERTIARY, error);
1494     if (coll->getAttribute(UCOL_STRENGTH, error) != UCOL_TERTIARY ||
1495         U_FAILURE(error)) {
1496         errln("Setting and retrieving of the collation strength failed");
1497     }
1498
1499     coll->setAttribute(UCOL_STRENGTH, UCOL_QUATERNARY, error);
1500     if (coll->getAttribute(UCOL_STRENGTH, error) != UCOL_QUATERNARY ||
1501         U_FAILURE(error)) {
1502         errln("Setting and retrieving of the collation strength failed");
1503     }
1504
1505     coll->setAttribute(UCOL_STRENGTH, UCOL_IDENTICAL, error);
1506     if (coll->getAttribute(UCOL_STRENGTH, error) != UCOL_IDENTICAL ||
1507         U_FAILURE(error)) {
1508         errln("Setting and retrieving of the collation strength failed");
1509     }
1510
1511     delete coll;
1512 }
1513
1514 void CollationAPITest::TestVariableTopSetting() {
1515   UErrorCode status = U_ZERO_ERROR;
1516
1517   UChar vt[256] = { 0 };
1518
1519   // Use the root collator, not the default collator.
1520   // This test fails with en_US_POSIX which tailors the dollar sign after 'A'.
1521   Collator *coll = Collator::createInstance(Locale::getRoot(), status);
1522   if(U_FAILURE(status)) {
1523     delete coll;
1524     errcheckln(status, "Collator creation failed with error %s", u_errorName(status));
1525     return;
1526   }
1527
1528   uint32_t oldVarTop = coll->getVariableTop(status);
1529
1530   // ICU 53+: The character must be in a supported reordering group,
1531   // and the variable top is pinned to the end of that group.
1532   vt[0] = 0x0041;
1533
1534   (void)coll->setVariableTop(vt, 1, status);
1535   if(status != U_ILLEGAL_ARGUMENT_ERROR) {
1536     errln("setVariableTop(letter) did not detect illegal argument - %s", u_errorName(status));
1537   }
1538
1539   status = U_ZERO_ERROR;
1540   vt[0] = 0x24;  // dollar sign (currency symbol)
1541   uint32_t newVarTop = coll->setVariableTop(vt, 1, status);
1542   if(U_FAILURE(status)) {
1543     errln("setVariableTop(dollar sign) failed: %s", u_errorName(status));
1544     return;
1545   }
1546   if(newVarTop != coll->getVariableTop(status)) {
1547     errln("setVariableTop(dollar sign) != following getVariableTop()");
1548   }
1549
1550   UnicodeString dollar((UChar)0x24);
1551   UnicodeString euro((UChar)0x20AC);
1552   uint32_t newVarTop2 = coll->setVariableTop(euro, status);
1553   assertEquals("setVariableTop(Euro sign) == following getVariableTop()",
1554                (int64_t)newVarTop2, (int64_t)coll->getVariableTop(status));
1555   assertEquals("setVariableTop(Euro sign) == setVariableTop(dollar sign) (should pin to top of currency group)",
1556                (int64_t)newVarTop2, (int64_t)newVarTop);
1557
1558   coll->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, status);
1559   assertEquals("empty==dollar", (int32_t)UCOL_EQUAL, (int32_t)coll->compare(UnicodeString(), dollar));
1560   assertEquals("empty==euro", (int32_t)UCOL_EQUAL, (int32_t)coll->compare(UnicodeString(), euro));
1561   assertEquals("dollar<zero", (int32_t)UCOL_LESS, (int32_t)coll->compare(dollar, UnicodeString((UChar)0x30)));
1562
1563   coll->setVariableTop(oldVarTop, status);
1564
1565   uint32_t newerVarTop = coll->setVariableTop(UnicodeString(vt, 1), status);
1566
1567   if(newVarTop != newerVarTop) {
1568     errln("Didn't set vartop properly from UnicodeString!\n");
1569   }
1570
1571   delete coll;
1572
1573 }
1574
1575 void CollationAPITest::TestMaxVariable() {
1576   UErrorCode errorCode = U_ZERO_ERROR;
1577   LocalPointer<Collator> coll(Collator::createInstance(Locale::getRoot(), errorCode));
1578   if(U_FAILURE(errorCode)) {
1579     errcheckln(errorCode, "Collator creation failed with error %s", u_errorName(errorCode));
1580     return;
1581   }
1582
1583   (void)coll->setMaxVariable(UCOL_REORDER_CODE_OTHERS, errorCode);
1584   if(errorCode != U_ILLEGAL_ARGUMENT_ERROR) {
1585     errln("setMaxVariable(others) did not detect illegal argument - %s", u_errorName(errorCode));
1586   }
1587
1588   errorCode = U_ZERO_ERROR;
1589   (void)coll->setMaxVariable(UCOL_REORDER_CODE_CURRENCY, errorCode);
1590
1591   if(UCOL_REORDER_CODE_CURRENCY != coll->getMaxVariable()) {
1592     errln("setMaxVariable(currency) != following getMaxVariable()");
1593   }
1594
1595   coll->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, errorCode);
1596   assertEquals("empty==dollar", (int32_t)UCOL_EQUAL, (int32_t)coll->compare(UnicodeString(), UnicodeString((UChar)0x24)));
1597   assertEquals("empty==euro", (int32_t)UCOL_EQUAL, (int32_t)coll->compare(UnicodeString(), UnicodeString((UChar)0x20AC)));
1598   assertEquals("dollar<zero", (int32_t)UCOL_LESS, (int32_t)coll->compare(UnicodeString((UChar)0x24), UnicodeString((UChar)0x30)));
1599 }
1600
1601 void CollationAPITest::TestGetLocale() {
1602   UErrorCode status = U_ZERO_ERROR;
1603   const char *rules = "&a<x<y<z";
1604   UChar rlz[256] = {0};
1605
1606   Collator *coll = Collator::createInstance("root", status);
1607   if(U_FAILURE(status)) {
1608     dataerrln("Failed to open collator for \"root\" with %s", u_errorName(status));
1609     return;
1610   }
1611   Locale locale = coll->getLocale(ULOC_ACTUAL_LOCALE, status);
1612   if(locale != Locale::getRoot()) {
1613     errln("Collator::createInstance(\"root\").getLocale(actual) != Locale::getRoot(); "
1614           "getLocale().getName() = \"%s\"",
1615           locale.getName());
1616   }
1617   delete coll;
1618
1619   coll = Collator::createInstance("", status);
1620   if(U_FAILURE(status)) {
1621     dataerrln("Failed to open collator for \"\" with %s", u_errorName(status));
1622     return;
1623   }
1624   locale = coll->getLocale(ULOC_ACTUAL_LOCALE, status);
1625   if(locale != Locale::getRoot()) {
1626     errln("Collator::createInstance(\"\").getLocale(actual) != Locale::getRoot(); "
1627           "getLocale().getName() = \"%s\"",
1628           locale.getName());
1629   }
1630   delete coll;
1631
1632   int32_t i = 0;
1633
1634   static const struct {
1635     const char* requestedLocale;
1636     const char* validLocale;
1637     const char* actualLocale;
1638   } testStruct[] = {
1639     // Note: Locale::getRoot().getName() == "" not "root".
1640     { "de_DE", "de", "" },
1641     { "sr_RS", "sr_Cyrl_RS", "sr" },
1642     { "en_US_CALIFORNIA", "en_US", "" },
1643     { "fr_FR_NONEXISTANT", "fr", "" },
1644     // pinyin is the default, therefore suppressed.
1645     { "zh_CN", "zh_Hans_CN", "zh" },
1646     // zh_Hant has default=stroke but the data is in zh.
1647     { "zh_TW", "zh_Hant_TW", "zh@collation=stroke" },
1648     { "zh_TW@collation=pinyin", "zh_Hant_TW@collation=pinyin", "zh" },
1649     { "zh_CN@collation=stroke", "zh_Hans_CN@collation=stroke", "zh@collation=stroke" }
1650   };
1651
1652   u_unescape(rules, rlz, 256);
1653
1654   /* test opening collators for different locales */
1655   for(i = 0; i<UPRV_LENGTHOF(testStruct); i++) {
1656     status = U_ZERO_ERROR;
1657     coll = Collator::createInstance(testStruct[i].requestedLocale, status);
1658     if(U_FAILURE(status)) {
1659       errln("Failed to open collator for %s with %s", testStruct[i].requestedLocale, u_errorName(status));
1660       delete coll;
1661       continue;
1662     }
1663     // The requested locale may be the same as the valid locale,
1664     // or may not be supported at all. See ticket #10477.
1665     locale = coll->getLocale(ULOC_REQUESTED_LOCALE, status);
1666     if(U_SUCCESS(status) &&
1667         locale != testStruct[i].requestedLocale && locale != testStruct[i].validLocale) {
1668       errln("[Coll %s]: Error in requested locale, expected %s or %s, got %s",
1669             testStruct[i].requestedLocale,
1670             testStruct[i].requestedLocale, testStruct[i].validLocale, locale.getName());
1671     }
1672     status = U_ZERO_ERROR;
1673     locale = coll->getLocale(ULOC_VALID_LOCALE, status);
1674     if(locale != testStruct[i].validLocale) {
1675       errln("[Coll %s]: Error in valid locale, expected %s, got %s",
1676             testStruct[i].requestedLocale, testStruct[i].validLocale, locale.getName());
1677     }
1678     locale = coll->getLocale(ULOC_ACTUAL_LOCALE, status);
1679     if(locale != testStruct[i].actualLocale) {
1680       errln("[Coll %s]: Error in actual locale, expected %s, got %s",
1681             testStruct[i].requestedLocale, testStruct[i].actualLocale, locale.getName());
1682     }
1683     // If we open a collator for the actual locale, we should get an equivalent one again.
1684     LocalPointer<Collator> coll2(Collator::createInstance(locale, status));
1685     if(U_FAILURE(status)) {
1686       errln("Failed to open collator for actual locale \"%s\" with %s",
1687             locale.getName(), u_errorName(status));
1688     } else {
1689       Locale actual2 = coll2->getLocale(ULOC_ACTUAL_LOCALE, status);
1690       if(actual2 != locale) {
1691         errln("[Coll actual \"%s\"]: Error in actual locale, got different one: \"%s\"",
1692               locale.getName(), actual2.getName());
1693       }
1694       if(*coll2 != *coll) {
1695         errln("[Coll actual \"%s\"]: Got different collator than before", locale.getName());
1696       }
1697     }
1698     delete coll;
1699   }
1700
1701   /* completely non-existent locale for collator should get a root collator */
1702   {
1703     LocalPointer<Collator> coll(Collator::createInstance("blahaha", status));
1704     if(U_FAILURE(status)) {
1705       errln("Failed to open collator with %s", u_errorName(status));
1706       return;
1707     }
1708     Locale valid = coll->getLocale(ULOC_VALID_LOCALE, status);
1709     const char *name = valid.getName();
1710     if(*name != 0 && strcmp(name, "root") != 0) {
1711       errln("Valid locale for nonexisting-locale collator is \"%s\" not root", name);
1712     }
1713     Locale actual = coll->getLocale(ULOC_ACTUAL_LOCALE, status);
1714     name = actual.getName();
1715     if(*name != 0 && strcmp(name, "root") != 0) {
1716       errln("Actual locale for nonexisting-locale collator is \"%s\" not root", name);
1717     }
1718   }
1719
1720
1721
1722   /* collator instantiated from rules should have all three locales NULL */
1723   coll = new RuleBasedCollator(rlz, status);
1724   locale = coll->getLocale(ULOC_REQUESTED_LOCALE, status);
1725   if(U_SUCCESS(status) && !locale.isBogus()) {
1726     errln("For collator instantiated from rules, requested locale %s is not bogus", locale.getName());
1727   }
1728   status = U_ZERO_ERROR;
1729   locale = coll->getLocale(ULOC_VALID_LOCALE, status);
1730   if(!locale.isBogus()) {
1731     errln("For collator instantiated from rules, valid locale %s is not bogus", locale.getName());
1732   }
1733   locale = coll->getLocale(ULOC_ACTUAL_LOCALE, status);
1734   if(!locale.isBogus()) {
1735     errln("For collator instantiated from rules, actual locale %s is not bogus", locale.getName());
1736   }
1737   delete coll;
1738 }
1739
1740 struct teststruct {
1741     const char *original;
1742     uint8_t key[256];
1743 };
1744
1745
1746
1747 U_CDECL_BEGIN
1748 static int U_CALLCONV
1749 compare_teststruct(const void *string1, const void *string2) {
1750   return(strcmp((const char *)((struct teststruct *)string1)->key, (const char *)((struct teststruct *)string2)->key));
1751 }
1752 U_CDECL_END
1753
1754
1755 void CollationAPITest::TestBounds(void) {
1756     UErrorCode status = U_ZERO_ERROR;
1757
1758     Collator *coll = Collator::createInstance(Locale("sh"), status);
1759     if(U_FAILURE(status)) {
1760       delete coll;
1761       errcheckln(status, "Collator creation failed with %s", u_errorName(status));
1762       return;
1763     }
1764
1765     uint8_t sortkey[512], lower[512], upper[512];
1766     UChar buffer[512];
1767
1768     static const char * const test[] = {
1769         "John Smith",
1770         "JOHN SMITH",
1771         "john SMITH",
1772         "j\\u00F6hn sm\\u00EFth",
1773         "J\\u00F6hn Sm\\u00EFth",
1774         "J\\u00D6HN SM\\u00CFTH",
1775         "john smithsonian",
1776         "John Smithsonian"
1777     };
1778
1779     struct teststruct tests[] = {
1780         {"\\u010CAKI MIHALJ", {0}},
1781         {"\\u010CAKI MIHALJ", {0}},
1782         {"\\u010CAKI PIRO\\u0160KA", {0}},
1783         {"\\u010CABAI ANDRIJA", {0}},
1784         {"\\u010CABAI LAJO\\u0160", {0}},
1785         {"\\u010CABAI MARIJA", {0}},
1786         {"\\u010CABAI STEVAN", {0}},
1787         {"\\u010CABAI STEVAN", {0}},
1788         {"\\u010CABARKAPA BRANKO", {0}},
1789         {"\\u010CABARKAPA MILENKO", {0}},
1790         {"\\u010CABARKAPA MIROSLAV", {0}},
1791         {"\\u010CABARKAPA SIMO", {0}},
1792         {"\\u010CABARKAPA STANKO", {0}},
1793         {"\\u010CABARKAPA TAMARA", {0}},
1794         {"\\u010CABARKAPA TOMA\\u0160", {0}},
1795         {"\\u010CABDARI\\u0106 NIKOLA", {0}},
1796         {"\\u010CABDARI\\u0106 ZORICA", {0}},
1797         {"\\u010CABI NANDOR", {0}},
1798         {"\\u010CABOVI\\u0106 MILAN", {0}},
1799         {"\\u010CABRADI AGNEZIJA", {0}},
1800         {"\\u010CABRADI IVAN", {0}},
1801         {"\\u010CABRADI JELENA", {0}},
1802         {"\\u010CABRADI LJUBICA", {0}},
1803         {"\\u010CABRADI STEVAN", {0}},
1804         {"\\u010CABRDA MARTIN", {0}},
1805         {"\\u010CABRILO BOGDAN", {0}},
1806         {"\\u010CABRILO BRANISLAV", {0}},
1807         {"\\u010CABRILO LAZAR", {0}},
1808         {"\\u010CABRILO LJUBICA", {0}},
1809         {"\\u010CABRILO SPASOJA", {0}},
1810         {"\\u010CADE\\u0160 ZDENKA", {0}},
1811         {"\\u010CADESKI BLAGOJE", {0}},
1812         {"\\u010CADOVSKI VLADIMIR", {0}},
1813         {"\\u010CAGLJEVI\\u0106 TOMA", {0}},
1814         {"\\u010CAGOROVI\\u0106 VLADIMIR", {0}},
1815         {"\\u010CAJA VANKA", {0}},
1816         {"\\u010CAJI\\u0106 BOGOLJUB", {0}},
1817         {"\\u010CAJI\\u0106 BORISLAV", {0}},
1818         {"\\u010CAJI\\u0106 RADOSLAV", {0}},
1819         {"\\u010CAK\\u0160IRAN MILADIN", {0}},
1820         {"\\u010CAKAN EUGEN", {0}},
1821         {"\\u010CAKAN EVGENIJE", {0}},
1822         {"\\u010CAKAN IVAN", {0}},
1823         {"\\u010CAKAN JULIJAN", {0}},
1824         {"\\u010CAKAN MIHAJLO", {0}},
1825         {"\\u010CAKAN STEVAN", {0}},
1826         {"\\u010CAKAN VLADIMIR", {0}},
1827         {"\\u010CAKAN VLADIMIR", {0}},
1828         {"\\u010CAKAN VLADIMIR", {0}},
1829         {"\\u010CAKARA ANA", {0}},
1830         {"\\u010CAKAREVI\\u0106 MOMIR", {0}},
1831         {"\\u010CAKAREVI\\u0106 NEDELJKO", {0}},
1832         {"\\u010CAKI \\u0160ANDOR", {0}},
1833         {"\\u010CAKI AMALIJA", {0}},
1834         {"\\u010CAKI ANDRA\\u0160", {0}},
1835         {"\\u010CAKI LADISLAV", {0}},
1836         {"\\u010CAKI LAJO\\u0160", {0}},
1837         {"\\u010CAKI LASLO", {0}}
1838     };
1839
1840
1841
1842     int32_t i = 0, j = 0, k = 0, buffSize = 0, skSize = 0, lowerSize = 0, upperSize = 0;
1843     int32_t arraySize = UPRV_LENGTHOF(tests);
1844
1845     (void)lowerSize;  // Suppress unused variable warnings.
1846     (void)upperSize;
1847
1848     for(i = 0; i<arraySize; i++) {
1849         buffSize = u_unescape(tests[i].original, buffer, 512);
1850         skSize = coll->getSortKey(buffer, buffSize, tests[i].key, 512);
1851     }
1852
1853     qsort(tests, arraySize, sizeof(struct teststruct), compare_teststruct);
1854
1855     for(i = 0; i < arraySize-1; i++) {
1856         for(j = i+1; j < arraySize; j++) {
1857             lowerSize = coll->getBound(tests[i].key, -1, UCOL_BOUND_LOWER, 1, lower, 512, status);
1858             upperSize = coll->getBound(tests[j].key, -1, UCOL_BOUND_UPPER, 1, upper, 512, status);
1859             for(k = i; k <= j; k++) {
1860                 if(strcmp((const char *)lower, (const char *)tests[k].key) > 0) {
1861                     errln("Problem with lower! j = %i (%s vs %s)", k, tests[k].original, tests[i].original);
1862                 }
1863                 if(strcmp((const char *)upper, (const char *)tests[k].key) <= 0) {
1864                     errln("Problem with upper! j = %i (%s vs %s)", k, tests[k].original, tests[j].original);
1865                 }
1866             }
1867         }
1868     }
1869
1870
1871     for(i = 0; i<UPRV_LENGTHOF(test); i++) {
1872         buffSize = u_unescape(test[i], buffer, 512);
1873         skSize = coll->getSortKey(buffer, buffSize, sortkey, 512);
1874         lowerSize = ucol_getBound(sortkey, skSize, UCOL_BOUND_LOWER, 1, lower, 512, &status);
1875         upperSize = ucol_getBound(sortkey, skSize, UCOL_BOUND_UPPER_LONG, 1, upper, 512, &status);
1876         for(j = i+1; j<UPRV_LENGTHOF(test); j++) {
1877             buffSize = u_unescape(test[j], buffer, 512);
1878             skSize = coll->getSortKey(buffer, buffSize, sortkey, 512);
1879             if(strcmp((const char *)lower, (const char *)sortkey) > 0) {
1880                 errln("Problem with lower! i = %i, j = %i (%s vs %s)", i, j, test[i], test[j]);
1881             }
1882             if(strcmp((const char *)upper, (const char *)sortkey) <= 0) {
1883                 errln("Problem with upper! i = %i, j = %i (%s vs %s)", i, j, test[i], test[j]);
1884             }
1885         }
1886     }
1887     delete coll;
1888 }
1889
1890
1891 void CollationAPITest::TestGetTailoredSet()
1892 {
1893   struct {
1894     const char *rules;
1895     const char *tests[20];
1896     int32_t testsize;
1897   } setTest[] = {
1898     { "&a < \\u212b", { "\\u212b", "A\\u030a", "\\u00c5" }, 3},
1899     { "& S < \\u0161 <<< \\u0160", { "\\u0161", "s\\u030C", "\\u0160", "S\\u030C" }, 4}
1900   };
1901
1902   int32_t i = 0, j = 0;
1903   UErrorCode status = U_ZERO_ERROR;
1904
1905   UnicodeString buff;
1906   UnicodeSet *set = NULL;
1907
1908   for(i = 0; i < UPRV_LENGTHOF(setTest); i++) {
1909     buff = UnicodeString(setTest[i].rules, -1, US_INV).unescape();
1910     RuleBasedCollator coll(buff, status);
1911     if(U_SUCCESS(status)) {
1912       set = coll.getTailoredSet(status);
1913       if(set->size() < setTest[i].testsize) {
1914         errln("Tailored set size smaller (%d) than expected (%d)", set->size(), setTest[i].testsize);
1915       }
1916       for(j = 0; j < setTest[i].testsize; j++) {
1917         buff = UnicodeString(setTest[i].tests[j], -1, US_INV).unescape();
1918         if(!set->contains(buff)) {
1919           errln("Tailored set doesn't contain %s... It should", setTest[i].tests[j]);
1920         }
1921       }
1922       delete set;
1923     } else {
1924       errcheckln(status, "Couldn't open collator with rules %s - %s", setTest[i].rules, u_errorName(status));
1925     }
1926   }
1927 }
1928
1929 void CollationAPITest::TestUClassID()
1930 {
1931     char id = *((char *)RuleBasedCollator::getStaticClassID());
1932     if (id != 0) {
1933         errln("Static class id for RuleBasedCollator should be 0");
1934     }
1935     UErrorCode status = U_ZERO_ERROR;
1936     RuleBasedCollator *coll
1937         = (RuleBasedCollator *)Collator::createInstance(status);
1938     if(U_FAILURE(status)) {
1939       delete coll;
1940       errcheckln(status, "Collator creation failed with %s", u_errorName(status));
1941       return;
1942     }
1943     id = *((char *)coll->getDynamicClassID());
1944     if (id != 0) {
1945         errln("Dynamic class id for RuleBasedCollator should be 0");
1946     }
1947     id = *((char *)CollationKey::getStaticClassID());
1948     if (id != 0) {
1949         errln("Static class id for CollationKey should be 0");
1950     }
1951     CollationKey *key = new CollationKey();
1952     id = *((char *)key->getDynamicClassID());
1953     if (id != 0) {
1954         errln("Dynamic class id for CollationKey should be 0");
1955     }
1956     id = *((char *)CollationElementIterator::getStaticClassID());
1957     if (id != 0) {
1958         errln("Static class id for CollationElementIterator should be 0");
1959     }
1960     UnicodeString str("testing");
1961     CollationElementIterator *iter = coll->createCollationElementIterator(str);
1962     id = *((char *)iter->getDynamicClassID());
1963     if (id != 0) {
1964         errln("Dynamic class id for CollationElementIterator should be 0");
1965     }
1966     delete key;
1967     delete iter;
1968     delete coll;
1969 }
1970
1971 class TestCollator  : public Collator
1972 {
1973 public:
1974     virtual Collator* clone(void) const;
1975
1976     using Collator::compare;
1977
1978     virtual UCollationResult compare(const UnicodeString& source,
1979                                       const UnicodeString& target,
1980                                       UErrorCode& status) const;
1981     virtual UCollationResult compare(const UnicodeString& source,
1982                                       const UnicodeString& target,
1983                                       int32_t length,
1984                                       UErrorCode& status) const;
1985     virtual UCollationResult compare(const UChar* source,
1986                                       int32_t sourceLength,
1987                                       const UChar* target,
1988                                       int32_t targetLength,
1989                                       UErrorCode& status) const;
1990     virtual CollationKey& getCollationKey(const UnicodeString&  source,
1991                                           CollationKey& key,
1992                                           UErrorCode& status) const;
1993     virtual CollationKey& getCollationKey(const UChar*source,
1994                                           int32_t sourceLength,
1995                                           CollationKey& key,
1996                                           UErrorCode& status) const;
1997     virtual int32_t hashCode(void) const;
1998     virtual Locale getLocale(ULocDataLocaleType type, UErrorCode& status) const;
1999     virtual ECollationStrength getStrength(void) const;
2000     virtual void setStrength(ECollationStrength newStrength);
2001     virtual UClassID getDynamicClassID(void) const;
2002     virtual void getVersion(UVersionInfo info) const;
2003     virtual void setAttribute(UColAttribute attr, UColAttributeValue value,
2004                               UErrorCode &status);
2005     virtual UColAttributeValue getAttribute(UColAttribute attr,
2006                                             UErrorCode &status) const;
2007     virtual uint32_t setVariableTop(const UChar *varTop, int32_t len,
2008                                     UErrorCode &status);
2009     virtual uint32_t setVariableTop(const UnicodeString &varTop,
2010                                     UErrorCode &status);
2011     virtual void setVariableTop(uint32_t varTop, UErrorCode &status);
2012     virtual uint32_t getVariableTop(UErrorCode &status) const;
2013     virtual int32_t getSortKey(const UnicodeString& source,
2014                             uint8_t* result,
2015                             int32_t resultLength) const;
2016     virtual int32_t getSortKey(const UChar*source, int32_t sourceLength,
2017                              uint8_t*result, int32_t resultLength) const;
2018     virtual UnicodeSet *getTailoredSet(UErrorCode &status) const;
2019     virtual UBool operator==(const Collator& other) const;
2020     // Collator::operator!= calls !Collator::operator== which works for all subclasses.
2021     virtual void setLocales(const Locale& requestedLocale, const Locale& validLocale, const Locale& actualLocale);
2022     TestCollator() : Collator() {};
2023     TestCollator(UCollationStrength collationStrength,
2024            UNormalizationMode decompositionMode) : Collator(collationStrength, decompositionMode) {};
2025 };
2026
2027 inline UBool TestCollator::operator==(const Collator& other) const {
2028     // TestCollator has no fields, so we test for identity.
2029     return this == &other;
2030
2031     // Normally, subclasses should do something like the following:
2032     //    if (this == &other) { return TRUE; }
2033     //    if (!Collator::operator==(other)) { return FALSE; }  // not the same class
2034     //
2035     //    const TestCollator &o = (const TestCollator&)other;
2036     //    (compare this vs. o's subclass fields)
2037 }
2038
2039 Collator* TestCollator::clone() const
2040 {
2041     return new TestCollator();
2042 }
2043
2044 UCollationResult TestCollator::compare(const UnicodeString& source,
2045                                         const UnicodeString& target,
2046                                         UErrorCode& status) const
2047 {
2048   if(U_SUCCESS(status)) {
2049     return UCollationResult(source.compare(target));
2050   } else {
2051     return UCOL_EQUAL;
2052   }
2053 }
2054
2055 UCollationResult TestCollator::compare(const UnicodeString& source,
2056                                         const UnicodeString& target,
2057                                         int32_t length,
2058                                         UErrorCode& status) const
2059 {
2060   if(U_SUCCESS(status)) {
2061     return UCollationResult(source.compare(0, length, target));
2062   } else {
2063     return UCOL_EQUAL;
2064   }
2065 }
2066
2067 UCollationResult TestCollator::compare(const UChar* source,
2068                                         int32_t sourceLength,
2069                                         const UChar* target,
2070                                         int32_t targetLength,
2071                                         UErrorCode& status) const
2072 {
2073     UnicodeString s(source, sourceLength);
2074     UnicodeString t(target, targetLength);
2075     return compare(s, t, status);
2076 }
2077
2078 CollationKey& TestCollator::getCollationKey(const UnicodeString& source,
2079                                             CollationKey& key,
2080                                             UErrorCode& status) const
2081 {
2082     char temp[100];
2083     int length = 100;
2084     length = source.extract(temp, length, NULL, status);
2085     temp[length] = 0;
2086     CollationKey tempkey((uint8_t*)temp, length);
2087     key = tempkey;
2088     return key;
2089 }
2090
2091 CollationKey& TestCollator::getCollationKey(const UChar*source,
2092                                           int32_t sourceLength,
2093                                           CollationKey& key,
2094                                           UErrorCode& status) const
2095 {
2096     //s tack allocation used since collationkey does not keep the unicodestring
2097     UnicodeString str(source, sourceLength);
2098     return getCollationKey(str, key, status);
2099 }
2100
2101 int32_t TestCollator::getSortKey(const UnicodeString& source, uint8_t* result,
2102                                  int32_t resultLength) const
2103 {
2104     UErrorCode status = U_ZERO_ERROR;
2105     int32_t length = source.extract((char *)result, resultLength, NULL,
2106                                     status);
2107     result[length] = 0;
2108     return length;
2109 }
2110
2111 int32_t TestCollator::getSortKey(const UChar*source, int32_t sourceLength,
2112                                  uint8_t*result, int32_t resultLength) const
2113 {
2114     UnicodeString str(source, sourceLength);
2115     return getSortKey(str, result, resultLength);
2116 }
2117
2118 int32_t TestCollator::hashCode() const
2119 {
2120     return 0;
2121 }
2122
2123 Locale TestCollator::getLocale(ULocDataLocaleType type, UErrorCode& status) const
2124 {
2125     // api not used, this is to make the compiler happy
2126     if (U_FAILURE(status)) {
2127         (void)type;
2128     }
2129     return NULL;
2130 }
2131
2132 Collator::ECollationStrength TestCollator::getStrength() const
2133 {
2134     return TERTIARY;
2135 }
2136
2137 void TestCollator::setStrength(Collator::ECollationStrength newStrength)
2138 {
2139     // api not used, this is to make the compiler happy
2140     (void)newStrength;
2141 }
2142
2143 UClassID TestCollator::getDynamicClassID(void) const
2144 {
2145     return 0;
2146 }
2147
2148 void TestCollator::getVersion(UVersionInfo info) const
2149 {
2150     // api not used, this is to make the compiler happy
2151     memset(info, 0, U_MAX_VERSION_LENGTH);
2152 }
2153
2154 void TestCollator::setAttribute(UColAttribute /*attr*/, UColAttributeValue /*value*/,
2155                                 UErrorCode & /*status*/)
2156 {
2157 }
2158
2159 UColAttributeValue TestCollator::getAttribute(UColAttribute attr,
2160                                               UErrorCode &status) const
2161 {
2162     // api not used, this is to make the compiler happy
2163     if (U_FAILURE(status) || attr == UCOL_ATTRIBUTE_COUNT) {
2164         return UCOL_OFF;
2165     }
2166     return UCOL_DEFAULT;
2167 }
2168
2169 uint32_t TestCollator::setVariableTop(const UChar *varTop, int32_t len,
2170                                   UErrorCode &status)
2171 {
2172     // api not used, this is to make the compiler happy
2173     if (U_SUCCESS(status) && (varTop == 0 || len < -1)) {
2174         status = U_ILLEGAL_ARGUMENT_ERROR;
2175     }
2176     return 0;
2177 }
2178
2179 uint32_t TestCollator::setVariableTop(const UnicodeString &varTop,
2180                                   UErrorCode &status)
2181 {
2182     // api not used, this is to make the compiler happy
2183     if (U_SUCCESS(status) && varTop.length() == 0) {
2184         status = U_ILLEGAL_ARGUMENT_ERROR;
2185     }
2186     return 0;
2187 }
2188
2189 void TestCollator::setVariableTop(uint32_t varTop, UErrorCode &status)
2190 {
2191     // api not used, this is to make the compiler happy
2192     if (U_SUCCESS(status) && varTop == 0) {
2193         status = U_ILLEGAL_ARGUMENT_ERROR;
2194     }
2195 }
2196
2197 uint32_t TestCollator::getVariableTop(UErrorCode &status) const
2198 {
2199
2200     // api not used, this is to make the compiler happy
2201     if (U_SUCCESS(status)) {
2202         return 0;
2203     }
2204     return (uint32_t)(0xFFFFFFFFu);
2205 }
2206
2207 UnicodeSet * TestCollator::getTailoredSet(UErrorCode &status) const
2208 {
2209     return Collator::getTailoredSet(status);
2210 }
2211
2212 void TestCollator::setLocales(const Locale& requestedLocale, const Locale& validLocale, const Locale& actualLocale)
2213 {
2214     Collator::setLocales(requestedLocale, validLocale, actualLocale);
2215 }
2216
2217
2218 void CollationAPITest::TestSubclass()
2219 {
2220     TestCollator col1;
2221     TestCollator col2;
2222     doAssert(col1 != col2, "2 instances of TestCollator should be different");
2223     if (col1.hashCode() != col2.hashCode()) {
2224         errln("Every TestCollator has the same hashcode");
2225     }
2226     UnicodeString abc("abc", 3);
2227     UnicodeString bcd("bcd", 3);
2228     if (col1.compare(abc, bcd) != abc.compare(bcd)) {
2229         errln("TestCollator compare should be the same as the default "
2230               "string comparison");
2231     }
2232     CollationKey key;
2233     UErrorCode status = U_ZERO_ERROR;
2234     col1.getCollationKey(abc, key, status);
2235     int32_t length = 0;
2236     const char* bytes = (const char *)key.getByteArray(length);
2237     UnicodeString keyarray(bytes, length, NULL, status);
2238     if (abc != keyarray) {
2239         errln("TestCollator collationkey API is returning wrong values");
2240     }
2241
2242     UnicodeSet expectedset(0, 0x10FFFF);
2243     UnicodeSet *defaultset = col1.getTailoredSet(status);
2244     if (!defaultset->containsAll(expectedset)
2245         || !expectedset.containsAll(*defaultset)) {
2246         errln("Error: expected default tailoring to be 0 to 0x10ffff");
2247     }
2248     delete defaultset;
2249
2250     // use base class implementation
2251     Locale loc1 = Locale::getGermany();
2252     Locale loc2 = Locale::getFrance();
2253     col1.setLocales(loc1, loc2, loc2); // default implementation has no effect
2254
2255     UnicodeString displayName;
2256     col1.getDisplayName(loc1, loc2, displayName); // de_DE collator in fr_FR locale
2257
2258     TestCollator col3(UCOL_TERTIARY, UNORM_NONE);
2259     UnicodeString a("a");
2260     UnicodeString b("b");
2261     Collator::EComparisonResult result = Collator::EComparisonResult(a.compare(b));
2262     if(col1.compare(a, b) != result) {
2263       errln("Collator doesn't give default result");
2264     }
2265     if(col1.compare(a, b, 1) != result) {
2266       errln("Collator doesn't give default result");
2267     }
2268     if(col1.compare(a.getBuffer(), a.length(), b.getBuffer(), b.length()) != result) {
2269       errln("Collator doesn't give default result");
2270     }
2271 }
2272
2273 void CollationAPITest::TestNULLCharTailoring()
2274 {
2275     UErrorCode status = U_ZERO_ERROR;
2276     UChar buf[256] = {0};
2277     int32_t len = u_unescape("&a < '\\u0000'", buf, 256);
2278     UnicodeString first((UChar)0x0061);
2279     UnicodeString second((UChar)0);
2280     RuleBasedCollator *coll = new RuleBasedCollator(UnicodeString(buf, len), status);
2281     if(U_FAILURE(status)) {
2282         delete coll;
2283         errcheckln(status, "Failed to open collator - %s", u_errorName(status));
2284         return;
2285     }
2286     UCollationResult res = coll->compare(first, second, status);
2287     if(res != UCOL_LESS) {
2288         errln("a should be less then NULL after tailoring");
2289     }
2290     delete coll;
2291 }
2292
2293 void CollationAPITest::TestClone() {
2294     logln("\ninit c0");
2295     UErrorCode status = U_ZERO_ERROR;
2296     RuleBasedCollator* c0 = (RuleBasedCollator*)Collator::createInstance(status);
2297
2298     if (U_FAILURE(status)) {
2299         errcheckln(status, "Collator::CreateInstance(status) failed with %s", u_errorName(status));
2300         return;
2301     }
2302
2303     c0->setStrength(Collator::TERTIARY);
2304     dump("c0", c0, status);
2305
2306     logln("\ninit c1");
2307     RuleBasedCollator* c1 = (RuleBasedCollator*)Collator::createInstance(status);
2308     c1->setStrength(Collator::TERTIARY);
2309     UColAttributeValue val = c1->getAttribute(UCOL_CASE_FIRST, status);
2310     if(val == UCOL_LOWER_FIRST){
2311         c1->setAttribute(UCOL_CASE_FIRST, UCOL_UPPER_FIRST, status);
2312     }else{
2313         c1->setAttribute(UCOL_CASE_FIRST, UCOL_LOWER_FIRST, status);
2314     }
2315     dump("c0", c0, status);
2316     dump("c1", c1, status);
2317
2318     logln("\ninit c2");
2319     RuleBasedCollator* c2 = (RuleBasedCollator*)c1->clone();
2320     val = c2->getAttribute(UCOL_CASE_FIRST, status);
2321     if(val == UCOL_LOWER_FIRST){
2322         c2->setAttribute(UCOL_CASE_FIRST, UCOL_UPPER_FIRST, status);
2323     }else{
2324         c2->setAttribute(UCOL_CASE_FIRST, UCOL_LOWER_FIRST, status);
2325     }
2326     if(U_FAILURE(status)){
2327         errln("set and get attributes of collator failed. %s\n", u_errorName(status));
2328         return;
2329     }
2330     dump("c0", c0, status);
2331     dump("c1", c1, status);
2332     dump("c2", c2, status);
2333     if(*c1 == *c2){
2334         errln("The cloned objects refer to same data");
2335     }
2336     delete c0;
2337     delete c1;
2338     delete c2;
2339 }
2340
2341 void CollationAPITest::TestCloneBinary() {
2342     IcuTestErrorCode errorCode(*this, "TestCloneBinary");
2343     LocalPointer<Collator> root(Collator::createInstance(Locale::getRoot(), errorCode));
2344     LocalPointer<Collator> coll(Collator::createInstance("de@collation=phonebook", errorCode));
2345     if(errorCode.logDataIfFailureAndReset("Collator::createInstance(de@collation=phonebook)")) {
2346         return;
2347     }
2348     RuleBasedCollator *rbRoot = dynamic_cast<RuleBasedCollator *>(root.getAlias());
2349     RuleBasedCollator *rbc = dynamic_cast<RuleBasedCollator *>(coll.getAlias());
2350     if(rbRoot == NULL || rbc == NULL) {
2351         infoln("root or de@collation=phonebook is not a RuleBasedCollator");
2352         return;
2353     }
2354     rbc->setAttribute(UCOL_STRENGTH, UCOL_PRIMARY, errorCode);
2355     UnicodeString uUmlaut((UChar)0xfc);
2356     UnicodeString ue = UNICODE_STRING_SIMPLE("ue");
2357     assertEquals("rbc/primary: u-umlaut==ue", (int32_t)UCOL_EQUAL, rbc->compare(uUmlaut, ue, errorCode));
2358     uint8_t bin[25000];
2359     int32_t binLength = rbc->cloneBinary(bin, UPRV_LENGTHOF(bin), errorCode);
2360     if(errorCode.logDataIfFailureAndReset("rbc->cloneBinary()")) {
2361         return;
2362     }
2363     logln("rbc->cloneBinary() -> %d bytes", (int)binLength);
2364
2365     RuleBasedCollator rbc2(bin, binLength, rbRoot, errorCode);
2366     if(errorCode.logDataIfFailureAndReset("RuleBasedCollator(rbc binary)")) {
2367         return;
2368     }
2369     assertEquals("rbc2.strength==primary", (int32_t)UCOL_PRIMARY, rbc2.getAttribute(UCOL_STRENGTH, errorCode));
2370     assertEquals("rbc2: u-umlaut==ue", (int32_t)UCOL_EQUAL, rbc2.compare(uUmlaut, ue, errorCode));
2371     assertTrue("rbc==rbc2", *rbc == rbc2);
2372     uint8_t bin2[25000];
2373     int32_t bin2Length = rbc2.cloneBinary(bin2, UPRV_LENGTHOF(bin2), errorCode);
2374     assertEquals("len(rbc binary)==len(rbc2 binary)", binLength, bin2Length);
2375     assertTrue("rbc binary==rbc2 binary", binLength == bin2Length && memcmp(bin, bin2, binLength) == 0);
2376
2377     RuleBasedCollator rbc3(bin, -1, rbRoot, errorCode);
2378     if(errorCode.logDataIfFailureAndReset("RuleBasedCollator(rbc binary, length<0)")) {
2379         return;
2380     }
2381     assertEquals("rbc3.strength==primary", (int32_t)UCOL_PRIMARY, rbc3.getAttribute(UCOL_STRENGTH, errorCode));
2382     assertEquals("rbc3: u-umlaut==ue", (int32_t)UCOL_EQUAL, rbc3.compare(uUmlaut, ue, errorCode));
2383     assertTrue("rbc==rbc3", *rbc == rbc3);
2384 }
2385
2386 void CollationAPITest::TestIterNumeric() {
2387     // Regression test for ticket #9915.
2388     // The collation code sometimes masked the continuation marker away
2389     // but later tested the result for isContinuation().
2390     // This test case failed because the third bytes of the computed numeric-collation primaries
2391     // were permutated with the script reordering table.
2392     // It should have been possible to reproduce this with the root collator
2393     // and characters with appropriate 3-byte primary weights.
2394     // The effectiveness of this test depends completely on the collation elements
2395     // and on the implementation code.
2396     IcuTestErrorCode errorCode(*this, "TestIterNumeric");
2397     RuleBasedCollator coll(UnicodeString("[reorder Hang Hani]"), errorCode);
2398     if(errorCode.logDataIfFailureAndReset("RuleBasedCollator constructor")) {
2399         return;
2400     }
2401     coll.setAttribute(UCOL_NUMERIC_COLLATION, UCOL_ON, errorCode);
2402     UCharIterator iter40, iter72;
2403     uiter_setUTF8(&iter40, "\x34\x30", 2);
2404     uiter_setUTF8(&iter72, "\x37\x32", 2);
2405     UCollationResult result = coll.compare(iter40, iter72, errorCode);
2406     assertEquals("40<72", (int32_t)UCOL_LESS, (int32_t)result);
2407 }
2408
2409 void CollationAPITest::TestBadKeywords() {
2410     // Test locale IDs with errors.
2411     // Valid locale IDs are tested via data-driven tests.
2412     UErrorCode errorCode = U_ZERO_ERROR;
2413     Locale bogusLocale(Locale::getRoot());
2414     bogusLocale.setToBogus();
2415     LocalPointer<Collator> coll(Collator::createInstance(bogusLocale, errorCode));
2416     if(errorCode != U_ILLEGAL_ARGUMENT_ERROR) {
2417         errln("Collator::createInstance(bogus locale) did not fail as expected - %s",
2418               u_errorName(errorCode));
2419     }
2420
2421     // Unknown value.
2422     const char *localeID = "it-u-ks-xyz";
2423     errorCode = U_ZERO_ERROR;
2424     coll.adoptInstead(Collator::createInstance(localeID, errorCode));
2425     if(errorCode != U_ILLEGAL_ARGUMENT_ERROR) {
2426         dataerrln("Collator::createInstance(%s) did not fail as expected - %s",
2427               localeID, u_errorName(errorCode));
2428     }
2429
2430     // Unsupported attributes.
2431     localeID = "it@colHiraganaQuaternary=true";
2432     errorCode = U_ZERO_ERROR;
2433     coll.adoptInstead(Collator::createInstance(localeID, errorCode));
2434     if(errorCode != U_UNSUPPORTED_ERROR) {
2435         if (errorCode == U_FILE_ACCESS_ERROR) {
2436             dataerrln("Collator::createInstance(it@colHiraganaQuaternary=true) : %s", u_errorName(errorCode));
2437         } else {
2438             errln("Collator::createInstance(%s) did not fail as expected - %s",
2439                   localeID, u_errorName(errorCode));
2440         }
2441     }
2442
2443     localeID = "it-u-vt-u24";
2444     errorCode = U_ZERO_ERROR;
2445     coll.adoptInstead(Collator::createInstance(localeID, errorCode));
2446     if(errorCode != U_UNSUPPORTED_ERROR) {
2447         if (errorCode == U_ILLEGAL_ARGUMENT_ERROR || errorCode == U_FILE_ACCESS_ERROR) {
2448             dataerrln("Collator::createInstance(it-u-vt-u24) : %s", u_errorName(errorCode));
2449         } else {
2450            errln("Collator::createInstance(%s) did not fail as expected - %s",
2451                   localeID, u_errorName(errorCode));
2452         }
2453     }
2454 }
2455
2456  void CollationAPITest::dump(UnicodeString msg, RuleBasedCollator* c, UErrorCode& status) {
2457     const char* bigone = "One";
2458     const char* littleone = "one";
2459
2460     logln(msg + " " + c->compare(bigone, littleone) +
2461                         " s: " + c->getStrength() +
2462                         " u: " + c->getAttribute(UCOL_CASE_FIRST, status));
2463 }
2464 void CollationAPITest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par */)
2465 {
2466     if (exec) logln("TestSuite CollationAPITest: ");
2467     TESTCASE_AUTO_BEGIN;
2468     TESTCASE_AUTO(TestProperty);
2469     TESTCASE_AUTO(TestOperators);
2470     TESTCASE_AUTO(TestDuplicate);
2471     TESTCASE_AUTO(TestCompare);
2472     TESTCASE_AUTO(TestHashCode);
2473     TESTCASE_AUTO(TestCollationKey);
2474     TESTCASE_AUTO(TestElemIter);
2475     TESTCASE_AUTO(TestGetAll);
2476     TESTCASE_AUTO(TestRuleBasedColl);
2477     TESTCASE_AUTO(TestDecomposition);
2478     TESTCASE_AUTO(TestSafeClone);
2479     TESTCASE_AUTO(TestSortKey);
2480     TESTCASE_AUTO(TestSortKeyOverflow);
2481     TESTCASE_AUTO(TestMaxExpansion);
2482     TESTCASE_AUTO(TestDisplayName);
2483     TESTCASE_AUTO(TestAttribute);
2484     TESTCASE_AUTO(TestVariableTopSetting);
2485     TESTCASE_AUTO(TestMaxVariable);
2486     TESTCASE_AUTO(TestRules);
2487     TESTCASE_AUTO(TestGetLocale);
2488     TESTCASE_AUTO(TestBounds);
2489     TESTCASE_AUTO(TestGetTailoredSet);
2490     TESTCASE_AUTO(TestUClassID);
2491     TESTCASE_AUTO(TestSubclass);
2492     TESTCASE_AUTO(TestNULLCharTailoring);
2493     TESTCASE_AUTO(TestClone);
2494     TESTCASE_AUTO(TestCloneBinary);
2495     TESTCASE_AUTO(TestIterNumeric);
2496     TESTCASE_AUTO(TestBadKeywords);
2497     TESTCASE_AUTO_END;
2498 }
2499
2500 #endif /* #if !UCONFIG_NO_COLLATION */