Update ICU to 54.1 step 1

source/test/intltest/apicoll.cpp

 /********************************************************************
  * COPYRIGHT:
- * Copyright (c) 1997-2013, International Business Machines Corporation and
+ * Copyright (c) 1997-2014, International Business Machines Corporation and
  * others. All Rights Reserved.
  ********************************************************************/
 //===============================================================================
 //
-// File apitest.cpp
+// File apicoll.cpp
 //
 //
 //
 // Created by: Helena Shih
 //
 // Modification History:
 //
 //  Date         Name          Description
 //  2/5/97      aliu        Added streamIn and streamOut methods.  Added
 //                          constructor which reads RuleBasedCollator object from
@@ skipping 20 matching lines @@
 #include "apicoll.h"
 #include "unicode/chariter.h"
 #include "unicode/schriter.h"
 #include "unicode/ustring.h"
 #include "unicode/ucol.h"
 
 #include "sfwdchit.h"
 #include "cmemory.h"
 #include <stdlib.h>
 
-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
-
 void
 CollationAPITest::doAssert(UBool condition, const char *message)
 {
     if (!condition) {
         errln(UnicodeString("ERROR : ") + message);
     }
 }
 
-#ifdef U_USE_COLLATION_OBSOLETE_2_6
-/*
- * Test Collator::createInstance(... version...) for some locale. Called by TestProperty().
- */
-static void
-TestOpenVersion(IntlTest &test, const Locale &locale) {
-    UVersionInfo version1, version2;
-    Collator *collator1, *collator2;
-    UErrorCode errorCode;
-
-    errorCode=U_ZERO_ERROR;
-    collator1=Collator::createInstance(locale, errorCode);
-    if(U_SUCCESS(errorCode)) {
-        /* get the current version */
-        collator1->getVersion(version1);
-        delete collator1;
-
-        /* try to get that same version again */
-        collator2=Collator::createInstance(locale, version1, errorCode);
-        if(U_SUCCESS(errorCode)) {
-            collator2->getVersion(version2);
-            if(0!=uprv_memcmp(version1, version2, sizeof(UVersionInfo))) {
-                test.errln("error: Collator::createInstance(\"%s\", (%s collator)->getVersion()) returns a different collator\n", locale.getName(), locale.getName());
-            }
-            delete collator2;
-        } else {
-            test.errln("error: Collator::createInstance(\"%s\", (%s collator)->getVersion()) fails: %s\n", locale.getName(), locale.getName(), u_errorName(errorCode));
-        }
-    }
-}
-#endif
-
 // Collator Class Properties
 // ctor, dtor, createInstance, compare, getStrength/setStrength
 // getDecomposition/setDecomposition, getDisplayName
 void
 CollationAPITest::TestProperty(/* char* par */)
 {
     UErrorCode success = U_ZERO_ERROR;
     Collator *col = 0;
     /*
      * Expected version of the English collator.
@@ skipping 88 matching lines @@
 #if 0
     // weiv : this test is bogus if we're running on any machine that has different default locale than English.
     // Therefore, it is banned!
     logln("Get display name for the US English in default locale language : ");
     logln(Collator::getDisplayName(Locale::US, name));
     doAssert((name == UnicodeString("English (United States)")), "getDisplayName failed if this is an English machine");
 #endif
     delete col; col = 0;
     RuleBasedCollator *rcol = (RuleBasedCollator *)Collator::createInstance("da_DK",
                                                                             success);
-    doAssert(rcol->getRules().length() != 0, "da_DK rules does not have length 0");
+    if (U_FAILURE(success)) {
+        errcheckln(success, "Collator::createInstance(\"da_DK\") failed - %s", u_errorName(success));
+        return;
+    }
+    const UnicodeString &daRules = rcol->getRules();
+    if(daRules.isEmpty()) {
+        dataerrln("missing da_DK tailoring rule string");
+    } else {
+        doAssert(daRules.indexOf("aa") >= 0, "da_DK rules do not contain 'aa'");
+    }
     delete rcol;
 
     col = Collator::createInstance(Locale::getFrench(), success);
     if (U_FAILURE(success))
     {
         errln("Creating French collation failed.");
         return;
     }
 
     col->setStrength(Collator::PRIMARY);
@@ skipping 46 matching lines @@
         doAssert((*frCol != *junk), "The junk is the same as the fr_CA collator.");
     }
     Collator *aFrCol = frCol->clone();
     doAssert((*frCol == *aFrCol), "The cloning of a fr_CA collator failed.");
     logln("Collator property test ended.");
 
     delete col;
     delete frCol;
     delete aFrCol;
     delete junk;
-
-#ifdef U_USE_COLLATION_OBSOLETE_2_6
-    /* test Collator::createInstance(...version...) */
-    TestOpenVersion(*this, "");
-    TestOpenVersion(*this, "da");
-    TestOpenVersion(*this, "fr");
-    TestOpenVersion(*this, "ja");
-
-    /* try some bogus version */
-    versionArray[0]=0;
-    versionArray[1]=0x99;
-    versionArray[2]=0xc7;
-    versionArray[3]=0xfe;
-    col=Collator::createInstance(Locale(), versionArray, success);
-    if(U_SUCCESS(success)) {
-        errln("error: ucol_openVersion(bogus version) succeeded");
-        delete col;
-    }
-#endif
 }
 
 void 
 CollationAPITest::TestRuleBasedColl()
 {
     RuleBasedCollator *col1, *col2, *col3, *col4;
     UErrorCode status = U_ZERO_ERROR;
 
     UnicodeString ruleset1("&9 < a, A < b, B < c, C; ch, cH, Ch, CH < d, D, e, E");
     UnicodeString ruleset2("&9 < a, A < b, B < c, C < d, D, e, E");
@@ skipping 248 matching lines @@
         errcheckln(success, "Default collation creation failed. - %s", u_errorName(success));
         return;
     }
     col->setStrength(Collator::TERTIARY);
 
     CollationKey sortk1, sortk2;
     UnicodeString test1("Abcda"), test2("abcda");
     UErrorCode key1Status = U_ZERO_ERROR, key2Status = U_ZERO_ERROR;
 
     logln("Testing weird arguments");
