Update ICU to 54.1 step 1

source/test/intltest/svccoll.cpp

 /*
  *******************************************************************************
- * Copyright (C) 2003-2013, International Business Machines Corporation and    *
- * others. All Rights Reserved.                                                *
+ * Copyright (C) 2003-2014, International Business Machines Corporation and
+ * others. All Rights Reserved.
  *******************************************************************************
  */
 
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_COLLATION
 
 #include "svccoll.h"
 #include "unicode/coll.h"
 #include "unicode/strenum.h"
 #include "hash.h"
 #include "uassert.h"
 
-#include "ucol_imp.h" // internal api needed to test ucollator equality
 #include "cstring.h" // internal api used to compare locale strings
 
 void CollationServiceTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /*par */)
 {
     if (exec) logln("TestSuite CollationServiceTest: ");
     switch (index) {
         TESTCASE(0, TestRegister);
         TESTCASE(1, TestRegisterFactory);
         TESTCASE(2, TestSeparateTree);
     default: name = ""; break;
@@ skipping 13 matching lines @@
     Collator* frcol = Collator::createInstance(FR, status);
     Collator* uscol = Collator::createInstance(US, status);
     if(U_FAILURE(status)) {
         errcheckln(status, "Failed to create collators with %s", u_errorName(status));
         delete frcol;
         delete uscol;
         return;
     }
 
     { // try override en_US collator
+        Collator *clone = frcol->clone();
         URegistryKey key = Collator::registerInstance(frcol, US, status);
+        // frcol has been adopted. We must not use it any more, nor rely on its attributes.
+        frcol = NULL;
 
         Collator* ncol = Collator::createInstance(US_FOO, status);
-        if (*frcol != *ncol) {
+        if (*clone != *ncol) {
             errln("register of french collator for en_US failed on request for en_US_FOO");
         }
-        // ensure original collator's params not touched
-        Locale loc = frcol->getLocale(ULOC_REQUESTED_LOCALE, status);
-        if (loc != FR) {
-          errln(UnicodeString("fr collator's requested locale changed to ") + loc.getName());
+        delete clone;
+
+        // The requested locale may be the same as the valid locale,
+        // or may not be supported at all. See ticket #10477.
+        Locale loc = ncol->getLocale(ULOC_REQUESTED_LOCALE, status);
+        if (U_SUCCESS(status) && loc != US_FOO && loc != US) {
+            errln(UnicodeString("requested locale for en_US_FOO is not en_US_FOO nor en_US but ") + loc.getName());
         }
-        loc = frcol->getLocale(ULOC_VALID_LOCALE, status);
-        if (loc != FR) {
-          errln(UnicodeString("fr collator's valid locale changed to ") + loc.getName());
-        }
-
-        loc = ncol->getLocale(ULOC_REQUESTED_LOCALE, status);
-        if (loc != US_FOO) {
-            errln(UnicodeString("requested locale for en_US_FOO is not en_US_FOO but ") + loc.getName());
-        }
+        status = U_ZERO_ERROR;
         loc = ncol->getLocale(ULOC_VALID_LOCALE, status);
         if (loc != US) {
             errln(UnicodeString("valid locale for en_US_FOO is not en_US but ") + loc.getName());
         }
         loc = ncol->getLocale(ULOC_ACTUAL_LOCALE, status);
         if (loc != US) {
             errln(UnicodeString("actual locale for en_US_FOO is not en_US but ") + loc.getName());
         }
         delete ncol; ncol = NULL;
 
         if (!Collator::unregister(key, status)) {
             errln("failed to unregister french collator");
         }
-        // !!! frcol pointer is now invalid !!!
 
         ncol = Collator::createInstance(US, status);
         if (*uscol != *ncol) {
             errln("collator after unregister does not match original");
         }
         delete ncol; ncol = NULL;
     }
 
     // recreate frcol
     frcol = Collator::createInstance(FR, status);
 
     LocalUCollatorPointer frFR(ucol_open("fr_FR", &status));
 
     { // try create collator for new locale
         Locale fu_FU_FOO("fu", "FU", "FOO");
         Locale fu_FU("fu", "FU", "");
 
         Collator* fucol = Collator::createInstance(fu_FU, status);
+        Collator *clone = frcol->clone();
         URegistryKey key = Collator::registerInstance(frcol, fu_FU, status);
+        frcol = NULL;  // frcol has been adopted.
         Collator* ncol = Collator::createInstance(fu_FU_FOO, status);
-        if (*frcol != *ncol) {
+        if (*clone != *ncol) {
             errln("register of fr collator for fu_FU failed");
         }
+        delete clone;
 
         UnicodeString locName = fu_FU.getName();
         StringEnumeration* localeEnum = Collator::getAvailableLocales();
         UBool found = FALSE;
         const UnicodeString* locStr, *ls2;
         for (locStr = localeEnum->snext(status);
         !found && locStr != NULL;
         locStr = localeEnum->snext(status)) {
             //
             if (locName == *locStr) {
@@ skipping 48 matching lines @@
            ((defaultLocale == Locale::getKorean() && defaultLocale == Locale::getJapanese()) && displayName == "fu(FU)") &&
            ((defaultLocale == Locale::getChinese()) && displayName != zh_fuFU)) {
             errln(UnicodeString("found ") + displayName + " for fu_FU");
         }
 
         // test ucol_open
         LocalUCollatorPointer fufu(ucol_open("fu_FU_FOO", &status));
         if (fufu.isNull()) {
             errln("could not open fu_FU_FOO with ucol_open");
         } else {
-            if (!ucol_equals(fufu.getAlias(), frFR.getAlias())) {
+            if (*Collator::fromUCollator(fufu.getAlias()) !=
+                    *Collator::fromUCollator(frFR.getAlias())) {
                 errln("collator fufu != collator frFR");
             }
         }
 
         if (!Collator::unregister(key, status)) {
             errln("failed to unregister french collator");
         }
         // !!! note frcoll invalid again, but we're no longer using it
 
         // other collators should still work ok
@@ skipping 32 matching lines @@
   CollatorInfo(const Locale& locale, Collator* collatorToAdopt, Hashtable* displayNamesToAdopt);
   ~CollatorInfo();
   UnicodeString& getDisplayName(const Locale& displayLocale, UnicodeString& name) const;
 };
 
 CollatorInfo::CollatorInfo(const Locale& _locale, Collator* _collator, Hashtable* _displayNames)
   : locale(_locale)
   , collator(_collator)
   , displayNames(_displayNames)
 {
+  collator->setLocales(locale, locale, locale);
 }
 
 CollatorInfo::~CollatorInfo() {
   delete collator;
   delete displayNames;
 }
 
 UnicodeString&
 CollatorInfo::getDisplayName(const Locale& displayLocale, UnicodeString& name) const {
   if (displayNames) {
@@ skipping 163 matching lines @@
         if (*frcol != *ncol) {
             errln("frcoll for en_US failed");
         }
         delete ncol; ncol = NULL;
 
         ncol = Collator::createInstance(fu_FU_FOO, status);
         if (*jpcol != *ncol) {
             errln("jpcol for fu_FU_FOO failed");
         }
 
+        // The requested locale may be the same as the valid locale,
+        // or may not be supported at all. See ticket #10477.
         Locale loc = ncol->getLocale(ULOC_REQUESTED_LOCALE, status);
-        if (loc != fu_FU_FOO) {
-            errln(UnicodeString("requested locale for fu_FU_FOO is not fu_FU_FOO but ") + loc.getName());
+        if (U_SUCCESS(status) && loc != fu_FU_FOO && loc != fu_FU) {
+            errln(UnicodeString("requested locale for fu_FU_FOO is not fu_FU_FOO nor fu_FU but ") + loc.getName());
         }
+        status = U_ZERO_ERROR;
         loc = ncol->getLocale(ULOC_VALID_LOCALE, status);
         if (loc != fu_FU) {
             errln(UnicodeString("valid locale for fu_FU_FOO is not fu_FU but ") + loc.getName());
         }
         delete ncol; ncol = NULL;
 
         UnicodeString locName = fu_FU.getName();
         StringEnumeration* localeEnum = Collator::getAvailableLocales();
         UBool found = FALSE;
         const UnicodeString* locStr;
@@ skipping 151 matching lines @@
     assertSuccess("getFunctionalEquivalent", ec);
     assertEquals("getFunctionalEquivalent(de)", "root", equiv.getName());
     assertTrue("getFunctionalEquivalent(de).isAvailable==TRUE",
                isAvailable == TRUE);
 
     equiv = Collator::getFunctionalEquivalent("collation",
                                               Locale::createFromName("de_DE"),
                                               isAvailable, ec);
     assertSuccess("getFunctionalEquivalent", ec);
     assertEquals("getFunctionalEquivalent(de_DE)", "root", equiv.getName());
-    assertTrue("getFunctionalEquivalent(de_DE).isAvailable==TRUE",
-               isAvailable == TRUE);
+    assertTrue("getFunctionalEquivalent(de_DE).isAvailable==FALSE",
+               isAvailable == FALSE);
 
     equiv = Collator::getFunctionalEquivalent("collation",
                                                      Locale::createFromName("sv"),
                                                      isAvailable, ec);
     assertSuccess("getFunctionalEquivalent", ec);
     assertEquals("getFunctionalEquivalent(sv)", "sv", equiv.getName());
     assertTrue("getFunctionalEquivalent(sv).isAvailable==TRUE",
                isAvailable == TRUE);
 
     equiv = Collator::getFunctionalEquivalent("collation",
                                               Locale::createFromName("sv_SE"),
                                               isAvailable, ec);
     assertSuccess("getFunctionalEquivalent", ec);
     assertEquals("getFunctionalEquivalent(sv_SE)", "sv", equiv.getName());
-    assertTrue("getFunctionalEquivalent(sv_SE).isAvailable==TRUE",
-               isAvailable == TRUE);
+    assertTrue("getFunctionalEquivalent(sv_SE).isAvailable==FALSE",
+               isAvailable == FALSE);
 }
 
 #endif