| /* |
| ******************************************************************************* |
| * Copyright (C) 2003-2006, 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; |
| } |
| } |
| |
| void CollationServiceTest::TestRegister() |
| { |
| #if !UCONFIG_NO_SERVICE |
| // register a singleton |
| const Locale& FR = Locale::getFrance(); |
| const Locale& US = Locale::getUS(); |
| const Locale US_FOO("en", "US", "FOO"); |
| |
| UErrorCode status = U_ZERO_ERROR; |
| |
| Collator* frcol = Collator::createInstance(FR, status); |
| Collator* uscol = Collator::createInstance(US, status); |
| if(U_FAILURE(status)) { |
| errln("Failed to create collators with %s", u_errorName(status)); |
| delete frcol; |
| delete uscol; |
| return; |
| } |
| |
| { // try override en_US collator |
| URegistryKey key = Collator::registerInstance(frcol, US, status); |
| |
| Collator* ncol = Collator::createInstance(US_FOO, status); |
| if (*frcol != *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()); |
| } |
| 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()); |
| } |
| 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); |
| |
| UCollator* 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); |
| URegistryKey key = Collator::registerInstance(frcol, fu_FU, status); |
| Collator* ncol = Collator::createInstance(fu_FU_FOO, status); |
| if (*frcol != *ncol) { |
| errln("register of fr collator for fu_FU failed"); |
| } |
| |
| 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) { |
| found = TRUE; |
| } |
| } |
| |
| StringEnumeration *le2 = NULL; |
| localeEnum->reset(status); |
| int32_t i, count; |
| count = localeEnum->count(status); |
| for(i = 0; i < count; ++i) { |
| if(i == count / 2) { |
| le2 = localeEnum->clone(); |
| if(le2 == NULL || count != le2->count(status)) { |
| errln("ServiceEnumeration.clone() failed"); |
| break; |
| } |
| } |
| if(i >= count / 2) { |
| locStr = localeEnum->snext(status); |
| ls2 = le2->snext(status); |
| if(*locStr != *ls2) { |
| errln("ServiceEnumeration.clone() failed for item %d", i); |
| } |
| } else { |
| localeEnum->snext(status); |
| } |
| } |
| |
| delete localeEnum; |
| delete le2; |
| |
| if (!found) { |
| errln("new locale fu_FU not reported as supported locale"); |
| } |
| |
| UnicodeString displayName; |
| Collator::getDisplayName(fu_FU, displayName); |
| if (displayName != "fu (FU)") { |
| errln(UnicodeString("found ") + displayName + " for fu_FU"); |
| } |
| |
| Collator::getDisplayName(fu_FU, fu_FU, displayName); |
| if (displayName != "fu (FU)") { |
| errln(UnicodeString("found ") + displayName + " for fu_FU"); |
| } |
| |
| // test ucol_open |
| UCollator* fufu = ucol_open("fu_FU_FOO", &status); |
| if (!fufu) { |
| errln("could not open fu_FU_FOO with ucol_open"); |
| } else { |
| if (!ucol_equals(fufu, frFR)) { |
| 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 |
| Locale nloc = ncol->getLocale(ULOC_VALID_LOCALE, status); |
| if (nloc != fu_FU) { |
| errln(UnicodeString("asked for nloc valid locale after close and got") + nloc.getName()); |
| } |
| delete ncol; ncol = NULL; |
| |
| if (fufu) { |
| const char* nlocstr = ucol_getLocale(fufu, ULOC_VALID_LOCALE, &status); |
| if (uprv_strcmp(nlocstr, "fu_FU") != 0) { |
| errln(UnicodeString("asked for uloc valid locale after close and got ") + nlocstr); |
| } |
| ucol_close(fufu); |
| } |
| ucol_close(frFR); |
| |
| ncol = Collator::createInstance(fu_FU, status); |
| if (*fucol != *ncol) { |
| errln("collator after unregister does not match original fu_FU"); |
| } |
| delete uscol; uscol = NULL; |
| delete ncol; ncol = NULL; |
| delete fucol; fucol = NULL; |
| } |
| #endif |
| } |
| |
| // ------------------ |
| |
| #if !UCONFIG_NO_SERVICE |
| struct CollatorInfo { |
| Locale locale; |
| Collator* collator; |
| Hashtable* displayNames; // locale name -> string |
| |
| 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) |
| { |
| } |
| |
| CollatorInfo::~CollatorInfo() { |
| delete collator; |
| delete displayNames; |
| } |
| |
| UnicodeString& |
| CollatorInfo::getDisplayName(const Locale& displayLocale, UnicodeString& name) const { |
| if (displayNames) { |
| UnicodeString* val = (UnicodeString*)displayNames->get(displayLocale.getName()); |
| if (val) { |
| name = *val; |
| return name; |
| } |
| } |
| |
| return locale.getDisplayName(displayLocale, name); |
| } |
| |
| // --------------- |
| |
| class TestFactory : public CollatorFactory { |
| CollatorInfo** info; |
| int32_t count; |
| UnicodeString* ids; |
| |
| const CollatorInfo* getInfo(const Locale& loc) const { |
| for (CollatorInfo** p = info; *p; ++p) { |
| if (loc == (**p).locale) { |
| return *p; |
| } |
| } |
| return NULL; |
| } |
| |
| public: |
| TestFactory(CollatorInfo** _info) |
| : info(_info) |
| , count(0) |
| , ids(NULL) |
| { |
| CollatorInfo** p; |
| for (p = info; *p; ++p) {} |
| count = (int32_t)(p - info); |
| } |
| |
| ~TestFactory() { |
| for (CollatorInfo** p = info; *p; ++p) { |
| delete *p; |
| } |
| delete[] info; |
| delete[] ids; |
| } |
| |
| virtual Collator* createCollator(const Locale& loc) { |
| const CollatorInfo* ci = getInfo(loc); |
| if (ci) { |
| return ci->collator->clone(); |
| } |
| return NULL; |
| } |
| |
| virtual UnicodeString& getDisplayName(const Locale& objectLocale, |
| const Locale& displayLocale, |
| UnicodeString& result) |
| { |
| const CollatorInfo* ci = getInfo(objectLocale); |
| if (ci) { |
| ci->getDisplayName(displayLocale, result); |
| } else { |
| result.setToBogus(); |
| } |
| return result; |
| } |
| |
| const UnicodeString* getSupportedIDs(int32_t& _count, UErrorCode& status) { |
| if (U_SUCCESS(status)) { |
| if (!ids) { |
| ids = new UnicodeString[count]; |
| if (!ids) { |
| status = U_MEMORY_ALLOCATION_ERROR; |
| _count = 0; |
| return NULL; |
| } |
| |
| for (int i = 0; i < count; ++i) { |
| ids[i] = info[i]->locale.getName(); |
| } |
| } |
| |
| _count = count; |
| return ids; |
| } |
| return NULL; |
| } |
| |
| virtual inline UClassID getDynamicClassID() const { |
| return (UClassID)&gClassID; |
| } |
| |
| static UClassID getStaticClassID() { |
| return (UClassID)&gClassID; |
| } |
| |
| private: |
| static char gClassID; |
| }; |
| |
| char TestFactory::gClassID = 0; |
| #endif |
| |
| void CollationServiceTest::TestRegisterFactory(void) |
| { |
| #if !UCONFIG_NO_SERVICE |
| int32_t n1, n2, n3; |
| Locale fu_FU("fu", "FU", ""); |
| Locale fu_FU_FOO("fu", "FU", "FOO"); |
| |
| UErrorCode status = U_ZERO_ERROR; |
| |
| Hashtable* fuFUNames = new Hashtable(FALSE, status); |
| if (!fuFUNames) { |
| errln("memory allocation error"); |
| return; |
| } |
| fuFUNames->setValueDeleter(uhash_deleteUnicodeString); |
| |
| fuFUNames->put(fu_FU.getName(), new UnicodeString("ze leetle bunny Fu-Fu"), status); |
| fuFUNames->put(fu_FU_FOO.getName(), new UnicodeString("zee leetel bunny Foo-Foo"), status); |
| fuFUNames->put(Locale::getDefault().getName(), new UnicodeString("little bunny Foo Foo"), status); |
| |
| Collator* frcol = Collator::createInstance(Locale::getFrance(), status); |
| Collator* gecol = Collator::createInstance(Locale::getGermany(), status); |
| Collator* jpcol = Collator::createInstance(Locale::getJapan(), status); |
| if(U_FAILURE(status)) { |
| errln("Failed to create collators with %s", u_errorName(status)); |
| delete frcol; |
| delete gecol; |
| delete jpcol; |
| delete fuFUNames; |
| return; |
| } |
| |
| CollatorInfo** info = new CollatorInfo*[4]; |
| if (!info) { |
| errln("memory allocation error"); |
| return; |
| } |
| |
| info[0] = new CollatorInfo(Locale::getUS(), frcol, NULL); |
| info[1] = new CollatorInfo(Locale::getFrance(), gecol, NULL); |
| info[2] = new CollatorInfo(fu_FU, jpcol, fuFUNames); |
| info[3] = NULL; |
| |
| TestFactory* factory = new TestFactory(info); |
| if (!factory) { |
| errln("memory allocation error"); |
| return; |
| } |
| |
| Collator* uscol = Collator::createInstance(Locale::getUS(), status); |
| Collator* fucol = Collator::createInstance(fu_FU, status); |
| |
| { |
| n1 = checkAvailable("before registerFactory"); |
| |
| URegistryKey key = Collator::registerFactory(factory, status); |
| |
| n2 = checkAvailable("after registerFactory"); |
| assertTrue("count after > count before", n2 > n1); |
| |
| Collator* ncol = Collator::createInstance(Locale::getUS(), status); |
| 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"); |
| } |
| |
| 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()); |
| } |
| 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; |
| for (locStr = localeEnum->snext(status); |
| !found && locStr != NULL; |
| locStr = localeEnum->snext(status)) |
| { |
| if (locName == *locStr) { |
| found = TRUE; |
| } |
| } |
| delete localeEnum; |
| |
| if (!found) { |
| errln("new locale fu_FU not reported as supported locale"); |
| } |
| |
| UnicodeString name; |
| Collator::getDisplayName(fu_FU, name); |
| if (name != "little bunny Foo Foo") { |
| errln(UnicodeString("found ") + name + " for fu_FU"); |
| } |
| |
| Collator::getDisplayName(fu_FU, fu_FU_FOO, name); |
| if (name != "zee leetel bunny Foo-Foo") { |
| errln(UnicodeString("found ") + name + " for fu_FU in fu_FU_FOO"); |
| } |
| |
| if (!Collator::unregister(key, status)) { |
| errln("failed to unregister factory"); |
| } |
| // ja, fr, ge collators no longer valid |
| |
| ncol = Collator::createInstance(fu_FU, status); |
| if (*fucol != *ncol) { |
| errln("collator after unregister does not match original fu_FU"); |
| } |
| delete ncol; |
| |
| n3 = checkAvailable("after unregister"); |
| assertTrue("count after unregister == count before register", n3 == n1); |
| } |
| |
| delete fucol; |
| delete uscol; |
| #endif |
| } |
| |
| /** |
| * Iterate through the given iterator, checking to see that all the strings |
| * in the expected array are present. |
| * @param expected array of strings we expect to see, or NULL |
| * @param expectedCount number of elements of expected, or 0 |
| */ |
| int32_t CollationServiceTest::checkStringEnumeration(const char* msg, |
| StringEnumeration& iter, |
| const char** expected, |
| int32_t expectedCount) { |
| UErrorCode ec = U_ZERO_ERROR; |
| U_ASSERT(expectedCount >= 0 && expectedCount < 31); // [sic] 31 not 32 |
| int32_t i = 0, idxAfterReset = 0, n = iter.count(ec); |
| assertSuccess("count", ec); |
| UnicodeString buf, buffAfterReset; |
| int32_t seenMask = 0; |
| for (;; ++i) { |
| const UnicodeString* s = iter.snext(ec); |
| if (!assertSuccess("snext", ec) || s == NULL) |
| break; |
| if (i != 0) |
| buf.append(UNICODE_STRING_SIMPLE(", ")); |
| buf.append(*s); |
| // check expected list |
| for (int32_t j=0, bit=1; j<expectedCount; ++j, bit<<=1) { |
| if ((seenMask&bit)==0) { |
| UnicodeString exp(expected[j], (char*)NULL); |
| if (*s == exp) { |
| seenMask |= bit; |
| logln((UnicodeString)"Ok: \"" + exp + "\" seen"); |
| } |
| } |
| } |
| } |
| // can't get pesky operator+(const US&, foo) to cooperate; use toString |
| #if !UCONFIG_NO_FORMATTING |
| logln(UnicodeString() + msg + " = [" + buf + "] (" + toString(i) + ")"); |
| #else |
| logln(UnicodeString() + msg + " = [" + buf + "] (??? NO_FORMATTING)"); |
| #endif |
| assertTrue("count verified", i==n); |
| iter.reset(ec); |
| for (;; ++idxAfterReset) { |
| const UChar *s = iter.unext(NULL, ec); |
| if (!assertSuccess("unext", ec) || s == NULL) |
| break; |
| if (idxAfterReset != 0) |
| buffAfterReset.append(UNICODE_STRING_SIMPLE(", ")); |
| buffAfterReset.append(s); |
| } |
| assertTrue("idxAfterReset verified", idxAfterReset==n); |
| assertTrue("buffAfterReset verified", buffAfterReset==buf); |
| // did we see all expected strings? |
| if (((1<<expectedCount)-1) != seenMask) { |
| for (int32_t j=0, bit=1; j<expectedCount; ++j, bit<<=1) { |
| if ((seenMask&bit)==0) { |
| errln((UnicodeString)"FAIL: \"" + expected[j] + "\" not seen"); |
| } |
| } |
| } |
| return n; |
| } |
| |
| /** |
| * Check the integrity of the results of Collator::getAvailableLocales(). |
| * Return the number of items returned. |
| */ |
| #if !UCONFIG_NO_SERVICE |
| int32_t CollationServiceTest::checkAvailable(const char* msg) { |
| StringEnumeration *iter = Collator::getAvailableLocales(); |
| if (!assertTrue("getAvailableLocales != NULL", iter!=NULL)) return -1; |
| int32_t n = checkStringEnumeration(msg, *iter, NULL, 0); |
| delete iter; |
| return n; |
| } |
| #endif |
| |
| static const char* KW[] = { |
| "collation" |
| }; |
| static const int32_t KW_COUNT = sizeof(KW)/sizeof(KW[0]); |
| |
| static const char* KWVAL[] = { |
| "phonebook", |
| "stroke" |
| }; |
| static const int32_t KWVAL_COUNT = sizeof(KWVAL)/sizeof(KWVAL[0]); |
| |
| void CollationServiceTest::TestSeparateTree() { |
| UErrorCode ec = U_ZERO_ERROR; |
| StringEnumeration *iter = Collator::getKeywords(ec); |
| if (!assertTrue("getKeywords != NULL", iter!=NULL)) return; |
| if (!assertSuccess("getKeywords", ec)) return; |
| checkStringEnumeration("getKeywords", *iter, KW, KW_COUNT); |
| delete iter; |
| |
| iter = Collator::getKeywordValues(KW[0], ec); |
| if (!assertTrue("getKeywordValues != NULL", iter!=NULL)) return; |
| if (!assertSuccess("getKeywordValues", ec)) return; |
| checkStringEnumeration("getKeywordValues", *iter, KWVAL, KWVAL_COUNT); |
| delete iter; |
| |
| UBool isAvailable; |
| Locale equiv = Collator::getFunctionalEquivalent("collation", |
| Locale::createFromName("fr"), |
| isAvailable, ec); |
| assertSuccess("getFunctionalEquivalent", ec); |
| assertEquals("getFunctionalEquivalent(fr)", "fr", equiv.getName()); |
| assertTrue("getFunctionalEquivalent(fr).isAvailable==TRUE", |
| isAvailable == TRUE); |
| |
| equiv = Collator::getFunctionalEquivalent("collation", |
| Locale::createFromName("fr_FR"), |
| isAvailable, ec); |
| assertSuccess("getFunctionalEquivalent", ec); |
| assertEquals("getFunctionalEquivalent(fr_FR)", "fr", equiv.getName()); |
| assertTrue("getFunctionalEquivalent(fr_FR).isAvailable==TRUE", |
| isAvailable == TRUE); |
| } |
| |
| #endif |