-    col->getCollationKey(NULL, 0, sortk1, key1Status);
+    // No string vs. empty string vs. completely-ignorable string:
+    // See ICU ticket #10495.
+    CollationKey sortkNone;
+    int32_t length;
+    sortkNone.getByteArray(length);
+    doAssert(!sortkNone.isBogus() && length == 0,
+             "Default-constructed collation key should be empty");
+    CollationKey sortkEmpty;
+    col->getCollationKey(NULL, 0, sortkEmpty, key1Status);
     // key gets reset here
-    int32_t length;
-    sortk1.getByteArray(length);
-    doAssert(sortk1.isBogus() == FALSE && length == 0,
-             "Empty string should return an empty collation key");
+    const uint8_t* byteArrayEmpty = sortkEmpty.getByteArray(length);
+    doAssert(sortkEmpty.isBogus() == FALSE && length == 3 &&
+             byteArrayEmpty[0] == 1 && byteArrayEmpty[1] == 1 && byteArrayEmpty[2] == 0,
+             "Empty string should return a collation key with empty levels");
+    doAssert(sortkNone.compareTo(sortkEmpty) == Collator::LESS,
+             "Expected no collation key < collation key for empty string");
+    doAssert(sortkEmpty.compareTo(sortkNone) == Collator::GREATER,
+             "Expected collation key for empty string > no collation key");
+
+    CollationKey sortkIgnorable;
+    // Most control codes and CGJ are completely ignorable.
+    // A string with only completely ignorables must compare equal to an empty string.
+    col->getCollationKey(UnicodeString((UChar)1).append((UChar)0x34f), sortkIgnorable, key1Status);
+    sortkIgnorable.getByteArray(length);
+    doAssert(!sortkIgnorable.isBogus() && length == 3,
+             "Completely ignorable string should return a collation key with empty levels");
+    doAssert(sortkIgnorable.compareTo(sortkEmpty) == Collator::EQUAL,
+             "Completely ignorable string should compare equal to empty string");
+
     // bogus key returned here
     key1Status = U_ILLEGAL_ARGUMENT_ERROR;
     col->getCollationKey(NULL, 0, sortk1, key1Status);
     doAssert(sortk1.isBogus() && (sortk1.getByteArray(length), length) == 0,
         "Error code should return bogus collation key");
 
     key1Status = U_ZERO_ERROR;
     logln("Use tertiary comparison level testing ....");
 
     col->getCollationKey(test1, sortk1, key1Status);
+    if (U_FAILURE(key1Status)) {
+        errln("getCollationKey(Abcda) failed - %s", u_errorName(key1Status));
+        return;
+    }
     doAssert((sortk1.compareTo(col->getCollationKey(test2, sortk2, key2Status)))
                  == Collator::GREATER,
                 "Result should be \"Abcda\" >>> \"abcda\"");
 
-    CollationKey sortk3(sortk2), sortkNew, sortkEmpty;
-
+    CollationKey sortk3(sortk2), sortkNew;
 
     sortkNew = sortk1;
     doAssert((sortk1 != sortk2), "The sort keys should be different");
     doAssert((sortk1.hashCode() != sortk2.hashCode()), "sort key hashCode() failed");
     doAssert((sortk2 == sortk3), "The sort keys should be the same");
     doAssert((sortk1 == sortkNew), "The sort keys assignment failed");
     doAssert((sortk1.hashCode() == sortkNew.hashCode()), "sort key hashCode() failed");
     doAssert((sortkNew != sortk3), "The sort keys should be different");
     doAssert(sortk1.compareTo(sortk3) == Collator::GREATER, "Result should be \"Abcda\" >>> \"abcda\"");
     doAssert(sortk2.compareTo(sortk3) == Collator::EQUAL, "Result should be \"abcda\" == \"abcda\"");
