X-Git-Url: https://git.saurik.com/apple/icu.git/blobdiff_plain/b25be06635768807f8f693286fa73bb2297bb06c..4388f060552cc537e71e957d32f35e9d75a61233:/icuSources/test/intltest/alphaindextst.cpp?ds=inline diff --git a/icuSources/test/intltest/alphaindextst.cpp b/icuSources/test/intltest/alphaindextst.cpp new file mode 100644 index 00000000..bc928600 --- /dev/null +++ b/icuSources/test/intltest/alphaindextst.cpp @@ -0,0 +1,435 @@ +/******************************************************************** + * COPYRIGHT: + * Copyright (c) 2012, International Business Machines Corporation and + * others. All Rights Reserved. + ********************************************************************/ +// +// file: alphaindex.cpp +// Alphabetic Index Tests. +// +#include "intltest.h" +#include "alphaindextst.h" + +#include "unicode/alphaindex.h" +#include "unicode/coll.h" +#include "unicode/tblcoll.h" +#include "unicode/uniset.h" + +#if !UCONFIG_NO_COLLATION && !UCONFIG_NO_NORMALIZATION + +// #include +// #include + +AlphabeticIndexTest::AlphabeticIndexTest() { +} + +AlphabeticIndexTest::~AlphabeticIndexTest() { +} + +void AlphabeticIndexTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ ) +{ + if (exec) logln("TestSuite AlphabeticIndex: "); + switch (index) { + + case 0: name = "APITest"; + if (exec) APITest(); + break; + + case 1: name = "ManyLocales"; + if (exec) ManyLocalesTest(); + break; + + case 2: name = "HackPinyinTest"; + if (exec) HackPinyinTest(); + break; + + case 3: name = "TestBug9009"; + if (exec) TestBug9009(); + break; + + default: name = ""; + break; //needed to end loop + } +} + +#define TEST_CHECK_STATUS {if (U_FAILURE(status)) {dataerrln("%s:%d: Test failure. status=%s", \ + __FILE__, __LINE__, u_errorName(status)); return;}} + +#define TEST_ASSERT(expr) {if ((expr)==FALSE) {errln("%s:%d: Test failure \n", __FILE__, __LINE__);};} + +// +// APITest. Invoke every function at least once, and check that it does something. +// Does not attempt to check complete functionality. +// +void AlphabeticIndexTest::APITest() { + // + // Simple constructor and destructor, getBucketCount() + // + UErrorCode status = U_ZERO_ERROR; + int32_t lc = 0; + int32_t i = 0; + AlphabeticIndex *index = new AlphabeticIndex(Locale::getEnglish(), status); + TEST_CHECK_STATUS; + lc = index->getBucketCount(status); + TEST_CHECK_STATUS; + TEST_ASSERT(28 == lc); // 26 letters plus two under/overflow labels. + //printf("getBucketCount() == %d\n", lc); + delete index; + + // addLabels() + + status = U_ZERO_ERROR; + index = new AlphabeticIndex(Locale::getEnglish(), status); + TEST_CHECK_STATUS; + UnicodeSet additions; + additions.add((UChar32)0x410).add((UChar32)0x415); // A couple of Cyrillic letters + index->addLabels(additions, status); + TEST_CHECK_STATUS; + lc = index->getBucketCount(status); + TEST_CHECK_STATUS; + // TODO: should get 31. Java also gives 30. Needs fixing + TEST_ASSERT(30 == lc); // 26 Latin letters plus + // TEST_ASSERT(31 == lc); // 26 Latin letters plus + // 2 Cyrillic letters plus + // 1 inflow label plus + // two under/overflow labels. + // std::cout << lc << std::endl; + delete index; + + + // addLabels(Locale) + + status = U_ZERO_ERROR; + index = new AlphabeticIndex(Locale::getEnglish(), status); + TEST_CHECK_STATUS; + AlphabeticIndex &aip = index->addLabels(Locale::getJapanese(), status); + TEST_ASSERT(&aip == index); + TEST_CHECK_STATUS; + lc = index->getBucketCount(status); + TEST_CHECK_STATUS; + TEST_ASSERT(35 < lc); // Japanese should add a bunch. Don't rely on the exact value. + delete index; + + // GetCollator(), Get under/in/over flow labels + + status = U_ZERO_ERROR; + index = new AlphabeticIndex(Locale::getGerman(), status); + TEST_CHECK_STATUS; + Collator *germanCol = Collator::createInstance(Locale::getGerman(), status); + TEST_CHECK_STATUS; + const RuleBasedCollator &indexCol = index->getCollator(); + TEST_ASSERT(*germanCol == indexCol); + delete germanCol; + + UnicodeString ELLIPSIS; ELLIPSIS.append((UChar32)0x2026); + UnicodeString s = index->getUnderflowLabel(); + TEST_ASSERT(ELLIPSIS == s); + s = index->getOverflowLabel(); + TEST_ASSERT(ELLIPSIS == s); + s = index->getInflowLabel(); + TEST_ASSERT(ELLIPSIS == s); + index->setOverflowLabel(UNICODE_STRING_SIMPLE("O"), status); + index->setUnderflowLabel(UNICODE_STRING_SIMPLE("U"), status).setInflowLabel(UNICODE_STRING_SIMPLE("I"), status); + s = index->getUnderflowLabel(); + TEST_ASSERT(UNICODE_STRING_SIMPLE("U") == s); + s = index->getOverflowLabel(); + TEST_ASSERT(UNICODE_STRING_SIMPLE("O") == s); + s = index->getInflowLabel(); + TEST_ASSERT(UNICODE_STRING_SIMPLE("I") == s); + + + + + delete index; + + + + const UnicodeString adam = UNICODE_STRING_SIMPLE("Adam"); + const UnicodeString baker = UNICODE_STRING_SIMPLE("Baker"); + const UnicodeString charlie = UNICODE_STRING_SIMPLE("Charlie"); + const UnicodeString chad = UNICODE_STRING_SIMPLE("Chad"); + const UnicodeString zed = UNICODE_STRING_SIMPLE("Zed"); + const UnicodeString Cyrillic = UNICODE_STRING_SIMPLE("\\u0410\\u0443\\u0435").unescape(); + + // addRecord(), verify that it comes back out. + // + status = U_ZERO_ERROR; + index = new AlphabeticIndex(Locale::getEnglish(), status); + TEST_CHECK_STATUS; + index->addRecord(UnicodeString("Adam"), this, status); + UBool b; + TEST_CHECK_STATUS; + index->resetBucketIterator(status); + TEST_CHECK_STATUS; + index->nextBucket(status); // Move to underflow label + index->nextBucket(status); // Move to "A" + TEST_CHECK_STATUS; + const UnicodeString &label2 = index->getBucketLabel(); + UnicodeString A_STR = UNICODE_STRING_SIMPLE("A"); + TEST_ASSERT(A_STR == label2); + + b = index->nextRecord(status); + TEST_CHECK_STATUS; + TEST_ASSERT(b); + const UnicodeString &itemName = index->getRecordName(); + TEST_ASSERT(adam == itemName); + + const void *itemContext = index->getRecordData(); + TEST_ASSERT(itemContext == this); + + delete index; + + // clearRecords, addRecord(), Iteration + + status = U_ZERO_ERROR; + index = new AlphabeticIndex(Locale::getEnglish(), status); + TEST_CHECK_STATUS; + while (index->nextBucket(status)) { + TEST_CHECK_STATUS; + while (index->nextRecord(status)) { + TEST_CHECK_STATUS; + TEST_ASSERT(FALSE); // No items have been added. + } + TEST_CHECK_STATUS; + } + + index->addRecord(adam, NULL, status); + index->addRecord(baker, NULL, status); + index->addRecord(charlie, NULL, status); + index->addRecord(chad, NULL, status); + TEST_CHECK_STATUS; + int itemCount = 0; + index->resetBucketIterator(status); + while (index->nextBucket(status)) { + TEST_CHECK_STATUS; + while (index->nextRecord(status)) { + TEST_CHECK_STATUS; + ++itemCount; + } + } + TEST_CHECK_STATUS; + TEST_ASSERT(itemCount == 4); + + TEST_ASSERT(index->nextBucket(status) == FALSE); + index->resetBucketIterator(status); + TEST_CHECK_STATUS; + TEST_ASSERT(index->nextBucket(status) == TRUE); + + index->clearRecords(status); + TEST_CHECK_STATUS; + index->resetBucketIterator(status); + while (index->nextBucket(status)) { + TEST_CHECK_STATUS; + while (index->nextRecord(status)) { + TEST_ASSERT(FALSE); // No items have been added. + } + } + TEST_CHECK_STATUS; + delete index; + + // getBucketLabel(), getBucketType() + + status = U_ZERO_ERROR; + index = new AlphabeticIndex(Locale::getEnglish(), status); + TEST_CHECK_STATUS; + index->setUnderflowLabel(adam, status).setOverflowLabel(charlie, status); + TEST_CHECK_STATUS; + for (i=0; index->nextBucket(status); i++) { + TEST_CHECK_STATUS; + UnicodeString label = index->getBucketLabel(); + UAlphabeticIndexLabelType type = index->getBucketLabelType(); + if (i == 0) { + TEST_ASSERT(type == U_ALPHAINDEX_UNDERFLOW); + TEST_ASSERT(label == adam); + } else if (i <= 26) { + // Labels A - Z for English locale + TEST_ASSERT(type == U_ALPHAINDEX_NORMAL); + UnicodeString expectedLabel((UChar)(0x40 + i)); + TEST_ASSERT(expectedLabel == label); + } else if (i == 27) { + TEST_ASSERT(type == U_ALPHAINDEX_OVERFLOW); + TEST_ASSERT(label == charlie); + } else { + TEST_ASSERT(FALSE); + } + } + TEST_ASSERT(i==28); + delete index; + + // getBucketIndex() + + status = U_ZERO_ERROR; + index = new AlphabeticIndex(Locale::getEnglish(), status); + TEST_CHECK_STATUS; + int32_t n = index->getBucketIndex(adam, status); + TEST_CHECK_STATUS; + TEST_ASSERT(n == 1); /* Label #0 is underflow, 1 is A, etc. */ + n = index->getBucketIndex(baker, status); + TEST_ASSERT(n == 2); + n = index->getBucketIndex(Cyrillic, status); + TEST_ASSERT(n == 27); // Overflow label + n = index->getBucketIndex(zed, status); + TEST_ASSERT(n == 26); + + for (i=0; index->nextBucket(status); i++) { + n = index->getBucketIndex(); + TEST_ASSERT(n == i); + UnicodeString label = index->getBucketLabel(); + TEST_ASSERT(n == i); + } + TEST_ASSERT(i == 28); + + delete index; + index = new AlphabeticIndex(Locale::createFromName("ru"), status); + //Locale loc = Locale::createFromName(localeName); + TEST_CHECK_STATUS; + n = index->getBucketIndex(adam, status); + TEST_CHECK_STATUS; + TEST_ASSERT(n == 0); // Label #0 is underflow + n = index->getBucketIndex(baker, status); + TEST_ASSERT(n == 0); + n = index->getBucketIndex(Cyrillic, status); + TEST_ASSERT(n == 1); // Overflow label + n = index->getBucketIndex(zed, status); + TEST_ASSERT(n == 0); + + delete index; + +} + + +static const char * KEY_LOCALES[] = { + "en", "es", "de", "fr", "ja", "it", "tr", "pt", "zh", "nl", + "pl", "ar", "ru", "zh_Hant", "ko", "th", "sv", "fi", "da", + "he", "nb", "el", "hr", "bg", "sk", "lt", "vi", "lv", "sr", + "pt_PT", "ro", "hu", "cs", "id", "sl", "fil", "fa", "uk", + "ca", "hi", "et", "eu", "is", "sw", "ms", "bn", "am", "ta", + "te", "mr", "ur", "ml", "kn", "gu", "or", ""}; + + +void AlphabeticIndexTest::ManyLocalesTest() { + UErrorCode status = U_ZERO_ERROR; + int32_t lc = 0; + AlphabeticIndex *index = NULL; + + for (int i=0; ; ++i) { + status = U_ZERO_ERROR; + const char *localeName = KEY_LOCALES[i]; + if (localeName[0] == 0) { + break; + } + // std::cout << localeName << " "; + Locale loc = Locale::createFromName(localeName); + index = new AlphabeticIndex(loc, status); + TEST_CHECK_STATUS; + lc = index->getBucketCount(status); + TEST_CHECK_STATUS; + // std::cout << "getBucketCount() == " << lc << std::endl; + + while (index->nextBucket(status)) { + TEST_CHECK_STATUS; + const UnicodeString &label = index->getBucketLabel(); + TEST_ASSERT(label.length()>0); + // std::string ss; + // std::cout << ":" << label.toUTF8String(ss); + } + // std::cout << ":" << std::endl; + + + delete index; + } +} + + +// Test data for Pinyin based indexes. +// The Chinese characters should be distributed under latin labels in +// an index. + +static const char *pinyinTestData[] = { + "\\u0101", "\\u5416", "\\u58ba", // + "b", "\\u516b", "\\u62d4", "\\u8500", // + "c", "\\u5693", "\\u7938", "\\u9e7e", // + "d", "\\u5491", "\\u8fcf", "\\u964a", // + "\\u0113","\\u59b8", "\\u92e8", "\\u834b", // + "f", "\\u53d1", "\\u9197", "\\u99a5", // + "g", "\\u7324", "\\u91d3", "\\u8142", // + "h", "\\u598e", "\\u927f", "\\u593b", // + "j", "\\u4e0c", "\\u6785", "\\u9d58", // + "k", "\\u5494", "\\u958b", "\\u7a52", // + "l", "\\u5783", "\\u62c9", "\\u9ba5", // + "m", "\\u5638", "\\u9ebb", "\\u65c0", // + "n", "\\u62ff", "\\u80ad", "\\u685b", // + "\\u014D", "\\u5662", "\\u6bee", "\\u8bb4", // + "p", "\\u5991", "\\u8019", "\\u8c31", // + "q", "\\u4e03", "\\u6053", "\\u7f56", // + "r", "\\u5465", "\\u72aa", "\\u6e03", // + "s", "\\u4ee8", "\\u9491", "\\u93c1", // + "t", "\\u4ed6", "\\u9248", "\\u67dd", // + "w", "\\u5c72", "\\u5558", "\\u5a7a", // + "x", "\\u5915", "\\u5438", "\\u6bbe", // + "y", "\\u4e2b", "\\u82bd", "\\u8574", // + "z", "\\u5e00", "\\u707d", "\\u5c0a", + NULL + }; + +void AlphabeticIndexTest::HackPinyinTest() { + UErrorCode status = U_ZERO_ERROR; + AlphabeticIndex aindex(Locale::createFromName("zh"), status); + TEST_CHECK_STATUS; + + UnicodeString names[sizeof(pinyinTestData) / sizeof(pinyinTestData[0])]; + int32_t nameCount; + for (nameCount=0; pinyinTestData[nameCount] != NULL; nameCount++) { + names[nameCount] = UnicodeString(pinyinTestData[nameCount], -1, UnicodeString::kInvariant).unescape(); + aindex.addRecord(names[nameCount], &names[nameCount], status); + TEST_CHECK_STATUS; + if (U_FAILURE(status)) { + return; + } + } + TEST_ASSERT(nameCount == aindex.getRecordCount(status)); + + // Weak checking: make sure that none of the Chinese names landed in the overflow bucket + // of the index, and that the names are distributed among several buckets. + // (Exact expected data would be subject to change with evolution of the collation rules.) + + int32_t bucketCount = 0; + int32_t filledBucketCount = 0; + while (aindex.nextBucket(status)) { + bucketCount++; + UnicodeString label = aindex.getBucketLabel(); + // std::string s; + // std::cout << label.toUTF8String(s) << ": "; + + UBool bucketHasContents = FALSE; + while (aindex.nextRecord(status)) { + bucketHasContents = TRUE; + UnicodeString name = aindex.getRecordName(); + if (aindex.getBucketLabelType() != U_ALPHAINDEX_NORMAL) { + errln("File %s, Line %d, Name \"\\u%x\" is in an under or overflow bucket.", + __FILE__, __LINE__, name.char32At(0)); + } + // s.clear(); + // std::cout << aindex.getRecordName().toUTF8String(s) << " "; + } + if (bucketHasContents) { + filledBucketCount++; + } + // std::cout << std::endl; + } + TEST_ASSERT(bucketCount > 25); + TEST_ASSERT(filledBucketCount > 15); +} + + +void AlphabeticIndexTest::TestBug9009() { + UErrorCode status = U_ZERO_ERROR; + Locale loc("root"); + AlphabeticIndex aindex(loc, status); + TEST_CHECK_STATUS; + aindex.nextBucket(status); // Crash here before bug was fixed. + TEST_CHECK_STATUS; +} + + +#endif