[apple/icu.git] / icuSources / test / intltest / alphaindextst.cpp

/********************************************************************
 * 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 <string>
// #include <iostream>

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
Commit	Line	Data
4388f060 A	1	/********************************************************************
	2	* COPYRIGHT:
	3	* Copyright (c) 2012, International Business Machines Corporation and
	4	* others. All Rights Reserved.
	5	********************************************************************/
	6	//
	7	// file: alphaindex.cpp
	8	// Alphabetic Index Tests.
	9	//
	10	#include "intltest.h"
	11	#include "alphaindextst.h"
	12
	13	#include "unicode/alphaindex.h"
	14	#include "unicode/coll.h"
	15	#include "unicode/tblcoll.h"
	16	#include "unicode/uniset.h"
	17
	18	#if !UCONFIG_NO_COLLATION && !UCONFIG_NO_NORMALIZATION
	19
	20	// #include <string>
	21	// #include <iostream>
	22
	23	AlphabeticIndexTest::AlphabeticIndexTest() {
	24	}
	25
	26	AlphabeticIndexTest::~AlphabeticIndexTest() {
	27	}
	28
	29	void AlphabeticIndexTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /par/ )
	30	{
	31	if (exec) logln("TestSuite AlphabeticIndex: ");
	32	switch (index) {
	33
	34	case 0: name = "APITest";
	35	if (exec) APITest();
	36	break;
	37
	38	case 1: name = "ManyLocales";
	39	if (exec) ManyLocalesTest();
	40	break;
	41
	42	case 2: name = "HackPinyinTest";
	43	if (exec) HackPinyinTest();
	44	break;
	45
	46	case 3: name = "TestBug9009";
	47	if (exec) TestBug9009();
	48	break;
	49
	50	default: name = "";
	51	break; //needed to end loop
	52	}
	53	}
	54
	55	#define TEST_CHECK_STATUS {if (U_FAILURE(status)) {dataerrln("%s:%d: Test failure. status=%s", \
	56	__FILE__, __LINE__, u_errorName(status)); return;}}
	57
	58	#define TEST_ASSERT(expr) {if ((expr)==FALSE) {errln("%s:%d: Test failure \n", __FILE__, __LINE__);};}
	59
	60	//
	61	// APITest. Invoke every function at least once, and check that it does something.
	62	// Does not attempt to check complete functionality.
	63	//
	64	void AlphabeticIndexTest::APITest() {
65	//
66	// Simple constructor and destructor, getBucketCount()
67	//
68	UErrorCode status = U_ZERO_ERROR;
69	int32_t lc = 0;
70	int32_t i = 0;
71	AlphabeticIndex *index = new AlphabeticIndex(Locale::getEnglish(), status);
72	TEST_CHECK_STATUS;
73	lc = index->getBucketCount(status);
74	TEST_CHECK_STATUS;
75	TEST_ASSERT(28 == lc); // 26 letters plus two under/overflow labels.
76	//printf("getBucketCount() == %d\n", lc);
77	delete index;
78
79	// addLabels()
80
81	status = U_ZERO_ERROR;
82	index = new AlphabeticIndex(Locale::getEnglish(), status);
83	TEST_CHECK_STATUS;
84	UnicodeSet additions;
85	additions.add((UChar32)0x410).add((UChar32)0x415); // A couple of Cyrillic letters
86	index->addLabels(additions, status);
87	TEST_CHECK_STATUS;
88	lc = index->getBucketCount(status);
89	TEST_CHECK_STATUS;
90	// TODO: should get 31. Java also gives 30. Needs fixing
91	TEST_ASSERT(30 == lc); // 26 Latin letters plus
92	// TEST_ASSERT(31 == lc); // 26 Latin letters plus
93	// 2 Cyrillic letters plus
94	// 1 inflow label plus
95	// two under/overflow labels.
96	// std::cout << lc << std::endl;
97	delete index;
98
99
100	// addLabels(Locale)
101
102	status = U_ZERO_ERROR;
103	index = new AlphabeticIndex(Locale::getEnglish(), status);
104	TEST_CHECK_STATUS;
105	AlphabeticIndex &aip = index->addLabels(Locale::getJapanese(), status);
106	TEST_ASSERT(&aip == index);
107	TEST_CHECK_STATUS;
108	lc = index->getBucketCount(status);
109	TEST_CHECK_STATUS;
110	TEST_ASSERT(35 < lc); // Japanese should add a bunch. Don't rely on the exact value.
111	delete index;
112
113	// GetCollator(), Get under/in/over flow labels
114
115	status = U_ZERO_ERROR;
116	index = new AlphabeticIndex(Locale::getGerman(), status);
117	TEST_CHECK_STATUS;
118	Collator *germanCol = Collator::createInstance(Locale::getGerman(), status);
119	TEST_CHECK_STATUS;
120	const RuleBasedCollator &indexCol = index->getCollator();
121	TEST_ASSERT(*germanCol == indexCol);
122	delete germanCol;
123
124	UnicodeString ELLIPSIS; ELLIPSIS.append((UChar32)0x2026);
125	UnicodeString s = index->getUnderflowLabel();
126	TEST_ASSERT(ELLIPSIS == s);
127	s = index->getOverflowLabel();
128	TEST_ASSERT(ELLIPSIS == s);
129	s = index->getInflowLabel();
130	TEST_ASSERT(ELLIPSIS == s);
131	index->setOverflowLabel(UNICODE_STRING_SIMPLE("O"), status);
132	index->setUnderflowLabel(UNICODE_STRING_SIMPLE("U"), status).setInflowLabel(UNICODE_STRING_SIMPLE("I"), status);
133	s = index->getUnderflowLabel();
134	TEST_ASSERT(UNICODE_STRING_SIMPLE("U") == s);
135	s = index->getOverflowLabel();
136	TEST_ASSERT(UNICODE_STRING_SIMPLE("O") == s);
137	s = index->getInflowLabel();
138	TEST_ASSERT(UNICODE_STRING_SIMPLE("I") == s);
139
140
141
142
143	delete index;
144
145
146
147	const UnicodeString adam = UNICODE_STRING_SIMPLE("Adam");
148	const UnicodeString baker = UNICODE_STRING_SIMPLE("Baker");
149	const UnicodeString charlie = UNICODE_STRING_SIMPLE("Charlie");
150	const UnicodeString chad = UNICODE_STRING_SIMPLE("Chad");
151	const UnicodeString zed = UNICODE_STRING_SIMPLE("Zed");
152	const UnicodeString Cyrillic = UNICODE_STRING_SIMPLE("\\u0410\\u0443\\u0435").unescape();
153
154	// addRecord(), verify that it comes back out.
155	//
156	status = U_ZERO_ERROR;
157	index = new AlphabeticIndex(Locale::getEnglish(), status);
158	TEST_CHECK_STATUS;
159	index->addRecord(UnicodeString("Adam"), this, status);
160	UBool b;
161	TEST_CHECK_STATUS;
162	index->resetBucketIterator(status);
163	TEST_CHECK_STATUS;
164	index->nextBucket(status); // Move to underflow label
165	index->nextBucket(status); // Move to "A"
166	TEST_CHECK_STATUS;
167	const UnicodeString &label2 = index->getBucketLabel();
168	UnicodeString A_STR = UNICODE_STRING_SIMPLE("A");
169	TEST_ASSERT(A_STR == label2);
170
171	b = index->nextRecord(status);
172	TEST_CHECK_STATUS;
173	TEST_ASSERT(b);
174	const UnicodeString &itemName = index->getRecordName();
175	TEST_ASSERT(adam == itemName);
176
177	const void *itemContext = index->getRecordData();
178	TEST_ASSERT(itemContext == this);
179
180	delete index;
181
182	// clearRecords, addRecord(), Iteration
183
184	status = U_ZERO_ERROR;
185	index = new AlphabeticIndex(Locale::getEnglish(), status);
186	TEST_CHECK_STATUS;
187	while (index->nextBucket(status)) {
188	TEST_CHECK_STATUS;
189	while (index->nextRecord(status)) {
190	TEST_CHECK_STATUS;
191	TEST_ASSERT(FALSE); // No items have been added.
192	}
193	TEST_CHECK_STATUS;
194	}
195
196	index->addRecord(adam, NULL, status);
197	index->addRecord(baker, NULL, status);
198	index->addRecord(charlie, NULL, status);
199	index->addRecord(chad, NULL, status);
200	TEST_CHECK_STATUS;
201	int itemCount = 0;
202	index->resetBucketIterator(status);
203	while (index->nextBucket(status)) {
204	TEST_CHECK_STATUS;
205	while (index->nextRecord(status)) {
206	TEST_CHECK_STATUS;
207	++itemCount;
208	}
209	}
210	TEST_CHECK_STATUS;
211	TEST_ASSERT(itemCount == 4);
212
213	TEST_ASSERT(index->nextBucket(status) == FALSE);
214	index->resetBucketIterator(status);
215	TEST_CHECK_STATUS;
216	TEST_ASSERT(index->nextBucket(status) == TRUE);
217
218	index->clearRecords(status);
219	TEST_CHECK_STATUS;
220	index->resetBucketIterator(status);
221	while (index->nextBucket(status)) {
222	TEST_CHECK_STATUS;
223	while (index->nextRecord(status)) {
224	TEST_ASSERT(FALSE); // No items have been added.
225	}
226	}
227	TEST_CHECK_STATUS;
228	delete index;
229
230	// getBucketLabel(), getBucketType()
231
232	status = U_ZERO_ERROR;
233	index = new AlphabeticIndex(Locale::getEnglish(), status);
234	TEST_CHECK_STATUS;
235	index->setUnderflowLabel(adam, status).setOverflowLabel(charlie, status);
236	TEST_CHECK_STATUS;
237	for (i=0; index->nextBucket(status); i++) {
238	TEST_CHECK_STATUS;
239	UnicodeString label = index->getBucketLabel();
240	UAlphabeticIndexLabelType type = index->getBucketLabelType();
241	if (i == 0) {
242	TEST_ASSERT(type == U_ALPHAINDEX_UNDERFLOW);
243	TEST_ASSERT(label == adam);
244	} else if (i <= 26) {
245	// Labels A - Z for English locale
246	TEST_ASSERT(type == U_ALPHAINDEX_NORMAL);
247	UnicodeString expectedLabel((UChar)(0x40 + i));
248	TEST_ASSERT(expectedLabel == label);
249	} else if (i == 27) {
250	TEST_ASSERT(type == U_ALPHAINDEX_OVERFLOW);
251	TEST_ASSERT(label == charlie);
252	} else {
253	TEST_ASSERT(FALSE);
254	}
255	}
256	TEST_ASSERT(i==28);
257	delete index;
258
259	// getBucketIndex()
260
261	status = U_ZERO_ERROR;
262	index = new AlphabeticIndex(Locale::getEnglish(), status);
263	TEST_CHECK_STATUS;
264	int32_t n = index->getBucketIndex(adam, status);
265	TEST_CHECK_STATUS;
266	TEST_ASSERT(n == 1); /* Label #0 is underflow, 1 is A, etc. */
267	n = index->getBucketIndex(baker, status);
268	TEST_ASSERT(n == 2);
269	n = index->getBucketIndex(Cyrillic, status);
270	TEST_ASSERT(n == 27); // Overflow label
271	n = index->getBucketIndex(zed, status);
272	TEST_ASSERT(n == 26);
273
274	for (i=0; index->nextBucket(status); i++) {
275	n = index->getBucketIndex();
276	TEST_ASSERT(n == i);
277	UnicodeString label = index->getBucketLabel();
278	TEST_ASSERT(n == i);
279	}
280	TEST_ASSERT(i == 28);
281
282	delete index;
283	index = new AlphabeticIndex(Locale::createFromName("ru"), status);
284	//Locale loc = Locale::createFromName(localeName);
285	TEST_CHECK_STATUS;
286	n = index->getBucketIndex(adam, status);
287	TEST_CHECK_STATUS;
288	TEST_ASSERT(n == 0); // Label #0 is underflow
289	n = index->getBucketIndex(baker, status);
290	TEST_ASSERT(n == 0);
291	n = index->getBucketIndex(Cyrillic, status);
292	TEST_ASSERT(n == 1); // Overflow label
293	n = index->getBucketIndex(zed, status);
294	TEST_ASSERT(n == 0);
295
296	delete index;
297
298	}
299
300
301	static const char * KEY_LOCALES[] = {
302	"en", "es", "de", "fr", "ja", "it", "tr", "pt", "zh", "nl",
303	"pl", "ar", "ru", "zh_Hant", "ko", "th", "sv", "fi", "da",
304	"he", "nb", "el", "hr", "bg", "sk", "lt", "vi", "lv", "sr",
305	"pt_PT", "ro", "hu", "cs", "id", "sl", "fil", "fa", "uk",
306	"ca", "hi", "et", "eu", "is", "sw", "ms", "bn", "am", "ta",
307	"te", "mr", "ur", "ml", "kn", "gu", "or", ""};
308
309
310	void AlphabeticIndexTest::ManyLocalesTest() {
311	UErrorCode status = U_ZERO_ERROR;
312	int32_t lc = 0;
313	AlphabeticIndex *index = NULL;
314
315	for (int i=0; ; ++i) {
316	status = U_ZERO_ERROR;
317	const char *localeName = KEY_LOCALES[i];
318	if (localeName[0] == 0) {
319	break;
320	}
321	// std::cout << localeName << " ";
322	Locale loc = Locale::createFromName(localeName);
323	index = new AlphabeticIndex(loc, status);
324	TEST_CHECK_STATUS;
325	lc = index->getBucketCount(status);
326	TEST_CHECK_STATUS;
327	// std::cout << "getBucketCount() == " << lc << std::endl;
328
329	while (index->nextBucket(status)) {
330	TEST_CHECK_STATUS;
331	const UnicodeString &label = index->getBucketLabel();
332	TEST_ASSERT(label.length()>0);
333	// std::string ss;
334	// std::cout << ":" << label.toUTF8String(ss);
335	}
336	// std::cout << ":" << std::endl;
337
338
339	delete index;
340	}
341	}
342
343
344	// Test data for Pinyin based indexes.
345	// The Chinese characters should be distributed under latin labels in
346	// an index.
347
348	static const char *pinyinTestData[] = {
349	"\\u0101", "\\u5416", "\\u58ba", //
350	"b", "\\u516b", "\\u62d4", "\\u8500", //
351	"c", "\\u5693", "\\u7938", "\\u9e7e", //
352	"d", "\\u5491", "\\u8fcf", "\\u964a", //
353	"\\u0113","\\u59b8", "\\u92e8", "\\u834b", //
354	"f", "\\u53d1", "\\u9197", "\\u99a5", //
355	"g", "\\u7324", "\\u91d3", "\\u8142", //
356	"h", "\\u598e", "\\u927f", "\\u593b", //
357	"j", "\\u4e0c", "\\u6785", "\\u9d58", //
358	"k", "\\u5494", "\\u958b", "\\u7a52", //
359	"l", "\\u5783", "\\u62c9", "\\u9ba5", //
360	"m", "\\u5638", "\\u9ebb", "\\u65c0", //
361	"n", "\\u62ff", "\\u80ad", "\\u685b", //
362	"\\u014D", "\\u5662", "\\u6bee", "\\u8bb4", //
363	"p", "\\u5991", "\\u8019", "\\u8c31", //
364	"q", "\\u4e03", "\\u6053", "\\u7f56", //
365	"r", "\\u5465", "\\u72aa", "\\u6e03", //
366	"s", "\\u4ee8", "\\u9491", "\\u93c1", //
367	"t", "\\u4ed6", "\\u9248", "\\u67dd", //
368	"w", "\\u5c72", "\\u5558", "\\u5a7a", //
369	"x", "\\u5915", "\\u5438", "\\u6bbe", //
370	"y", "\\u4e2b", "\\u82bd", "\\u8574", //
371	"z", "\\u5e00", "\\u707d", "\\u5c0a",
372	NULL
373	};
374
375	void AlphabeticIndexTest::HackPinyinTest() {
376	UErrorCode status = U_ZERO_ERROR;
377	AlphabeticIndex aindex(Locale::createFromName("zh"), status);
378	TEST_CHECK_STATUS;
379
380	UnicodeString names[sizeof(pinyinTestData) / sizeof(pinyinTestData[0])];
381	int32_t nameCount;
382	for (nameCount=0; pinyinTestData[nameCount] != NULL; nameCount++) {
383	names[nameCount] = UnicodeString(pinyinTestData[nameCount], -1, UnicodeString::kInvariant).unescape();
384	aindex.addRecord(names[nameCount], &names[nameCount], status);
385	TEST_CHECK_STATUS;
386	if (U_FAILURE(status)) {
387	return;
388	}
389	}
390	TEST_ASSERT(nameCount == aindex.getRecordCount(status));
391
392	// Weak checking: make sure that none of the Chinese names landed in the overflow bucket
393	// of the index, and that the names are distributed among several buckets.
394	// (Exact expected data would be subject to change with evolution of the collation rules.)
395
396	int32_t bucketCount = 0;
397	int32_t filledBucketCount = 0;
398	while (aindex.nextBucket(status)) {
399	bucketCount++;
400	UnicodeString label = aindex.getBucketLabel();
401	// std::string s;
402	// std::cout << label.toUTF8String(s) << ": ";
403
404	UBool bucketHasContents = FALSE;
405	while (aindex.nextRecord(status)) {
406	bucketHasContents = TRUE;
407	UnicodeString name = aindex.getRecordName();
408	if (aindex.getBucketLabelType() != U_ALPHAINDEX_NORMAL) {
409	errln("File %s, Line %d, Name \"\\u%x\" is in an under or overflow bucket.",
410	__FILE__, __LINE__, name.char32At(0));
411	}
412	// s.clear();
413	// std::cout << aindex.getRecordName().toUTF8String(s) << " ";
414	}
415	if (bucketHasContents) {
416	filledBucketCount++;
417	}
418	// std::cout << std::endl;
419	}
420	TEST_ASSERT(bucketCount > 25);
421	TEST_ASSERT(filledBucketCount > 15);
422	}
423
424
425	void AlphabeticIndexTest::TestBug9009() {
426	UErrorCode status = U_ZERO_ERROR;
427	Locale loc("root");
428	AlphabeticIndex aindex(loc, status);
429	TEST_CHECK_STATUS;
430	aindex.nextBucket(status); // Crash here before bug was fixed.
431	TEST_CHECK_STATUS;
432	}
433
434
435	#endif