@@ skipping 246 matching lines @@
 
 
     logln("testing CollationElementIterator ends...");
 }
 
 // Test RuleBasedCollator ctor, dtor, operator==, operator!=, clone, copy, and getRules
 void
 CollationAPITest::TestOperators(/* char* par */)
 {
     UErrorCode success = U_ZERO_ERROR;
-    UnicodeString ruleset1("< a, A < b, B < c, C; ch, cH, Ch, CH < d, D, e, E");
-    UnicodeString ruleset2("< a, A < b, B < c, C < d, D, e, E");
+    UnicodeString ruleset1("&9 < a, A < b, B < c, C; ch, cH, Ch, CH < d, D, e, E");
+    UnicodeString ruleset2("&9 < a, A < b, B < c, C < d, D, e, E");
     RuleBasedCollator *col1 = new RuleBasedCollator(ruleset1, success);
     if (U_FAILURE(success)) {
         errcheckln(success, "RuleBasedCollator creation failed. - %s", u_errorName(success));
         return;
     }
     success = U_ZERO_ERROR;
     RuleBasedCollator *col2 = new RuleBasedCollator(ruleset2, success);
     if (U_FAILURE(success)) {
         errln("The RuleBasedCollator constructor failed when building with the 2nd rule set.");
         return;
@@ skipping 65 matching lines @@
 CollationAPITest::TestDuplicate(/* char* par */)
 {
     UErrorCode status = U_ZERO_ERROR;
     Collator *col1 = Collator::createInstance(Locale::getEnglish(), status);
     if (U_FAILURE(status)) {
         logln("Default collator creation failed.");
         return;
     }
     Collator *col2 = col1->clone();
     doAssert((*col1 == *col2), "Cloned object is not equal to the orginal");
-    UnicodeString *ruleset = new UnicodeString("< a, A < b, B < c, C < d, D, e, E");
-    RuleBasedCollator *col3 = new RuleBasedCollator(*ruleset, status);
+    UnicodeString ruleset("&9 < a, A < b, B < c, C < d, D, e, E");
+    RuleBasedCollator *col3 = new RuleBasedCollator(ruleset, status);
+    if (U_FAILURE(status)) {
+        logln("Collation tailoring failed.");
+        return;
+    }
     doAssert((*col1 != *col3), "Cloned object is equal to some dummy");
     *col3 = *((RuleBasedCollator*)col1);
     doAssert((*col1 == *col3), "Copied object is not equal to the orginal");
 
-    if (U_FAILURE(status)) {
-        logln("Collation tailoring failed.");
-        return;
-    }
-
     UCollationResult res;
     UnicodeString first((UChar)0x0061);
     UnicodeString second((UChar)0x0062);
     UnicodeString copiedEnglishRules(((RuleBasedCollator*)col1)->getRules());
 
     delete col1;
-    delete ruleset;
 
     // Try using the cloned collators after deleting the original data
     res = col2->compare(first, second, status);
     if(res != UCOL_LESS) {
         errln("a should be less then b after tailoring");
     }
     if (((RuleBasedCollator*)col2)->getRules() != copiedEnglishRules) {
         errln(UnicodeString("English rule difference. ")
             + copiedEnglishRules + UnicodeString("\ngetRules=") + ((RuleBasedCollator*)col2)->getRules());
     }
@@ skipping 65 matching lines @@
 
 
 
     logln("The compare tests end.");
     delete col;
 }
 
 void
 CollationAPITest::TestGetAll(/* char* par */)
 {
+    if (logKnownIssue("10774","Side effects from utility/LocaleTest/TestGetLocale")) {
+        return;
+    }
     int32_t count1, count2;
     UErrorCode status = U_ZERO_ERROR;
 
     logln("Trying Collator::getAvailableLocales(int&)");
 
     const Locale* list = Collator::getAvailableLocales(count1);
     for (int32_t i = 0; i < count1; ++i) {
         UnicodeString dispName;
         logln(UnicodeString("Locale name: ")
             + UnicodeString(list[i].getName())
@@ skipping 211 matching lines @@
     LocalPointer<Collator> col(Collator::createInstance(Locale::getEnglish(), errorCode));
     if (errorCode.logDataIfFailureAndReset("Collator::createInstance(English) failed")) {
         return;
     }
     col->setAttribute(UCOL_STRENGTH, UCOL_PRIMARY, errorCode);
     UChar i_and_phi[] = { 0x438, 0x3c6 };  // Cyrillic small i & Greek small phi.
     // The sort key should be 6 bytes:
     // 2 bytes for the Cyrillic i, 1 byte for the primary-compression terminator,
     // 2 bytes for the Greek phi, and 1 byte for the NUL terminator.
     uint8_t sortKey[12];
-    int32_t length = col->getSortKey(i_and_phi, 2, sortKey, LENGTHOF(sortKey));
+    int32_t length = col->getSortKey(i_and_phi, 2, sortKey, UPRV_LENGTHOF(sortKey));
     uint8_t sortKey2[12];
     for (int32_t capacity = 0; capacity < length; ++capacity) {
-        uprv_memset(sortKey2, 2, LENGTHOF(sortKey2));
+        uprv_memset(sortKey2, 2, UPRV_LENGTHOF(sortKey2));
         int32_t length2 = col->getSortKey(i_and_phi, 2, sortKey2, capacity);
         if (length2 != length || 0 != uprv_memcmp(sortKey, sortKey2, capacity)) {
             errln("getSortKey(i_and_phi, capacity=%d) failed to write proper prefix", capacity);
         } else if (sortKey2[capacity] != 2 || sortKey2[capacity + 1] != 2) {
             errln("getSortKey(i_and_phi, capacity=%d) wrote beyond capacity", capacity);
         }
     }
 
     // Now try to break getCollationKey().
     // Internally, it always starts with a large stack buffer.
@@ skipping 46 matching lines @@
         ch ++;
 
         str.setCharAt(0, ch);
         iter->setText(str, status);
         order = iter->previous(status);
 
         /* thai management */
         if (order == 0)
             order = iter->previous(status);
 
-        while (U_SUCCESS(status) && iter->previous(status) != UCOL_NULLORDER) {
+        while (U_SUCCESS(status) && iter->previous(status) != CollationElementIterator::NULLORDER) {
             count ++;
         }
 
         size = coll.getMaxExpansion(order);
         if (U_FAILURE(status) || size < count) {
             errln("Failure at codepoint U+%04X, maximum expansion count %d < %d",
                   ch, size, count);
         }
     }
 
@@ skipping 195 matching lines @@
     }
 
     delete coll;
 }
 
 void CollationAPITest::TestVariableTopSetting() {
   UErrorCode status = U_ZERO_ERROR;
 
   UChar vt[256] = { 0 };
 
-  Collator *coll = Collator::createInstance(status);
+  // Use the root collator, not the default collator.
+  // This test fails with en_US_POSIX which tailors the dollar sign after 'A'.
+  Collator *coll = Collator::createInstance(Locale::getRoot(), status);
   if(U_FAILURE(status)) {
     delete coll;
     errcheckln(status, "Collator creation failed with error %s", u_errorName(status));
     return;
   }
 
   uint32_t oldVarTop = coll->getVariableTop(status);
 
+  // ICU 53+: The character must be in a supported reordering group,
+  // and the variable top is pinned to the end of that group.
   vt[0] = 0x0041;
 
+  (void)coll->setVariableTop(vt, 1, status);
+  if(status != U_ILLEGAL_ARGUMENT_ERROR) {
+    errln("setVariableTop(letter) did not detect illegal argument - %s", u_errorName(status));
+  }
+
+  status = U_ZERO_ERROR;
+  vt[0] = 0x24;  // dollar sign (currency symbol)
   uint32_t newVarTop = coll->setVariableTop(vt, 1, status);
 
-  if((newVarTop & 0xFFFF0000) != (coll->getVariableTop(status) & 0xFFFF0000)) {
-    errln("Didn't set vartop properly\n");
+  if(newVarTop != coll->getVariableTop(status)) {
+    errln("setVariableTop(dollar sign) != following getVariableTop()");
   }
 
+  UnicodeString dollar((UChar)0x24);
+  UnicodeString euro((UChar)0x20AC);
+  uint32_t newVarTop2 = coll->setVariableTop(euro, status);
+  assertEquals("setVariableTop(Euro sign) == following getVariableTop()",
+               (int64_t)newVarTop2, (int64_t)coll->getVariableTop(status));
+  assertEquals("setVariableTop(Euro sign) == setVariableTop(dollar sign) (should pin to top of currency group)",
+               (int64_t)newVarTop2, (int64_t)newVarTop);
+
+  coll->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, status);
+  assertEquals("empty==dollar", UCOL_EQUAL, coll->compare(UnicodeString(), dollar));
+  assertEquals("empty==euro", UCOL_EQUAL, coll->compare(UnicodeString(), euro));
+  assertEquals("dollar<zero", UCOL_LESS, coll->compare(dollar, UnicodeString((UChar)0x30)));
+
   coll->setVariableTop(oldVarTop, status);
 
   uint32_t newerVarTop = coll->setVariableTop(UnicodeString(vt, 1), status);
 
-  if((newVarTop & 0xFFFF0000) != (newerVarTop & 0xFFFF0000)) {
+  if(newVarTop != newerVarTop) {
     errln("Didn't set vartop properly from UnicodeString!\n");
   }
 
   delete coll;
 
 }
 
+void CollationAPITest::TestMaxVariable() {
+  UErrorCode errorCode = U_ZERO_ERROR;
+  LocalPointer<Collator> coll(Collator::createInstance(Locale::getRoot(), errorCode));
+  if(U_FAILURE(errorCode)) {
+    errcheckln(errorCode, "Collator creation failed with error %s", u_errorName(errorCode));
+    return;
+  }
+
+  (void)coll->setMaxVariable(UCOL_REORDER_CODE_OTHERS, errorCode);
+  if(errorCode != U_ILLEGAL_ARGUMENT_ERROR) {
+    errln("setMaxVariable(others) did not detect illegal argument - %s", u_errorName(errorCode));
+  }
+
+  errorCode = U_ZERO_ERROR;
+  (void)coll->setMaxVariable(UCOL_REORDER_CODE_CURRENCY, errorCode);
+
+  if(UCOL_REORDER_CODE_CURRENCY != coll->getMaxVariable()) {
+    errln("setMaxVariable(currency) != following getMaxVariable()");
+  }
+
+  coll->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, errorCode);
+  assertEquals("empty==dollar", UCOL_EQUAL, coll->compare(UnicodeString(), UnicodeString((UChar)0x24)));
+  assertEquals("empty==euro", UCOL_EQUAL, coll->compare(UnicodeString(), UnicodeString((UChar)0x20AC)));
+  assertEquals("dollar<zero", UCOL_LESS, coll->compare(UnicodeString((UChar)0x24), UnicodeString((UChar)0x30)));
+}
+
 void CollationAPITest::TestGetLocale() {
   UErrorCode status = U_ZERO_ERROR;
   const char *rules = "&a<x<y<z";
   UChar rlz[256] = {0};
 
-  Collator *coll = NULL;
-  Locale locale;
+  Collator *coll = Collator::createInstance("root", status);
+  if(U_FAILURE(status)) {
+    dataerrln("Failed to open collator for \"root\" with %s", u_errorName(status));
+    return;
+  }
+  Locale locale = coll->getLocale(ULOC_ACTUAL_LOCALE, status);
+  if(locale != Locale::getRoot()) {
+    errln("Collator::createInstance(\"root\").getLocale(actual) != Locale::getRoot(); "
+          "getLocale().getName() = \"%s\"",
+          locale.getName());
+  }
+  delete coll;
+
+  coll = Collator::createInstance("", status);
+  if(U_FAILURE(status)) {
+    dataerrln("Failed to open collator for \"\" with %s", u_errorName(status));
+    return;
+  }
+  locale = coll->getLocale(ULOC_ACTUAL_LOCALE, status);
+  if(locale != Locale::getRoot()) {
+    errln("Collator::createInstance(\"\").getLocale(actual) != Locale::getRoot(); "
+          "getLocale().getName() = \"%s\"",
+          locale.getName());
+  }
+  delete coll;
 
   int32_t i = 0;
 
   static const struct {
     const char* requestedLocale;
     const char* validLocale;
     const char* actualLocale;
   } testStruct[] = {
-    { "sr_YU", "sr_YU", "root" },
-    { "sh_YU", "sh_YU", "sh" },
-    { "en_US_CALIFORNIA", "en_US", "root" },
-    { "fr_FR_NONEXISTANT", "fr_FR", "fr" }
+    // Note: Locale::getRoot().getName() == "" not "root".
+    { "de_DE", "de", "" },
+    { "sr_RS", "sr_Cyrl_RS", "sr" },
+    { "en_US_CALIFORNIA", "en_US", "" },
+    { "fr_FR_NONEXISTANT", "fr", "" },
+    // pinyin is the default, therefore suppressed.
+    { "zh_CN", "zh_Hans_CN", "zh" },
+    // zh_Hant has default=stroke but the data is in zh.
+    { "zh_TW", "zh_Hant_TW", "zh@collation=stroke" },
+    { "zh_TW@collation=pinyin", "zh_Hant_TW@collation=pinyin", "zh" },
+    { "zh_CN@collation=stroke", "zh_Hans_CN@collation=stroke", "zh@collation=stroke" }
   };
 
   u_unescape(rules, rlz, 256);
 
   /* test opening collators for different locales */
-  for(i = 0; i<(int32_t)(sizeof(testStruct)/sizeof(testStruct[0])); i++) {
+  for(i = 0; i<(int32_t)UPRV_LENGTHOF(testStruct); i++) {
     status = U_ZERO_ERROR;
     coll = Collator::createInstance(testStruct[i].requestedLocale, status);
     if(U_FAILURE(status)) {
-      log("Failed to open collator for %s with %s\n", testStruct[i].requestedLocale, u_errorName(status));
+      errln("Failed to open collator for %s with %s", testStruct[i].requestedLocale, u_errorName(status));
       delete coll;
       continue;
     }
+    // The requested locale may be the same as the valid locale,
+    // or may not be supported at all. See ticket #10477.
     locale = coll->getLocale(ULOC_REQUESTED_LOCALE, status);
-    if(locale != testStruct[i].requestedLocale) {
-      log("[Coll %s]: Error in requested locale, expected %s, got %s\n", testStruct[i].requestedLocale, testStruct[i].requestedLocale, locale.getName());
+    if(U_SUCCESS(status) &&
+        locale != testStruct[i].requestedLocale && locale != testStruct[i].validLocale) {
+      errln("[Coll %s]: Error in requested locale, expected %s or %s, got %s",
+            testStruct[i].requestedLocale,
+            testStruct[i].requestedLocale, testStruct[i].validLocale, locale.getName());
     }
+    status = U_ZERO_ERROR;
     locale = coll->getLocale(ULOC_VALID_LOCALE, status);
     if(locale != testStruct[i].validLocale) {
-      log("[Coll %s]: Error in valid locale, expected %s, got %s\n", testStruct[i].requestedLocale, testStruct[i].validLocale, locale.getName());
+      errln("[Coll %s]: Error in valid locale, expected %s, got %s",
+            testStruct[i].requestedLocale, testStruct[i].validLocale, locale.getName());
     }
     locale = coll->getLocale(ULOC_ACTUAL_LOCALE, status);
     if(locale != testStruct[i].actualLocale) {
-      log("[Coll %s]: Error in actual locale, expected %s, got %s\n", testStruct[i].requestedLocale, testStruct[i].actualLocale, locale.getName());
+      errln("[Coll %s]: Error in actual locale, expected %s, got %s",
+            testStruct[i].requestedLocale, testStruct[i].actualLocale, locale.getName());
+    }
+    // If we open a collator for the actual locale, we should get an equivalent one again.
+    LocalPointer<Collator> coll2(Collator::createInstance(locale, status));
+    if(U_FAILURE(status)) {
+      errln("Failed to open collator for actual locale \"%s\" with %s",
+            locale.getName(), u_errorName(status));
+    } else {
+      Locale actual2 = coll2->getLocale(ULOC_ACTUAL_LOCALE, status);
+      if(actual2 != locale) {
+        errln("[Coll actual \"%s\"]: Error in actual locale, got different one: \"%s\"",
+              locale.getName(), actual2.getName());
+      }
+      if(*coll2 != *coll) {
+        errln("[Coll actual \"%s\"]: Got different collator than before", locale.getName());
+      }
     }
     delete coll;
   }
 
   /* completely non-existant locale for collator should get a default collator */
   {
     Collator *defaultColl = Collator::createInstance((const Locale)NULL, status);
     coll = Collator::createInstance("blahaha", status);
     if(U_FAILURE(status)) {
-      log("Failed to open collator with %s\n", u_errorName(status));
+      errln("Failed to open collator with %s", u_errorName(status));
       delete coll;
       delete defaultColl;
       return;
     }
-    if(coll->getLocale(ULOC_REQUESTED_LOCALE, status) != "blahaha") {
-      log("Nonexisting locale didn't preserve the requested locale\n");
-    }
     if(coll->getLocale(ULOC_VALID_LOCALE, status) !=
       defaultColl->getLocale(ULOC_VALID_LOCALE, status)) {
-      log("Valid locale for nonexisting locale locale collator differs "
-        "from valid locale for default collator\n");
+      errln("Valid locale for nonexisting locale locale collator differs "
+        "from valid locale for default collator");
     }
     if(coll->getLocale(ULOC_ACTUAL_LOCALE, status) !=
       defaultColl->getLocale(ULOC_ACTUAL_LOCALE, status)) {
-      log("Actual locale for nonexisting locale locale collator differs "
-        "from actual locale for default collator\n");
+      errln("Actual locale for nonexisting locale locale collator differs "
+        "from actual locale for default collator");
     }
     delete coll;
     delete defaultColl;
   }
 
 
 
   /* collator instantiated from rules should have all three locales NULL */
   coll = new RuleBasedCollator(rlz, status);
   locale = coll->getLocale(ULOC_REQUESTED_LOCALE, status);
-  if(!locale.isBogus()) {
-    log("For collator instantiated from rules, requested locale %s is not bogus\n", locale.getName());
+  if(U_SUCCESS(status) && !locale.isBogus()) {
+    errln("For collator instantiated from rules, requested locale %s is not bogus", locale.getName());
   }
+  status = U_ZERO_ERROR;
   locale = coll->getLocale(ULOC_VALID_LOCALE, status);
   if(!locale.isBogus()) {
-    log("For collator instantiated from rules, valid locale %s is not bogus\n", locale.getName());
+    errln("For collator instantiated from rules, valid locale %s is not bogus", locale.getName());
   }
   locale = coll->getLocale(ULOC_ACTUAL_LOCALE, status);
   if(!locale.isBogus()) {
-    log("For collator instantiated from rules, actual locale %s is not bogus\n", locale.getName());
+    errln("For collator instantiated from rules, actual locale %s is not bogus", locale.getName());
   }
   delete coll;
 }
 
 struct teststruct {
     const char *original;
     uint8_t key[256];
 };
 
 
@@ skipping 146 matching lines @@
 {
   struct {
     const char *rules;
     const char *tests[20];
     int32_t testsize;
   } setTest[] = {
     { "&a < \\u212b", { "\\u212b", "A\\u030a", "\\u00c5" }, 3},
     { "& S < \\u0161 <<< \\u0160", { "\\u0161", "s\\u030C", "\\u0160", "S\\u030C" }, 4}
   };
 
-  uint32_t i = 0, j = 0;
+  int32_t i = 0, j = 0;
   UErrorCode status = U_ZERO_ERROR;
 
-  RuleBasedCollator *coll = NULL;
   UnicodeString buff; 
   UnicodeSet *set = NULL;
 
-  for(i = 0; i < sizeof(setTest)/sizeof(setTest[0]); i++) {
-    buff = UnicodeString(setTest[i].rules, "").unescape();
-    coll = new RuleBasedCollator(buff, status);
+  for(i = 0; i < UPRV_LENGTHOF(setTest); i++) {
+    buff = UnicodeString(setTest[i].rules, -1, US_INV).unescape();
+    RuleBasedCollator coll(buff, status);
     if(U_SUCCESS(status)) {
-      set = coll->getTailoredSet(status);
-      if(set->size() != setTest[i].testsize) {
-        errln("Tailored set size different (%d) than expected (%d)", set->size(), setTest[i].testsize);
+      set = coll.getTailoredSet(status);
+      if(set->size() < setTest[i].testsize) {
+        errln("Tailored set size smaller (%d) than expected (%d)", set->size(), setTest[i].testsize);
       }
-      for(j = 0; j < (uint32_t)setTest[i].testsize; j++) {
-        buff = UnicodeString(setTest[i].tests[j], "").unescape();
+      for(j = 0; j < setTest[i].testsize; j++) {
+        buff = UnicodeString(setTest[i].tests[j], -1, US_INV).unescape();
         if(!set->contains(buff)) {
           errln("Tailored set doesn't contain %s... It should", setTest[i].tests[j]);
         }
       }
       delete set;
     } else {
       errcheckln(status, "Couldn't open collator with rules %s - %s", setTest[i].rules, u_errorName(status));
     }
-    delete coll;
   }
 }
 
 void CollationAPITest::TestUClassID()
 {
     char id = *((char *)RuleBasedCollator::getStaticClassID());
     if (id != 0) {
         errln("Static class id for RuleBasedCollator should be 0");
     }
     UErrorCode status = U_ZERO_ERROR;
@@ skipping 395 matching lines @@
     dump("c1", c1, status);
     dump("c2", c2, status);
     if(*c1 == *c2){
         errln("The cloned objects refer to same data");
     }
     delete c0;
     delete c1;
     delete c2;
 }
 
+void CollationAPITest::TestCloneBinary() {
+    IcuTestErrorCode errorCode(*this, "TestCloneBinary");
+    LocalPointer<Collator> root(Collator::createInstance(Locale::getRoot(), errorCode));
+    LocalPointer<Collator> coll(Collator::createInstance("de@collation=phonebook", errorCode));
+    if(errorCode.logDataIfFailureAndReset("Collator::createInstance(de@collation=phonebook)")) {
+        return;
+    }
+    RuleBasedCollator *rbRoot = dynamic_cast<RuleBasedCollator *>(root.getAlias());
+    RuleBasedCollator *rbc = dynamic_cast<RuleBasedCollator *>(coll.getAlias());
+    if(rbRoot == NULL || rbc == NULL) {
+        infoln("root or de@collation=phonebook is not a RuleBasedCollator");
+        return;
+    }
+    rbc->setAttribute(UCOL_STRENGTH, UCOL_PRIMARY, errorCode);
+    UnicodeString uUmlaut((UChar)0xfc);
+    UnicodeString ue = UNICODE_STRING_SIMPLE("ue");
+    assertEquals("rbc/primary: u-umlaut==ue", UCOL_EQUAL, rbc->compare(uUmlaut, ue, errorCode));
+    uint8_t bin[25000];
+    int32_t binLength = rbc->cloneBinary(bin, UPRV_LENGTHOF(bin), errorCode);
+    if(errorCode.logDataIfFailureAndReset("rbc->cloneBinary()")) {
+        return;
+    }
+    logln("rbc->cloneBinary() -> %d bytes", (int)binLength);
+
+    RuleBasedCollator rbc2(bin, binLength, rbRoot, errorCode);
+    if(errorCode.logDataIfFailureAndReset("RuleBasedCollator(rbc binary)")) {
+        return;
+    }
+    assertEquals("rbc2.strength==primary", UCOL_PRIMARY, rbc2.getAttribute(UCOL_STRENGTH, errorCode));
+    assertEquals("rbc2: u-umlaut==ue", UCOL_EQUAL, rbc2.compare(uUmlaut, ue, errorCode));
+    assertTrue("rbc==rbc2", *rbc == rbc2);
+    uint8_t bin2[25000];
+    int32_t bin2Length = rbc2.cloneBinary(bin2, UPRV_LENGTHOF(bin2), errorCode);
+    assertEquals("len(rbc binary)==len(rbc2 binary)", binLength, bin2Length);
+    assertTrue("rbc binary==rbc2 binary", binLength == bin2Length && memcmp(bin, bin2, binLength) == 0);
+
+    RuleBasedCollator rbc3(bin, -1, rbRoot, errorCode);
+    if(errorCode.logDataIfFailureAndReset("RuleBasedCollator(rbc binary, length<0)")) {
+        return;
+    }
+    assertEquals("rbc3.strength==primary", UCOL_PRIMARY, rbc3.getAttribute(UCOL_STRENGTH, errorCode));
+    assertEquals("rbc3: u-umlaut==ue", UCOL_EQUAL, rbc3.compare(uUmlaut, ue, errorCode));
+    assertTrue("rbc==rbc3", *rbc == rbc3);
+}
+
 void CollationAPITest::TestIterNumeric() {
     // Regression test for ticket #9915.
     // The collation code sometimes masked the continuation marker away
     // but later tested the result for isContinuation().
     // This test case failed because the third bytes of the computed numeric-collation primaries
     // were permutated with the script reordering table.
     // It should have been possible to reproduce this with the root collator
     // and characters with appropriate 3-byte primary weights.
     // The effectiveness of this test depends completely on the collation elements
     // and on the implementation code.
     IcuTestErrorCode errorCode(*this, "TestIterNumeric");
     RuleBasedCollator coll(UnicodeString("[reorder Hang Hani]"), errorCode);
     if(errorCode.logDataIfFailureAndReset("RuleBasedCollator constructor")) {
         return;
     }
     coll.setAttribute(UCOL_NUMERIC_COLLATION, UCOL_ON, errorCode);
     UCharIterator iter40, iter72;
     uiter_setUTF8(&iter40, "\x34\x30", 2);
     uiter_setUTF8(&iter72, "\x37\x32", 2);
     UCollationResult result = coll.compare(iter40, iter72, errorCode);
     assertEquals("40<72", (int32_t)UCOL_LESS, (int32_t)result);
 }
 
+void CollationAPITest::TestBadKeywords() {
+    // Test locale IDs with errors.
+    // Valid locale IDs are tested via data-driven tests.
+    UErrorCode errorCode = U_ZERO_ERROR;
+    Locale bogusLocale(Locale::getRoot());
+    bogusLocale.setToBogus();
+    LocalPointer<Collator> coll(Collator::createInstance(bogusLocale, errorCode));
+    if(errorCode != U_ILLEGAL_ARGUMENT_ERROR) {
+        errln("Collator::createInstance(bogus locale) did not fail as expected - %s",
+              u_errorName(errorCode));
+    }
+
+    // Unknown value.
+    const char *localeID = "it-u-ks-xyz";
+    errorCode = U_ZERO_ERROR;
+    coll.adoptInstead(Collator::createInstance(localeID, errorCode));
+    if(errorCode != U_ILLEGAL_ARGUMENT_ERROR) {
+        dataerrln("Collator::createInstance(%s) did not fail as expected - %s",
+              localeID, u_errorName(errorCode));
+    }
+
+    // Unsupported attributes.
+    localeID = "it@colHiraganaQuaternary=true";
+    errorCode = U_ZERO_ERROR;
+    coll.adoptInstead(Collator::createInstance(localeID, errorCode));
+    if(errorCode != U_UNSUPPORTED_ERROR) {
+        if (errorCode == U_FILE_ACCESS_ERROR) {
+            dataerrln("Collator::createInstance(it@colHiraganaQuaternary=true) : %s", u_errorName(errorCode));
+        } else {
+            errln("Collator::createInstance(%s) did not fail as expected - %s",
+                  localeID, u_errorName(errorCode));
+        }
+    }
+
+    localeID = "it-u-vt-u24";
+    errorCode = U_ZERO_ERROR;
+    coll.adoptInstead(Collator::createInstance(localeID, errorCode));
+    if(errorCode != U_UNSUPPORTED_ERROR) {
+        if (errorCode == U_ILLEGAL_ARGUMENT_ERROR || errorCode == U_FILE_ACCESS_ERROR) {
+            dataerrln("Collator::createInstance(it-u-vt-u24) : %s", u_errorName(errorCode));
+        } else {
+           errln("Collator::createInstance(%s) did not fail as expected - %s",
+                  localeID, u_errorName(errorCode));
+        }
+    }
+}
+
  void CollationAPITest::dump(UnicodeString msg, RuleBasedCollator* c, UErrorCode& status) {
     const char* bigone = "One";
     const char* littleone = "one";
   
     logln(msg + " " + c->compare(bigone, littleone) +
                         " s: " + c->getStrength() +
                         " u: " + c->getAttribute(UCOL_CASE_FIRST, status));
 }
 void CollationAPITest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par */)
 {
     if (exec) logln("TestSuite CollationAPITest: ");
     TESTCASE_AUTO_BEGIN;
     TESTCASE_AUTO(TestProperty);
     TESTCASE_AUTO(TestOperators);
     TESTCASE_AUTO(TestDuplicate);
     TESTCASE_AUTO(TestCompare);
     TESTCASE_AUTO(TestHashCode);
     TESTCASE_AUTO(TestCollationKey);
     TESTCASE_AUTO(TestElemIter);
     TESTCASE_AUTO(TestGetAll);
     TESTCASE_AUTO(TestRuleBasedColl);
     TESTCASE_AUTO(TestDecomposition);
     TESTCASE_AUTO(TestSafeClone);
     TESTCASE_AUTO(TestSortKey);
     TESTCASE_AUTO(TestSortKeyOverflow);
     TESTCASE_AUTO(TestMaxExpansion);
     TESTCASE_AUTO(TestDisplayName);
     TESTCASE_AUTO(TestAttribute);
     TESTCASE_AUTO(TestVariableTopSetting);
+    TESTCASE_AUTO(TestMaxVariable);
     TESTCASE_AUTO(TestRules);
     TESTCASE_AUTO(TestGetLocale);
     TESTCASE_AUTO(TestBounds);
     TESTCASE_AUTO(TestGetTailoredSet);
     TESTCASE_AUTO(TestUClassID);
     TESTCASE_AUTO(TestSubclass);
     TESTCASE_AUTO(TestNULLCharTailoring);
     TESTCASE_AUTO(TestClone);
+    TESTCASE_AUTO(TestCloneBinary);
     TESTCASE_AUTO(TestIterNumeric);
+    TESTCASE_AUTO(TestBadKeywords);
     TESTCASE_AUTO_END;
 }
 
 #endif /* #if !UCONFIG_NO_COLLATION */