Home | History | Annotate | Download | only in intltest
      1 /*
      2  *******************************************************************************
      3  * Copyright (C) 2003-2010, International Business Machines Corporation and    *
      4  * others. All Rights Reserved.                                                *
      5  *******************************************************************************
      6  */
      7 
      8 #include "unicode/utypes.h"
      9 
     10 #if !UCONFIG_NO_COLLATION
     11 
     12 #include "svccoll.h"
     13 #include "unicode/coll.h"
     14 #include "unicode/strenum.h"
     15 #include "hash.h"
     16 #include "uassert.h"
     17 
     18 #include "ucol_imp.h" // internal api needed to test ucollator equality
     19 #include "cstring.h" // internal api used to compare locale strings
     20 
     21 void CollationServiceTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /*par */)
     22 {
     23     if (exec) logln("TestSuite CollationServiceTest: ");
     24     switch (index) {
     25         TESTCASE(0, TestRegister);
     26         TESTCASE(1, TestRegisterFactory);
     27         TESTCASE(2, TestSeparateTree);
     28     default: name = ""; break;
     29     }
     30 }
     31 
     32 void CollationServiceTest::TestRegister()
     33 {
     34 #if !UCONFIG_NO_SERVICE
     35     // register a singleton
     36     const Locale& FR = Locale::getFrance();
     37     const Locale& US = Locale::getUS();
     38     const Locale US_FOO("en", "US", "FOO");
     39 
     40     UErrorCode status = U_ZERO_ERROR;
     41 
     42     Collator* frcol = Collator::createInstance(FR, status);
     43     Collator* uscol = Collator::createInstance(US, status);
     44     if(U_FAILURE(status)) {
     45         errcheckln(status, "Failed to create collators with %s", u_errorName(status));
     46         delete frcol;
     47         delete uscol;
     48         return;
     49     }
     50 
     51     { // try override en_US collator
     52         URegistryKey key = Collator::registerInstance(frcol, US, status);
     53 
     54         Collator* ncol = Collator::createInstance(US_FOO, status);
     55         if (*frcol != *ncol) {
     56             errln("register of french collator for en_US failed on request for en_US_FOO");
     57         }
     58         // ensure original collator's params not touched
     59         Locale loc = frcol->getLocale(ULOC_REQUESTED_LOCALE, status);
     60         if (loc != FR) {
     61           errln(UnicodeString("fr collator's requested locale changed to ") + loc.getName());
     62         }
     63         loc = frcol->getLocale(ULOC_VALID_LOCALE, status);
     64         if (loc != FR) {
     65           errln(UnicodeString("fr collator's valid locale changed to ") + loc.getName());
     66         }
     67 
     68         loc = ncol->getLocale(ULOC_REQUESTED_LOCALE, status);
     69         if (loc != US_FOO) {
     70             errln(UnicodeString("requested locale for en_US_FOO is not en_US_FOO but ") + loc.getName());
     71         }
     72         loc = ncol->getLocale(ULOC_VALID_LOCALE, status);
     73         if (loc != US) {
     74             errln(UnicodeString("valid locale for en_US_FOO is not en_US but ") + loc.getName());
     75         }
     76         loc = ncol->getLocale(ULOC_ACTUAL_LOCALE, status);
     77         if (loc != US) {
     78             errln(UnicodeString("actual locale for en_US_FOO is not en_US but ") + loc.getName());
     79         }
     80         delete ncol; ncol = NULL;
     81 
     82         if (!Collator::unregister(key, status)) {
     83             errln("failed to unregister french collator");
     84         }
     85         // !!! frcol pointer is now invalid !!!
     86 
     87         ncol = Collator::createInstance(US, status);
     88         if (*uscol != *ncol) {
     89             errln("collator after unregister does not match original");
     90         }
     91         delete ncol; ncol = NULL;
     92     }
     93 
     94     // recreate frcol
     95     frcol = Collator::createInstance(FR, status);
     96 
     97     LocalUCollatorPointer frFR(ucol_open("fr_FR", &status));
     98 
     99     { // try create collator for new locale
    100         Locale fu_FU_FOO("fu", "FU", "FOO");
    101         Locale fu_FU("fu", "FU", "");
    102 
    103         Collator* fucol = Collator::createInstance(fu_FU, status);
    104         URegistryKey key = Collator::registerInstance(frcol, fu_FU, status);
    105         Collator* ncol = Collator::createInstance(fu_FU_FOO, status);
    106         if (*frcol != *ncol) {
    107             errln("register of fr collator for fu_FU failed");
    108         }
    109 
    110         UnicodeString locName = fu_FU.getName();
    111         StringEnumeration* localeEnum = Collator::getAvailableLocales();
    112         UBool found = FALSE;
    113         const UnicodeString* locStr, *ls2;
    114         for (locStr = localeEnum->snext(status);
    115         !found && locStr != NULL;
    116         locStr = localeEnum->snext(status)) {
    117             //
    118             if (locName == *locStr) {
    119                 found = TRUE;
    120             }
    121         }
    122 
    123         StringEnumeration *le2 = NULL;
    124         localeEnum->reset(status);
    125         int32_t i, count;
    126         count = localeEnum->count(status);
    127         for(i = 0; i < count; ++i) {
    128             if(i == count / 2) {
    129                 le2 = localeEnum->clone();
    130                 if(le2 == NULL || count != le2->count(status)) {
    131                     errln("ServiceEnumeration.clone() failed");
    132                     break;
    133                 }
    134             }
    135             if(i >= count / 2) {
    136                 locStr = localeEnum->snext(status);
    137                 ls2 = le2->snext(status);
    138                 if(*locStr != *ls2) {
    139                     errln("ServiceEnumeration.clone() failed for item %d", i);
    140                 }
    141             } else {
    142                 localeEnum->snext(status);
    143             }
    144         }
    145 
    146         delete localeEnum;
    147         delete le2;
    148 
    149         if (!found) {
    150             errln("new locale fu_FU not reported as supported locale");
    151         }
    152 
    153         UnicodeString displayName;
    154         Collator::getDisplayName(fu_FU, displayName);
    155         /* The locale display pattern for the locale ja, ko, and zh are different. */
    156         const UChar zh_fuFU_Array[] = { 0x0066, 0x0075, 0xff08, 0x0046, 0x0055, 0xff09, 0 };
    157         const UnicodeString zh_fuFU(zh_fuFU_Array);
    158         const Locale& defaultLocale = Locale::getDefault();
    159         if (displayName != "fu (FU)" &&
    160            ((defaultLocale == Locale::getKorean() && defaultLocale == Locale::getJapanese()) && displayName == "fu(FU)") &&
    161            ((defaultLocale == Locale::getChinese()) && displayName != zh_fuFU)) {
    162             errln(UnicodeString("found ") + displayName + " for fu_FU");
    163         }
    164 
    165         Collator::getDisplayName(fu_FU, fu_FU, displayName);
    166         if (displayName != "fu (FU)" &&
    167            ((defaultLocale == Locale::getKorean() && defaultLocale == Locale::getJapanese()) && displayName == "fu(FU)") &&
    168            ((defaultLocale == Locale::getChinese()) && displayName != zh_fuFU)) {
    169             errln(UnicodeString("found ") + displayName + " for fu_FU");
    170         }
    171 
    172         // test ucol_open
    173         LocalUCollatorPointer fufu(ucol_open("fu_FU_FOO", &status));
    174         if (fufu.isNull()) {
    175             errln("could not open fu_FU_FOO with ucol_open");
    176         } else {
    177             if (!ucol_equals(fufu.getAlias(), frFR.getAlias())) {
    178                 errln("collator fufu != collator frFR");
    179             }
    180         }
    181 
    182         if (!Collator::unregister(key, status)) {
    183             errln("failed to unregister french collator");
    184         }
    185         // !!! note frcoll invalid again, but we're no longer using it
    186 
    187         // other collators should still work ok
    188         Locale nloc = ncol->getLocale(ULOC_VALID_LOCALE, status);
    189         if (nloc != fu_FU) {
    190             errln(UnicodeString("asked for nloc valid locale after close and got") + nloc.getName());
    191         }
    192         delete ncol; ncol = NULL;
    193 
    194         if (fufu.isValid()) {
    195             const char* nlocstr = ucol_getLocaleByType(fufu.getAlias(), ULOC_VALID_LOCALE, &status);
    196             if (uprv_strcmp(nlocstr, "fu_FU") != 0) {
    197                 errln(UnicodeString("asked for uloc valid locale after close and got ") + nlocstr);
    198             }
    199         }
    200 
    201         ncol = Collator::createInstance(fu_FU, status);
    202         if (*fucol != *ncol) {
    203             errln("collator after unregister does not match original fu_FU");
    204         }
    205         delete uscol; uscol = NULL;
    206         delete ncol; ncol = NULL;
    207         delete fucol; fucol = NULL;
    208     }
    209 #endif
    210 }
    211 
    212 // ------------------
    213 
    214 #if !UCONFIG_NO_SERVICE
    215 struct CollatorInfo {
    216   Locale locale;
    217   Collator* collator;
    218   Hashtable* displayNames; // locale name -> string
    219 
    220   CollatorInfo(const Locale& locale, Collator* collatorToAdopt, Hashtable* displayNamesToAdopt);
    221   ~CollatorInfo();
    222   UnicodeString& getDisplayName(const Locale& displayLocale, UnicodeString& name) const;
    223 };
    224 
    225 CollatorInfo::CollatorInfo(const Locale& _locale, Collator* _collator, Hashtable* _displayNames)
    226   : locale(_locale)
    227   , collator(_collator)
    228   , displayNames(_displayNames)
    229 {
    230 }
    231 
    232 CollatorInfo::~CollatorInfo() {
    233   delete collator;
    234   delete displayNames;
    235 }
    236 
    237 UnicodeString&
    238 CollatorInfo::getDisplayName(const Locale& displayLocale, UnicodeString& name) const {
    239   if (displayNames) {
    240     UnicodeString* val = (UnicodeString*)displayNames->get(displayLocale.getName());
    241     if (val) {
    242       name = *val;
    243       return name;
    244     }
    245   }
    246 
    247   return locale.getDisplayName(displayLocale, name);
    248 }
    249 
    250 // ---------------
    251 
    252 class TestFactory : public CollatorFactory {
    253   CollatorInfo** info;
    254   int32_t count;
    255   UnicodeString* ids;
    256 
    257   const CollatorInfo* getInfo(const Locale& loc) const {
    258     for (CollatorInfo** p = info; *p; ++p) {
    259       if (loc == (**p).locale) {
    260         return *p;
    261       }
    262     }
    263     return NULL;
    264   }
    265 
    266 public:
    267   TestFactory(CollatorInfo** _info)
    268     : info(_info)
    269     , count(0)
    270     , ids(NULL)
    271   {
    272     CollatorInfo** p;
    273     for (p = info; *p; ++p) {}
    274     count = (int32_t)(p - info);
    275   }
    276 
    277   ~TestFactory() {
    278     for (CollatorInfo** p = info; *p; ++p) {
    279       delete *p;
    280     }
    281     delete[] info;
    282     delete[] ids;
    283   }
    284 
    285   virtual Collator* createCollator(const Locale& loc) {
    286     const CollatorInfo* ci = getInfo(loc);
    287     if (ci) {
    288       return ci->collator->clone();
    289     }
    290     return NULL;
    291   }
    292 
    293   virtual UnicodeString& getDisplayName(const Locale& objectLocale,
    294                                         const Locale& displayLocale,
    295                                         UnicodeString& result)
    296   {
    297     const CollatorInfo* ci = getInfo(objectLocale);
    298     if (ci) {
    299       ci->getDisplayName(displayLocale, result);
    300     } else {
    301       result.setToBogus();
    302     }
    303     return result;
    304   }
    305 
    306   const UnicodeString* getSupportedIDs(int32_t& _count, UErrorCode& status) {
    307     if (U_SUCCESS(status)) {
    308       if (!ids) {
    309         ids = new UnicodeString[count];
    310         if (!ids) {
    311           status = U_MEMORY_ALLOCATION_ERROR;
    312           _count = 0;
    313           return NULL;
    314         }
    315 
    316         for (int i = 0; i < count; ++i) {
    317           ids[i] = info[i]->locale.getName();
    318         }
    319       }
    320 
    321       _count = count;
    322       return ids;
    323     }
    324     return NULL;
    325   }
    326 
    327   virtual inline UClassID getDynamicClassID() const {
    328     return (UClassID)&gClassID;
    329   }
    330 
    331   static UClassID getStaticClassID() {
    332     return (UClassID)&gClassID;
    333   }
    334 
    335 private:
    336   static char gClassID;
    337 };
    338 
    339 char TestFactory::gClassID = 0;
    340 #endif
    341 
    342 void CollationServiceTest::TestRegisterFactory(void)
    343 {
    344 #if !UCONFIG_NO_SERVICE
    345     int32_t n1, n2, n3;
    346     Locale fu_FU("fu", "FU", "");
    347     Locale fu_FU_FOO("fu", "FU", "FOO");
    348 
    349     UErrorCode status = U_ZERO_ERROR;
    350 
    351     Hashtable* fuFUNames = new Hashtable(FALSE, status);
    352     if (!fuFUNames) {
    353         errln("memory allocation error");
    354         return;
    355     }
    356     fuFUNames->setValueDeleter(uhash_deleteUnicodeString);
    357 
    358     fuFUNames->put(fu_FU.getName(), new UnicodeString("ze leetle bunny Fu-Fu"), status);
    359     fuFUNames->put(fu_FU_FOO.getName(), new UnicodeString("zee leetel bunny Foo-Foo"), status);
    360     fuFUNames->put(Locale::getDefault().getName(), new UnicodeString("little bunny Foo Foo"), status);
    361 
    362     Collator* frcol = Collator::createInstance(Locale::getFrance(), status);
    363     Collator* gecol = Collator::createInstance(Locale::getGermany(), status);
    364     Collator* jpcol = Collator::createInstance(Locale::getJapan(), status);
    365     if(U_FAILURE(status)) {
    366       errcheckln(status, "Failed to create collators with %s", u_errorName(status));
    367       delete frcol;
    368       delete gecol;
    369       delete jpcol;
    370       delete fuFUNames;
    371       return;
    372     }
    373 
    374     CollatorInfo** info = new CollatorInfo*[4];
    375     if (!info) {
    376         errln("memory allocation error");
    377         return;
    378     }
    379 
    380     info[0] = new CollatorInfo(Locale::getUS(), frcol, NULL);
    381     info[1] = new CollatorInfo(Locale::getFrance(), gecol, NULL);
    382     info[2] = new CollatorInfo(fu_FU, jpcol, fuFUNames);
    383     info[3] = NULL;
    384 
    385     TestFactory* factory = new TestFactory(info);
    386     if (!factory) {
    387         errln("memory allocation error");
    388         return;
    389     }
    390 
    391     Collator* uscol = Collator::createInstance(Locale::getUS(), status);
    392     Collator* fucol = Collator::createInstance(fu_FU, status);
    393 
    394     {
    395         n1 = checkAvailable("before registerFactory");
    396 
    397         URegistryKey key = Collator::registerFactory(factory, status);
    398 
    399         n2 = checkAvailable("after registerFactory");
    400         assertTrue("count after > count before", n2 > n1);
    401 
    402         Collator* ncol = Collator::createInstance(Locale::getUS(), status);
    403         if (*frcol != *ncol) {
    404             errln("frcoll for en_US failed");
    405         }
    406         delete ncol; ncol = NULL;
    407 
    408         ncol = Collator::createInstance(fu_FU_FOO, status);
    409         if (*jpcol != *ncol) {
    410             errln("jpcol for fu_FU_FOO failed");
    411         }
    412 
    413         Locale loc = ncol->getLocale(ULOC_REQUESTED_LOCALE, status);
    414         if (loc != fu_FU_FOO) {
    415             errln(UnicodeString("requested locale for fu_FU_FOO is not fu_FU_FOO but ") + loc.getName());
    416         }
    417         loc = ncol->getLocale(ULOC_VALID_LOCALE, status);
    418         if (loc != fu_FU) {
    419             errln(UnicodeString("valid locale for fu_FU_FOO is not fu_FU but ") + loc.getName());
    420         }
    421         delete ncol; ncol = NULL;
    422 
    423         UnicodeString locName = fu_FU.getName();
    424         StringEnumeration* localeEnum = Collator::getAvailableLocales();
    425         UBool found = FALSE;
    426         const UnicodeString* locStr;
    427         for (locStr = localeEnum->snext(status);
    428             !found && locStr != NULL;
    429             locStr = localeEnum->snext(status))
    430         {
    431             if (locName == *locStr) {
    432                 found = TRUE;
    433             }
    434         }
    435         delete localeEnum;
    436 
    437         if (!found) {
    438             errln("new locale fu_FU not reported as supported locale");
    439         }
    440 
    441         UnicodeString name;
    442         Collator::getDisplayName(fu_FU, name);
    443         if (name != "little bunny Foo Foo") {
    444             errln(UnicodeString("found ") + name + " for fu_FU");
    445         }
    446 
    447         Collator::getDisplayName(fu_FU, fu_FU_FOO, name);
    448         if (name != "zee leetel bunny Foo-Foo") {
    449             errln(UnicodeString("found ") + name + " for fu_FU in fu_FU_FOO");
    450         }
    451 
    452         if (!Collator::unregister(key, status)) {
    453             errln("failed to unregister factory");
    454         }
    455         // ja, fr, ge collators no longer valid
    456 
    457         ncol = Collator::createInstance(fu_FU, status);
    458         if (*fucol != *ncol) {
    459             errln("collator after unregister does not match original fu_FU");
    460         }
    461         delete ncol;
    462 
    463         n3 = checkAvailable("after unregister");
    464         assertTrue("count after unregister == count before register", n3 == n1);
    465     }
    466 
    467     delete fucol;
    468     delete uscol;
    469 #endif
    470 }
    471 
    472 /**
    473  * Iterate through the given iterator, checking to see that all the strings
    474  * in the expected array are present.
    475  * @param expected array of strings we expect to see, or NULL
    476  * @param expectedCount number of elements of expected, or 0
    477  */
    478 int32_t CollationServiceTest::checkStringEnumeration(const char* msg,
    479                                                      StringEnumeration& iter,
    480                                                      const char** expected,
    481                                                      int32_t expectedCount) {
    482     UErrorCode ec = U_ZERO_ERROR;
    483     U_ASSERT(expectedCount >= 0 && expectedCount < 31); // [sic] 31 not 32
    484     int32_t i = 0, idxAfterReset = 0, n = iter.count(ec);
    485     assertSuccess("count", ec);
    486     UnicodeString buf, buffAfterReset;
    487     int32_t seenMask = 0;
    488     for (;; ++i) {
    489         const UnicodeString* s = iter.snext(ec);
    490         if (!assertSuccess("snext", ec) || s == NULL)
    491             break;
    492         if (i != 0)
    493             buf.append(UNICODE_STRING_SIMPLE(", "));
    494         buf.append(*s);
    495         // check expected list
    496         for (int32_t j=0, bit=1; j<expectedCount; ++j, bit<<=1) {
    497             if ((seenMask&bit)==0) {
    498                 UnicodeString exp(expected[j], (char*)NULL);
    499                 if (*s == exp) {
    500                     seenMask |= bit;
    501                     logln((UnicodeString)"Ok: \"" + exp + "\" seen");
    502                 }
    503             }
    504         }
    505     }
    506     // can't get pesky operator+(const US&, foo) to cooperate; use toString
    507 #if !UCONFIG_NO_FORMATTING
    508     logln(UnicodeString() + msg + " = [" + buf + "] (" + toString(i) + ")");
    509 #else
    510     logln(UnicodeString() + msg + " = [" + buf + "] (??? NO_FORMATTING)");
    511 #endif
    512     assertTrue("count verified", i==n);
    513     iter.reset(ec);
    514     for (;; ++idxAfterReset) {
    515         const UChar *s = iter.unext(NULL, ec);
    516         if (!assertSuccess("unext", ec) || s == NULL)
    517             break;
    518         if (idxAfterReset != 0)
    519             buffAfterReset.append(UNICODE_STRING_SIMPLE(", "));
    520         buffAfterReset.append(s);
    521     }
    522     assertTrue("idxAfterReset verified", idxAfterReset==n);
    523     assertTrue("buffAfterReset verified", buffAfterReset==buf);
    524     // did we see all expected strings?
    525     if (((1<<expectedCount)-1) != seenMask) {
    526         for (int32_t j=0, bit=1; j<expectedCount; ++j, bit<<=1) {
    527             if ((seenMask&bit)==0) {
    528                 errln((UnicodeString)"FAIL: \"" + expected[j] + "\" not seen");
    529             }
    530         }
    531     }
    532     return n;
    533 }
    534 
    535 /**
    536  * Check the integrity of the results of Collator::getAvailableLocales().
    537  * Return the number of items returned.
    538  */
    539 #if !UCONFIG_NO_SERVICE
    540 int32_t CollationServiceTest::checkAvailable(const char* msg) {
    541     StringEnumeration *iter = Collator::getAvailableLocales();
    542     if (!assertTrue("getAvailableLocales != NULL", iter!=NULL)) return -1;
    543     int32_t n = checkStringEnumeration(msg, *iter, NULL, 0);
    544     delete iter;
    545     return n;
    546 }
    547 #endif
    548 
    549 static const char* KW[] = {
    550     "collation"
    551 };
    552 static const int32_t KW_COUNT = sizeof(KW)/sizeof(KW[0]);
    553 
    554 static const char* KWVAL[] = {
    555     "phonebook",
    556     "stroke"
    557 };
    558 static const int32_t KWVAL_COUNT = sizeof(KWVAL)/sizeof(KWVAL[0]);
    559 
    560 void CollationServiceTest::TestSeparateTree() {
    561     UErrorCode ec = U_ZERO_ERROR;
    562     StringEnumeration *iter = Collator::getKeywords(ec);
    563     if (!assertTrue("getKeywords != NULL", iter!=NULL)) return;
    564     if (!assertSuccess("getKeywords", ec)) return;
    565     checkStringEnumeration("getKeywords", *iter, KW, KW_COUNT);
    566     delete iter;
    567 
    568     iter = Collator::getKeywordValues(KW[0], ec);
    569     if (!assertTrue("getKeywordValues != NULL", iter!=NULL, FALSE, TRUE)) return;
    570     if (!assertSuccess("getKeywordValues", ec)) return;
    571     checkStringEnumeration("getKeywordValues", *iter, KWVAL, KWVAL_COUNT);
    572     delete iter;
    573 
    574     UBool isAvailable;
    575     Locale equiv = Collator::getFunctionalEquivalent("collation",
    576                                                      Locale::createFromName("de"),
    577                                                      isAvailable, ec);
    578     assertSuccess("getFunctionalEquivalent", ec);
    579     assertEquals("getFunctionalEquivalent(de)", "de", equiv.getName());
    580     assertTrue("getFunctionalEquivalent(de).isAvailable==TRUE",
    581                isAvailable == TRUE);
    582 
    583     equiv = Collator::getFunctionalEquivalent("collation",
    584                                               Locale::createFromName("de_DE"),
    585                                               isAvailable, ec);
    586     assertSuccess("getFunctionalEquivalent", ec);
    587     assertEquals("getFunctionalEquivalent(de_DE)", "de", equiv.getName());
    588     assertTrue("getFunctionalEquivalent(de_DE).isAvailable==TRUE",
    589                isAvailable == TRUE);
    590 }
    591 
    592 #endif
    593