1/********************************************************************
2 * COPYRIGHT:
3 * Copyright (c) 1997-2013, International Business Machines Corporation and
4 * others. All Rights Reserved.
5 ********************************************************************/
6//===============================================================================
7//
8// File apitest.cpp
9//
10//
11//
12// Created by: Helena Shih
13//
14// Modification History:
15//
16//  Date         Name          Description
17//  2/5/97      aliu        Added streamIn and streamOut methods.  Added
18//                          constructor which reads RuleBasedCollator object from
19//                          a binary file.  Added writeToFile method which streams
20//                          RuleBasedCollator out to a binary file.  The streamIn
21//                          and streamOut methods use istream and ostream objects
22//                          in binary mode.
23//  6/30/97     helena      Added tests for CollationElementIterator::setText, getOffset
24//                          setOffset and DecompositionIterator::getOffset, setOffset.
25//                          DecompositionIterator is made public so add class scope
26//                          testing.
27//  02/10/98    damiba      Added test for compare(UnicodeString&, UnicodeString&, int32_t)
28//===============================================================================
29
30#include "unicode/utypes.h"
31
32#if !UCONFIG_NO_COLLATION
33
34#include "unicode/localpointer.h"
35#include "unicode/coll.h"
36#include "unicode/tblcoll.h"
37#include "unicode/coleitr.h"
38#include "unicode/sortkey.h"
39#include "apicoll.h"
40#include "unicode/chariter.h"
41#include "unicode/schriter.h"
42#include "unicode/ustring.h"
43#include "unicode/ucol.h"
44
45#include "sfwdchit.h"
46#include "cmemory.h"
47#include <stdlib.h>
48
49#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
50
51void
52CollationAPITest::doAssert(UBool condition, const char *message)
53{
54    if (!condition) {
55        errln(UnicodeString("ERROR : ") + message);
56    }
57}
58
59#ifdef U_USE_COLLATION_OBSOLETE_2_6
60/*
61 * Test Collator::createInstance(... version...) for some locale. Called by TestProperty().
62 */
63static void
64TestOpenVersion(IntlTest &test, const Locale &locale) {
65    UVersionInfo version1, version2;
66    Collator *collator1, *collator2;
67    UErrorCode errorCode;
68
69    errorCode=U_ZERO_ERROR;
70    collator1=Collator::createInstance(locale, errorCode);
71    if(U_SUCCESS(errorCode)) {
72        /* get the current version */
73        collator1->getVersion(version1);
74        delete collator1;
75
76        /* try to get that same version again */
77        collator2=Collator::createInstance(locale, version1, errorCode);
78        if(U_SUCCESS(errorCode)) {
79            collator2->getVersion(version2);
80            if(0!=uprv_memcmp(version1, version2, sizeof(UVersionInfo))) {
81                test.errln("error: Collator::createInstance(\"%s\", (%s collator)->getVersion()) returns a different collator\n", locale.getName(), locale.getName());
82            }
83            delete collator2;
84        } else {
85            test.errln("error: Collator::createInstance(\"%s\", (%s collator)->getVersion()) fails: %s\n", locale.getName(), locale.getName(), u_errorName(errorCode));
86        }
87    }
88}
89#endif
90
91// Collator Class Properties
92// ctor, dtor, createInstance, compare, getStrength/setStrength
93// getDecomposition/setDecomposition, getDisplayName
94void
95CollationAPITest::TestProperty(/* char* par */)
96{
97    UErrorCode success = U_ZERO_ERROR;
98    Collator *col = 0;
99    /*
100     * Expected version of the English collator.
101     * Currently, the major/minor version numbers change when the builder code
102     * changes,
103     * number 2 is from the tailoring data version and
104     * number 3 is the UCA version.
105     * This changes with every UCA version change, and the expected value
106     * needs to be adjusted.
107     * Same in cintltst/capitst.c.
108     */
109    UVersionInfo currVersionArray = {0x31, 0xC0, 0x05, 0x2A};  // from ICU 4.4/UCA 5.2
110    UVersionInfo versionArray;
111
112    logln("The property tests begin : ");
113    logln("Test ctors : ");
114    col = Collator::createInstance(Locale::getEnglish(), success);
115    if (U_FAILURE(success)){
116        errcheckln(success, "Default Collator creation failed. - %s", u_errorName(success));
117        return;
118    }
119
120    StringEnumeration* kwEnum = col->getKeywordValuesForLocale("", Locale::getEnglish(),true,success);
121    if (U_FAILURE(success)){
122        errcheckln(success, "Get Keyword Values for Locale failed. - %s", u_errorName(success));
123        return;
124    }
125    delete kwEnum;
126
127    col->getVersion(versionArray);
128    // Check for a version greater than some value rather than equality
129    // so that we need not update the expected version each time.
130    if (uprv_memcmp(versionArray, currVersionArray, 4)<0) {
131      errln("Testing Collator::getVersion() - unexpected result: %02x.%02x.%02x.%02x",
132            versionArray[0], versionArray[1], versionArray[2], versionArray[3]);
133    } else {
134      logln("Collator::getVersion() result: %02x.%02x.%02x.%02x",
135            versionArray[0], versionArray[1], versionArray[2], versionArray[3]);
136    }
137
138    doAssert((col->compare("ab", "abc") == Collator::LESS), "ab < abc comparison failed");
139    doAssert((col->compare("ab", "AB") == Collator::LESS), "ab < AB comparison failed");
140    doAssert((col->compare("blackbird", "black-bird") == Collator::GREATER), "black-bird > blackbird comparison failed");
141    doAssert((col->compare("black bird", "black-bird") == Collator::LESS), "black bird > black-bird comparison failed");
142    doAssert((col->compare("Hello", "hello") == Collator::GREATER), "Hello > hello comparison failed");
143    doAssert((col->compare("","",success) == UCOL_EQUAL), "Comparison between empty strings failed");
144
145    doAssert((col->compareUTF8("\x61\x62\xc3\xa4", "\x61\x62\xc3\x9f", success) == UCOL_LESS), "ab a-umlaut < ab sharp-s UTF-8 comparison failed");
146    success = U_ZERO_ERROR;
147    {
148        UnicodeString abau=UNICODE_STRING_SIMPLE("\\x61\\x62\\xe4").unescape();
149        UnicodeString abss=UNICODE_STRING_SIMPLE("\\x61\\x62\\xdf").unescape();
150        UCharIterator abauIter, abssIter;
151        uiter_setReplaceable(&abauIter, &abau);
152        uiter_setReplaceable(&abssIter, &abss);
153        doAssert((col->compare(abauIter, abssIter, success) == UCOL_LESS), "ab a-umlaut < ab sharp-s UCharIterator comparison failed");
154        success = U_ZERO_ERROR;
155    }
156
157    /*start of update [Bertrand A. D. 02/10/98]*/
158    doAssert((col->compare("ab", "abc", 2) == Collator::EQUAL), "ab = abc with length 2 comparison failed");
159    doAssert((col->compare("ab", "AB", 2) == Collator::LESS), "ab < AB  with length 2 comparison failed");
160    doAssert((col->compare("ab", "Aa", 1) == Collator::LESS), "ab < Aa  with length 1 comparison failed");
161    doAssert((col->compare("ab", "Aa", 2) == Collator::GREATER), "ab > Aa  with length 2 comparison failed");
162    doAssert((col->compare("black-bird", "blackbird", 5) == Collator::EQUAL), "black-bird = blackbird with length of 5 comparison failed");
163    doAssert((col->compare("black bird", "black-bird", 10) == Collator::LESS), "black bird < black-bird with length 10 comparison failed");
164    doAssert((col->compare("Hello", "hello", 5) == Collator::GREATER), "Hello > hello with length 5 comparison failed");
165    /*end of update [Bertrand A. D. 02/10/98]*/
166
167
168    logln("Test ctors ends.");
169    logln("testing Collator::getStrength() method ...");
170    doAssert((col->getStrength() == Collator::TERTIARY), "collation object has the wrong strength");
171    doAssert((col->getStrength() != Collator::PRIMARY), "collation object's strength is primary difference");
172
173
174    logln("testing Collator::setStrength() method ...");
175    col->setStrength(Collator::SECONDARY);
176    doAssert((col->getStrength() != Collator::TERTIARY), "collation object's strength is secondary difference");
177    doAssert((col->getStrength() != Collator::PRIMARY), "collation object's strength is primary difference");
178    doAssert((col->getStrength() == Collator::SECONDARY), "collation object has the wrong strength");
179
180    UnicodeString name;
181
182    logln("Get display name for the US English collation in German : ");
183    logln(Collator::getDisplayName(Locale::getUS(), Locale::getGerman(), name));
184    doAssert((name == UnicodeString("Englisch (Vereinigte Staaten)")), "getDisplayName failed");
185
186    logln("Get display name for the US English collation in English : ");
187    logln(Collator::getDisplayName(Locale::getUS(), Locale::getEnglish(), name));
188    doAssert((name == UnicodeString("English (United States)")), "getDisplayName failed");
189#if 0
190    // weiv : this test is bogus if we're running on any machine that has different default locale than English.
191    // Therefore, it is banned!
192    logln("Get display name for the US English in default locale language : ");
193    logln(Collator::getDisplayName(Locale::US, name));
194    doAssert((name == UnicodeString("English (United States)")), "getDisplayName failed if this is an English machine");
195#endif
196    delete col; col = 0;
197    RuleBasedCollator *rcol = (RuleBasedCollator *)Collator::createInstance("da_DK",
198                                                                            success);
199    doAssert(rcol->getRules().length() != 0, "da_DK rules does not have length 0");
200    delete rcol;
201
202    col = Collator::createInstance(Locale::getFrench(), success);
203    if (U_FAILURE(success))
204    {
205        errln("Creating French collation failed.");
206        return;
207    }
208
209    col->setStrength(Collator::PRIMARY);
210    logln("testing Collator::getStrength() method again ...");
211    doAssert((col->getStrength() != Collator::TERTIARY), "collation object has the wrong strength");
212    doAssert((col->getStrength() == Collator::PRIMARY), "collation object's strength is not primary difference");
213
214    logln("testing French Collator::setStrength() method ...");
215    col->setStrength(Collator::TERTIARY);
216    doAssert((col->getStrength() == Collator::TERTIARY), "collation object's strength is not tertiary difference");
217    doAssert((col->getStrength() != Collator::PRIMARY), "collation object's strength is primary difference");
218    doAssert((col->getStrength() != Collator::SECONDARY), "collation object's strength is secondary difference");
219
220    logln("Create junk collation: ");
221    Locale abcd("ab", "CD", "");
222    success = U_ZERO_ERROR;
223    Collator *junk = 0;
224    junk = Collator::createInstance(abcd, success);
225
226    if (U_FAILURE(success))
227    {
228        errln("Junk collation creation failed, should at least return default.");
229        delete col;
230        return;
231    }
232
233    delete col;
234    col = Collator::createInstance(success);
235    if (U_FAILURE(success))
236    {
237        errln("Creating default collator failed.");
238        delete junk;
239        return;
240    }
241
242    doAssert(((RuleBasedCollator *)col)->getRules() == ((RuleBasedCollator *)junk)->getRules(),
243               "The default collation should be returned.");
244    Collator *frCol = Collator::createInstance(Locale::getCanadaFrench(), success);
245    if (U_FAILURE(success))
246    {
247        errln("Creating fr_CA collator failed.");
248        delete col;
249        delete junk;
250        return;
251    }
252
253    // If the default locale isn't French, the French and non-French collators
254    // should be different
255    if (frCol->getLocale(ULOC_ACTUAL_LOCALE, success) != Locale::getCanadaFrench()) {
256        doAssert((*frCol != *junk), "The junk is the same as the fr_CA collator.");
257    }
258    Collator *aFrCol = frCol->clone();
259    doAssert((*frCol == *aFrCol), "The cloning of a fr_CA collator failed.");
260    logln("Collator property test ended.");
261
262    delete col;
263    delete frCol;
264    delete aFrCol;
265    delete junk;
266
267#ifdef U_USE_COLLATION_OBSOLETE_2_6
268    /* test Collator::createInstance(...version...) */
269    TestOpenVersion(*this, "");
270    TestOpenVersion(*this, "da");
271    TestOpenVersion(*this, "fr");
272    TestOpenVersion(*this, "ja");
273
274    /* try some bogus version */
275    versionArray[0]=0;
276    versionArray[1]=0x99;
277    versionArray[2]=0xc7;
278    versionArray[3]=0xfe;
279    col=Collator::createInstance(Locale(), versionArray, success);
280    if(U_SUCCESS(success)) {
281        errln("error: ucol_openVersion(bogus version) succeeded");
282        delete col;
283    }
284#endif
285}
286
287void
288CollationAPITest::TestRuleBasedColl()
289{
290    RuleBasedCollator *col1, *col2, *col3, *col4;
291    UErrorCode status = U_ZERO_ERROR;
292
293    UnicodeString ruleset1("&9 < a, A < b, B < c, C; ch, cH, Ch, CH < d, D, e, E");
294    UnicodeString ruleset2("&9 < a, A < b, B < c, C < d, D, e, E");
295
296    col1 = new RuleBasedCollator(ruleset1, status);
297    if (U_FAILURE(status)) {
298        errcheckln(status, "RuleBased Collator creation failed. - %s", u_errorName(status));
299        return;
300    }
301    else {
302        logln("PASS: RuleBased Collator creation passed\n");
303    }
304
305    status = U_ZERO_ERROR;
306    col2 = new RuleBasedCollator(ruleset2, status);
307    if (U_FAILURE(status)) {
308        errln("RuleBased Collator creation failed.\n");
309        return;
310    }
311    else {
312        logln("PASS: RuleBased Collator creation passed\n");
313    }
314
315    status = U_ZERO_ERROR;
316    Locale locale("aa", "AA");
317    col3 = (RuleBasedCollator *)Collator::createInstance(locale, status);
318    if (U_FAILURE(status)) {
319        errln("Fallback Collator creation failed.: %s\n");
320        return;
321    }
322    else {
323        logln("PASS: Fallback Collator creation passed\n");
324    }
325    delete col3;
326
327    status = U_ZERO_ERROR;
328    col3 = (RuleBasedCollator *)Collator::createInstance(status);
329    if (U_FAILURE(status)) {
330        errln("Default Collator creation failed.: %s\n");
331        return;
332    }
333    else {
334        logln("PASS: Default Collator creation passed\n");
335    }
336
337    UnicodeString rule1 = col1->getRules();
338    UnicodeString rule2 = col2->getRules();
339    UnicodeString rule3 = col3->getRules();
340
341    doAssert(rule1 != rule2, "Default collator getRules failed");
342    doAssert(rule2 != rule3, "Default collator getRules failed");
343    doAssert(rule1 != rule3, "Default collator getRules failed");
344
345    col4 = new RuleBasedCollator(rule2, status);
346    if (U_FAILURE(status)) {
347        errln("RuleBased Collator creation failed.\n");
348        return;
349    }
350
351    UnicodeString rule4 = col4->getRules();
352    doAssert(rule2 == rule4, "Default collator getRules failed");
353    int32_t length4 = 0;
354    uint8_t *clonedrule4 = col4->cloneRuleData(length4, status);
355    if (U_FAILURE(status)) {
356        errln("Cloned rule data failed.\n");
357        return;
358    }
359
360 //   free(clonedrule4);     BAD API!!!!
361    uprv_free(clonedrule4);
362
363
364    delete col1;
365    delete col2;
366    delete col3;
367    delete col4;
368}
369
370void
371CollationAPITest::TestRules()
372{
373    RuleBasedCollator *coll;
374    UErrorCode status = U_ZERO_ERROR;
375    UnicodeString rules;
376
377    coll = (RuleBasedCollator *)Collator::createInstance(Locale::getEnglish(), status);
378    if (U_FAILURE(status)) {
379        errcheckln(status, "English Collator creation failed. - %s", u_errorName(status));
380        return;
381    }
382    else {
383        logln("PASS: RuleBased Collator creation passed\n");
384    }
385
386    coll->getRules(UCOL_TAILORING_ONLY, rules);
387    if (rules.length() != 0x00) {
388      errln("English tailored rules failed - length is 0x%x expected 0x%x", rules.length(), 0x00);
389    }
390
391    coll->getRules(UCOL_FULL_RULES, rules);
392    if (rules.length() < 0) {
393        errln("English full rules failed");
394    }
395    delete coll;
396}
397
398void
399CollationAPITest::TestDecomposition() {
400  UErrorCode status = U_ZERO_ERROR;
401  Collator *en_US = Collator::createInstance("en_US", status),
402    *el_GR = Collator::createInstance("el_GR", status),
403    *vi_VN = Collator::createInstance("vi_VN", status);
404
405  if (U_FAILURE(status)) {
406    errcheckln(status, "ERROR: collation creation failed. - %s", u_errorName(status));
407    return;
408  }
409
410  /* there is no reason to have canonical decomposition in en_US OR default locale */
411  if (vi_VN->getAttribute(UCOL_NORMALIZATION_MODE, status) != UCOL_ON)
412  {
413    errln("ERROR: vi_VN collation did not have canonical decomposition for normalization!\n");
414  }
415
416  if (el_GR->getAttribute(UCOL_NORMALIZATION_MODE, status) != UCOL_ON)
417  {
418    errln("ERROR: el_GR collation did not have canonical decomposition for normalization!\n");
419  }
420
421  if (en_US->getAttribute(UCOL_NORMALIZATION_MODE, status) != UCOL_OFF)
422  {
423    errln("ERROR: en_US collation had canonical decomposition for normalization!\n");
424  }
425
426  delete en_US;
427  delete el_GR;
428  delete vi_VN;
429}
430
431void
432CollationAPITest::TestSafeClone() {
433    static const int CLONETEST_COLLATOR_COUNT = 3;
434    Collator *someCollators [CLONETEST_COLLATOR_COUNT];
435    Collator *col;
436    UErrorCode err = U_ZERO_ERROR;
437    int index;
438
439    UnicodeString test1("abCda");
440    UnicodeString test2("abcda");
441
442    /* one default collator & two complex ones */
443    someCollators[0] = Collator::createInstance("en_US", err);
444    someCollators[1] = Collator::createInstance("ko", err);
445    someCollators[2] = Collator::createInstance("ja_JP", err);
446    if(U_FAILURE(err)) {
447      errcheckln(err, "Couldn't instantiate collators. Error: %s", u_errorName(err));
448      delete someCollators[0];
449      delete someCollators[1];
450      delete someCollators[2];
451      return;
452    }
453
454    /* change orig & clone & make sure they are independent */
455
456    for (index = 0; index < CLONETEST_COLLATOR_COUNT; index++)
457    {
458        col = someCollators[index]->safeClone();
459        if (col == 0) {
460            errln("SafeClone of collator should not return null\n");
461            break;
462        }
463        col->setStrength(Collator::TERTIARY);
464        someCollators[index]->setStrength(Collator::PRIMARY);
465        col->setAttribute(UCOL_CASE_LEVEL, UCOL_OFF, err);
466        someCollators[index]->setAttribute(UCOL_CASE_LEVEL, UCOL_OFF, err);
467
468        doAssert(col->greater(test1, test2), "Result should be \"abCda\" >>> \"abcda\" ");
469        doAssert(someCollators[index]->equals(test1, test2), "Result should be \"abcda\" == \"abCda\"");
470        delete col;
471        delete someCollators[index];
472    }
473}
474
475void
476CollationAPITest::TestHashCode(/* char* par */)
477{
478    logln("hashCode tests begin.");
479    UErrorCode success = U_ZERO_ERROR;
480    Collator *col1 = 0;
481    col1 = Collator::createInstance(Locale::getEnglish(), success);
482    if (U_FAILURE(success))
483    {
484        errcheckln(success, "Default collation creation failed. - %s", u_errorName(success));
485        return;
486    }
487
488    Collator *col2 = 0;
489    Locale dk("da", "DK", "");
490    col2 = Collator::createInstance(dk, success);
491    if (U_FAILURE(success))
492    {
493        errln("Danish collation creation failed.");
494        return;
495    }
496
497    Collator *col3 = 0;
498    col3 = Collator::createInstance(Locale::getEnglish(), success);
499    if (U_FAILURE(success))
500    {
501        errln("2nd default collation creation failed.");
502        return;
503    }
504
505    logln("Collator::hashCode() testing ...");
506
507    doAssert(col1->hashCode() != col2->hashCode(), "Hash test1 result incorrect" );
508    doAssert(!(col1->hashCode() == col2->hashCode()), "Hash test2 result incorrect" );
509    doAssert(col1->hashCode() == col3->hashCode(), "Hash result not equal" );
510
511    logln("hashCode tests end.");
512    delete col1;
513    delete col2;
514
515    UnicodeString test1("Abcda");
516    UnicodeString test2("abcda");
517
518    CollationKey sortk1, sortk2, sortk3;
519    UErrorCode status = U_ZERO_ERROR;
520
521    col3->getCollationKey(test1, sortk1, status);
522    col3->getCollationKey(test2, sortk2, status);
523    col3->getCollationKey(test2, sortk3, status);
524
525    doAssert(sortk1.hashCode() != sortk2.hashCode(), "Hash test1 result incorrect");
526    doAssert(sortk2.hashCode() == sortk3.hashCode(), "Hash result not equal" );
527
528    delete col3;
529}
530
531//----------------------------------------------------------------------------
532// CollationKey -- Tests the CollationKey methods
533//
534void
535CollationAPITest::TestCollationKey(/* char* par */)
536{
537    logln("testing CollationKey begins...");
538    Collator *col = 0;
539    UErrorCode success=U_ZERO_ERROR;
540    col = Collator::createInstance(Locale::getEnglish(), success);
541    if (U_FAILURE(success))
542    {
543        errcheckln(success, "Default collation creation failed. - %s", u_errorName(success));
544        return;
545    }
546    col->setStrength(Collator::TERTIARY);
547
548    CollationKey sortk1, sortk2;
549    UnicodeString test1("Abcda"), test2("abcda");
550    UErrorCode key1Status = U_ZERO_ERROR, key2Status = U_ZERO_ERROR;
551
552    logln("Testing weird arguments");
553    col->getCollationKey(NULL, 0, sortk1, key1Status);
554    // key gets reset here
555    int32_t length;
556    sortk1.getByteArray(length);
557    doAssert(sortk1.isBogus() == FALSE && length == 0,
558             "Empty string should return an empty collation key");
559    // bogus key returned here
560    key1Status = U_ILLEGAL_ARGUMENT_ERROR;
561    col->getCollationKey(NULL, 0, sortk1, key1Status);
562    doAssert(sortk1.isBogus() && (sortk1.getByteArray(length), length) == 0,
563        "Error code should return bogus collation key");
564
565    key1Status = U_ZERO_ERROR;
566    logln("Use tertiary comparison level testing ....");
567
568    col->getCollationKey(test1, sortk1, key1Status);
569    doAssert((sortk1.compareTo(col->getCollationKey(test2, sortk2, key2Status)))
570                 == Collator::GREATER,
571                "Result should be \"Abcda\" >>> \"abcda\"");
572
573    CollationKey sortk3(sortk2), sortkNew, sortkEmpty;
574
575
576    sortkNew = sortk1;
577    doAssert((sortk1 != sortk2), "The sort keys should be different");
578    doAssert((sortk1.hashCode() != sortk2.hashCode()), "sort key hashCode() failed");
579    doAssert((sortk2 == sortk3), "The sort keys should be the same");
580    doAssert((sortk1 == sortkNew), "The sort keys assignment failed");
581    doAssert((sortk1.hashCode() == sortkNew.hashCode()), "sort key hashCode() failed");
582    doAssert((sortkNew != sortk3), "The sort keys should be different");
583    doAssert(sortk1.compareTo(sortk3) == Collator::GREATER, "Result should be \"Abcda\" >>> \"abcda\"");
584    doAssert(sortk2.compareTo(sortk3) == Collator::EQUAL, "Result should be \"abcda\" == \"abcda\"");
585    doAssert(sortkEmpty.compareTo(sortk1) == Collator::LESS, "Result should be (empty key) <<< \"Abcda\"");
586    doAssert(sortk1.compareTo(sortkEmpty) == Collator::GREATER, "Result should be \"Abcda\" >>> (empty key)");
587    doAssert(sortkEmpty.compareTo(sortkEmpty) == Collator::EQUAL, "Result should be (empty key) == (empty key)");
588    doAssert(sortk1.compareTo(sortk3, success) == UCOL_GREATER, "Result should be \"Abcda\" >>> \"abcda\"");
589    doAssert(sortk2.compareTo(sortk3, success) == UCOL_EQUAL, "Result should be \"abcda\" == \"abcda\"");
590    doAssert(sortkEmpty.compareTo(sortk1, success) == UCOL_LESS, "Result should be (empty key) <<< \"Abcda\"");
591    doAssert(sortk1.compareTo(sortkEmpty, success) == UCOL_GREATER, "Result should be \"Abcda\" >>> (empty key)");
592    doAssert(sortkEmpty.compareTo(sortkEmpty, success) == UCOL_EQUAL, "Result should be (empty key) == (empty key)");
593
594    int32_t    cnt1, cnt2, cnt3, cnt4;
595
596    const uint8_t* byteArray1 = sortk1.getByteArray(cnt1);
597    const uint8_t* byteArray2 = sortk2.getByteArray(cnt2);
598
599    const uint8_t* byteArray3 = 0;
600    byteArray3 = sortk1.getByteArray(cnt3);
601
602    const uint8_t* byteArray4 = 0;
603    byteArray4 = sortk2.getByteArray(cnt4);
604
605    CollationKey sortk4(byteArray1, cnt1), sortk5(byteArray2, cnt2);
606    CollationKey sortk6(byteArray3, cnt3), sortk7(byteArray4, cnt4);
607
608    doAssert(sortk1.compareTo(sortk4) == Collator::EQUAL, "CollationKey::toByteArray(sortk1) Failed.");
609    doAssert(sortk2.compareTo(sortk5) == Collator::EQUAL, "CollationKey::toByteArray(sortk2) Failed.");
610    doAssert(sortk4.compareTo(sortk5) == Collator::GREATER, "sortk4 >>> sortk5 Failed");
611    doAssert(sortk1.compareTo(sortk6) == Collator::EQUAL, "CollationKey::getByteArray(sortk1) Failed.");
612    doAssert(sortk2.compareTo(sortk7) == Collator::EQUAL, "CollationKey::getByteArray(sortk2) Failed.");
613    doAssert(sortk6.compareTo(sortk7) == Collator::GREATER, "sortk6 >>> sortk7 Failed");
614
615    logln("Equality tests : ");
616    doAssert(sortk1 == sortk4, "sortk1 == sortk4 Failed.");
617    doAssert(sortk2 == sortk5, "sortk2 == sortk5 Failed.");
618    doAssert(sortk1 != sortk5, "sortk1 != sortk5 Failed.");
619    doAssert(sortk1 == sortk6, "sortk1 == sortk6 Failed.");
620    doAssert(sortk2 == sortk7, "sortk2 == sortk7 Failed.");
621    doAssert(sortk1 != sortk7, "sortk1 != sortk7 Failed.");
622
623    byteArray1 = 0;
624    byteArray2 = 0;
625
626    sortk3 = sortk1;
627    doAssert(sortk1 == sortk3, "sortk1 = sortk3 assignment Failed.");
628    doAssert(sortk2 != sortk3, "sortk2 != sortk3 Failed.");
629    logln("testing sortkey ends...");
630
631    col->setStrength(Collator::SECONDARY);
632    doAssert(col->getCollationKey(test1, sortk1, key1Status).compareTo(
633                                  col->getCollationKey(test2, sortk2, key2Status))
634                                  == Collator::EQUAL,
635                                  "Result should be \"Abcda\" == \"abcda\"");
636    delete col;
637}
638
639//----------------------------------------------------------------------------
640// Tests the CollatorElementIterator class.
641// ctor, RuleBasedCollator::createCollationElementIterator(), operator==, operator!=
642//
643void
644CollationAPITest::TestElemIter(/* char* par */)
645{
646    logln("testing sortkey begins...");
647    Collator *col = 0;
648    UErrorCode success = U_ZERO_ERROR;
649    col = Collator::createInstance(Locale::getEnglish(), success);
650    if (U_FAILURE(success))
651    {
652        errcheckln(success, "Default collation creation failed. - %s", u_errorName(success));
653        return;
654    }
655
656    UnicodeString testString1("XFILE What subset of all possible test cases has the highest probability of detecting the most errors?");
657    UnicodeString testString2("Xf_ile What subset of all possible test cases has the lowest probability of detecting the least errors?");
658    logln("Constructors and comparison testing....");
659    CollationElementIterator *iterator1 = ((RuleBasedCollator*)col)->createCollationElementIterator(testString1);
660
661    CharacterIterator *chariter=new StringCharacterIterator(testString1);
662    CollationElementIterator *coliter=((RuleBasedCollator*)col)->createCollationElementIterator(*chariter);
663
664    // copy ctor
665    CollationElementIterator *iterator2 = ((RuleBasedCollator*)col)->createCollationElementIterator(testString1);
666    CollationElementIterator *iterator3 = ((RuleBasedCollator*)col)->createCollationElementIterator(testString2);
667
668    int32_t offset = iterator1->getOffset();
669    if (offset != 0) {
670        errln("Error in getOffset for collation element iterator\n");
671        return;
672    }
673    iterator1->setOffset(6, success);
674    if (U_FAILURE(success)) {
675        errln("Error in setOffset for collation element iterator\n");
676        return;
677    }
678    iterator1->setOffset(0, success);
679    int32_t order1, order2, order3;
680    doAssert((*iterator1 == *iterator2), "The two iterators should be the same");
681    doAssert((*iterator1 != *iterator3), "The two iterators should be different");
682
683    doAssert((*coliter == *iterator1), "The two iterators should be the same");
684    doAssert((*coliter == *iterator2), "The two iterators should be the same");
685    doAssert((*coliter != *iterator3), "The two iterators should be different");
686
687    order1 = iterator1->next(success);
688    if (U_FAILURE(success))
689    {
690        errln("Somehow ran out of memory stepping through the iterator.");
691        return;
692    }
693
694    doAssert((*iterator1 != *iterator2), "The first iterator advance failed");
695    order2 = iterator2->getOffset();
696    doAssert((order1 != order2), "The order result should not be the same");
697    order2 = iterator2->next(success);
698    if (U_FAILURE(success))
699    {
700        errln("Somehow ran out of memory stepping through the iterator.");
701        return;
702    }
703
704    doAssert((*iterator1 == *iterator2), "The second iterator advance failed");
705    doAssert((order1 == order2), "The order result should be the same");
706    order3 = iterator3->next(success);
707    if (U_FAILURE(success))
708    {
709        errln("Somehow ran out of memory stepping through the iterator.");
710        return;
711    }
712
713    doAssert((CollationElementIterator::primaryOrder(order1) ==
714        CollationElementIterator::primaryOrder(order3)), "The primary orders should be the same");
715    doAssert((CollationElementIterator::secondaryOrder(order1) ==
716        CollationElementIterator::secondaryOrder(order3)), "The secondary orders should be the same");
717    doAssert((CollationElementIterator::tertiaryOrder(order1) ==
718        CollationElementIterator::tertiaryOrder(order3)), "The tertiary orders should be the same");
719
720    order1 = iterator1->next(success); order3 = iterator3->next(success);
721    if (U_FAILURE(success))
722    {
723        errln("Somehow ran out of memory stepping through the iterator.");
724        return;
725    }
726
727    doAssert((CollationElementIterator::primaryOrder(order1) ==
728        CollationElementIterator::primaryOrder(order3)), "The primary orders should be identical");
729    doAssert((CollationElementIterator::tertiaryOrder(order1) !=
730        CollationElementIterator::tertiaryOrder(order3)), "The tertiary orders should be different");
731
732    order1 = iterator1->next(success);
733    order3 = iterator3->next(success);
734    /* NO! Secondary orders of two CEs are not related, especially in the case of '_' vs 'I' */
735    /*
736    doAssert((CollationElementIterator::secondaryOrder(order1) !=
737        CollationElementIterator::secondaryOrder(order3)), "The secondary orders should not be the same");
738    */
739    doAssert((order1 != CollationElementIterator::NULLORDER), "Unexpected end of iterator reached");
740
741    iterator1->reset(); iterator2->reset(); iterator3->reset();
742    order1 = iterator1->next(success);
743    if (U_FAILURE(success))
744    {
745        errln("Somehow ran out of memory stepping through the iterator.");
746        return;
747    }
748
749    doAssert((*iterator1 != *iterator2), "The first iterator advance failed");
750
751    order2 = iterator2->next(success);
752    if (U_FAILURE(success))
753    {
754        errln("Somehow ran out of memory stepping through the iterator.");
755        return;
756    }
757
758    doAssert((*iterator1 == *iterator2), "The second iterator advance failed");
759    doAssert((order1 == order2), "The order result should be the same");
760
761    order3 = iterator3->next(success);
762    if (U_FAILURE(success))
763    {
764        errln("Somehow ran out of memory stepping through the iterator.");
765        return;
766    }
767
768    doAssert((CollationElementIterator::primaryOrder(order1) ==
769        CollationElementIterator::primaryOrder(order3)), "The primary orders should be the same");
770    doAssert((CollationElementIterator::secondaryOrder(order1) ==
771        CollationElementIterator::secondaryOrder(order3)), "The secondary orders should be the same");
772    doAssert((CollationElementIterator::tertiaryOrder(order1) ==
773        CollationElementIterator::tertiaryOrder(order3)), "The tertiary orders should be the same");
774
775    order1 = iterator1->next(success); order2 = iterator2->next(success); order3 = iterator3->next(success);
776    if (U_FAILURE(success))
777    {
778        errln("Somehow ran out of memory stepping through the iterator.");
779        return;
780    }
781
782    doAssert((CollationElementIterator::primaryOrder(order1) ==
783        CollationElementIterator::primaryOrder(order3)), "The primary orders should be identical");
784    doAssert((CollationElementIterator::tertiaryOrder(order1) !=
785        CollationElementIterator::tertiaryOrder(order3)), "The tertiary orders should be different");
786
787    order1 = iterator1->next(success); order3 = iterator3->next(success);
788    if (U_FAILURE(success))
789    {
790        errln("Somehow ran out of memory stepping through the iterator.");
791        return;
792    }
793
794    /* NO! Secondary orders of two CEs are not related, especially in the case of '_' vs 'I' */
795    /*
796    doAssert((CollationElementIterator::secondaryOrder(order1) !=
797        CollationElementIterator::secondaryOrder(order3)), "The secondary orders should not be the same");
798    */
799    doAssert((order1 != CollationElementIterator::NULLORDER), "Unexpected end of iterator reached");
800    doAssert((*iterator2 != *iterator3), "The iterators should be different");
801
802
803    //test error values
804    success=U_UNSUPPORTED_ERROR;
805    Collator *colerror=NULL;
806    colerror=Collator::createInstance(Locale::getEnglish(), success);
807    if (colerror != 0 || success == U_ZERO_ERROR){
808        errln("Error: createInstance(UErrorCode != U_ZERO_ERROR) should just return and not create an instance\n");
809    }
810    int32_t position=coliter->previous(success);
811    if(position != CollationElementIterator::NULLORDER){
812        errln((UnicodeString)"Expected NULLORDER got" + position);
813    }
814    coliter->reset();
815    coliter->setText(*chariter, success);
816    if(!U_FAILURE(success)){
817        errln("Expeceted error");
818    }
819    iterator1->setText((UnicodeString)"hello there", success);
820    if(!U_FAILURE(success)){
821        errln("Expeceted error");
822    }
823
824    delete chariter;
825    delete coliter;
826    delete iterator1;
827    delete iterator2;
828    delete iterator3;
829    delete col;
830
831
832
833    logln("testing CollationElementIterator ends...");
834}
835
836// Test RuleBasedCollator ctor, dtor, operator==, operator!=, clone, copy, and getRules
837void
838CollationAPITest::TestOperators(/* char* par */)
839{
840    UErrorCode success = U_ZERO_ERROR;
841    UnicodeString ruleset1("< a, A < b, B < c, C; ch, cH, Ch, CH < d, D, e, E");
842    UnicodeString ruleset2("< a, A < b, B < c, C < d, D, e, E");
843    RuleBasedCollator *col1 = new RuleBasedCollator(ruleset1, success);
844    if (U_FAILURE(success)) {
845        errcheckln(success, "RuleBasedCollator creation failed. - %s", u_errorName(success));
846        return;
847    }
848    success = U_ZERO_ERROR;
849    RuleBasedCollator *col2 = new RuleBasedCollator(ruleset2, success);
850    if (U_FAILURE(success)) {
851        errln("The RuleBasedCollator constructor failed when building with the 2nd rule set.");
852        return;
853    }
854    logln("The operator tests begin : ");
855    logln("testing operator==, operator!=, clone  methods ...");
856    doAssert((*col1 != *col2), "The two different table collations compared equal");
857    *col1 = *col2;
858    doAssert((*col1 == *col2), "Collator objects not equal after assignment (operator=)");
859
860    success = U_ZERO_ERROR;
861    Collator *col3 = Collator::createInstance(Locale::getEnglish(), success);
862    if (U_FAILURE(success)) {
863        errln("Default collation creation failed.");
864        return;
865    }
866    doAssert((*col1 != *col3), "The two different table collations compared equal");
867    Collator* col4 = col1->clone();
868    Collator* col5 = col3->clone();
869    doAssert((*col1 == *col4), "Cloned collation objects not equal");
870    doAssert((*col3 != *col4), "Two different table collations compared equal");
871    doAssert((*col3 == *col5), "Cloned collation objects not equal");
872    doAssert((*col4 != *col5), "Two cloned collations compared equal");
873
874    const UnicodeString& defRules = ((RuleBasedCollator*)col3)->getRules();
875    RuleBasedCollator* col6 = new RuleBasedCollator(defRules, success);
876    if (U_FAILURE(success)) {
877        errln("Creating default collation with rules failed.");
878        return;
879    }
880    doAssert((((RuleBasedCollator*)col3)->getRules() == col6->getRules()), "Default collator getRules failed");
881
882    success = U_ZERO_ERROR;
883    RuleBasedCollator *col7 = new RuleBasedCollator(ruleset2, Collator::TERTIARY, success);
884    if (U_FAILURE(success)) {
885        errln("The RuleBasedCollator constructor failed when building with the 2nd rule set with tertiary strength.");
886        return;
887    }
888    success = U_ZERO_ERROR;
889    RuleBasedCollator *col8 = new RuleBasedCollator(ruleset2, UCOL_OFF, success);
890    if (U_FAILURE(success)) {
891        errln("The RuleBasedCollator constructor failed when building with the 2nd rule set with Normalizer::NO_OP.");
892        return;
893    }
894    success = U_ZERO_ERROR;
895    RuleBasedCollator *col9 = new RuleBasedCollator(ruleset2, Collator::PRIMARY, UCOL_ON, success);
896    if (U_FAILURE(success)) {
897        errln("The RuleBasedCollator constructor failed when building with the 2nd rule set with tertiary strength and Normalizer::NO_OP.");
898        return;
899    }
900  //  doAssert((*col7 == *col8), "The two equal table collations compared different");
901    doAssert((*col7 != *col9), "The two different table collations compared equal");
902    doAssert((*col8 != *col9), "The two different table collations compared equal");
903
904    logln("operator tests ended.");
905    delete col1;
906    delete col2;
907    delete col3;
908    delete col4;
909    delete col5;
910    delete col6;
911    delete col7;
912    delete col8;
913    delete col9;
914}
915
916// test clone and copy
917void
918CollationAPITest::TestDuplicate(/* char* par */)
919{
920    UErrorCode status = U_ZERO_ERROR;
921    Collator *col1 = Collator::createInstance(Locale::getEnglish(), status);
922    if (U_FAILURE(status)) {
923        logln("Default collator creation failed.");
924        return;
925    }
926    Collator *col2 = col1->clone();
927    doAssert((*col1 == *col2), "Cloned object is not equal to the orginal");
928    UnicodeString *ruleset = new UnicodeString("< a, A < b, B < c, C < d, D, e, E");
929    RuleBasedCollator *col3 = new RuleBasedCollator(*ruleset, status);
930    doAssert((*col1 != *col3), "Cloned object is equal to some dummy");
931    *col3 = *((RuleBasedCollator*)col1);
932    doAssert((*col1 == *col3), "Copied object is not equal to the orginal");
933
934    if (U_FAILURE(status)) {
935        logln("Collation tailoring failed.");
936        return;
937    }
938
939    UCollationResult res;
940    UnicodeString first((UChar)0x0061);
941    UnicodeString second((UChar)0x0062);
942    UnicodeString copiedEnglishRules(((RuleBasedCollator*)col1)->getRules());
943
944    delete col1;
945    delete ruleset;
946
947    // Try using the cloned collators after deleting the original data
948    res = col2->compare(first, second, status);
949    if(res != UCOL_LESS) {
950        errln("a should be less then b after tailoring");
951    }
952    if (((RuleBasedCollator*)col2)->getRules() != copiedEnglishRules) {
953        errln(UnicodeString("English rule difference. ")
954            + copiedEnglishRules + UnicodeString("\ngetRules=") + ((RuleBasedCollator*)col2)->getRules());
955    }
956    res = col3->compare(first, second, status);
957    if(res != UCOL_LESS) {
958        errln("a should be less then b after tailoring");
959    }
960    if (col3->getRules() != copiedEnglishRules) {
961        errln(UnicodeString("English rule difference. ")
962            + copiedEnglishRules + UnicodeString("\ngetRules=") + col3->getRules());
963    }
964
965    delete col2;
966    delete col3;
967}
968
969void
970CollationAPITest::TestCompare(/* char* par */)
971{
972    logln("The compare tests begin : ");
973    Collator *col = 0;
974    UErrorCode success = U_ZERO_ERROR;
975    col = Collator::createInstance(Locale::getEnglish(), success);
976    if (U_FAILURE(success)) {
977        errcheckln(success, "Default collation creation failed. - %s", u_errorName(success));
978        return;
979    }
980    UnicodeString test1("Abcda"), test2("abcda");
981    logln("Use tertiary comparison level testing ....");
982
983    doAssert((!col->equals(test1, test2) ), "Result should be \"Abcda\" != \"abcda\"");
984    doAssert((col->greater(test1, test2) ), "Result should be \"Abcda\" >>> \"abcda\"");
985    doAssert((col->greaterOrEqual(test1, test2) ), "Result should be \"Abcda\" >>> \"abcda\"");
986
987    col->setStrength(Collator::SECONDARY);
988    logln("Use secondary comparison level testing ....");
989
990    doAssert((col->equals(test1, test2) ), "Result should be \"Abcda\" == \"abcda\"");
991    doAssert((!col->greater(test1, test2) ), "Result should be \"Abcda\" == \"abcda\"");
992    doAssert((col->greaterOrEqual(test1, test2) ), "Result should be \"Abcda\" == \"abcda\"");
993
994    col->setStrength(Collator::PRIMARY);
995    logln("Use primary comparison level testing ....");
996
997    doAssert((col->equals(test1, test2) ), "Result should be \"Abcda\" == \"abcda\"");
998    doAssert((!col->greater(test1, test2) ), "Result should be \"Abcda\" == \"abcda\"");
999    doAssert((col->greaterOrEqual(test1, test2) ), "Result should be \"Abcda\" == \"abcda\"");
1000
1001    // Test different APIs
1002    const UChar* t1 = test1.getBuffer();
1003    int32_t t1Len = test1.length();
1004    const UChar* t2 = test2.getBuffer();
1005    int32_t t2Len = test2.length();
1006
1007    doAssert((col->compare(test1, test2) == Collator::EQUAL), "Problem");
1008    doAssert((col->compare(test1, test2, success) == UCOL_EQUAL), "Problem");
1009    doAssert((col->compare(t1, t1Len, t2, t2Len) == Collator::EQUAL), "Problem");
1010    doAssert((col->compare(t1, t1Len, t2, t2Len, success) == UCOL_EQUAL), "Problem");
1011    doAssert((col->compare(test1, test2, t1Len) == Collator::EQUAL), "Problem");
1012    doAssert((col->compare(test1, test2, t1Len, success) == UCOL_EQUAL), "Problem");
1013
1014    col->setAttribute(UCOL_STRENGTH, UCOL_TERTIARY, success);
1015    doAssert((col->compare(test1, test2) == Collator::GREATER), "Problem");
1016    doAssert((col->compare(test1, test2, success) == UCOL_GREATER), "Problem");
1017    doAssert((col->compare(t1, t1Len, t2, t2Len) == Collator::GREATER), "Problem");
1018    doAssert((col->compare(t1, t1Len, t2, t2Len, success) == UCOL_GREATER), "Problem");
1019    doAssert((col->compare(test1, test2, t1Len) == Collator::GREATER), "Problem");
1020    doAssert((col->compare(test1, test2, t1Len, success) == UCOL_GREATER), "Problem");
1021
1022
1023
1024    logln("The compare tests end.");
1025    delete col;
1026}
1027
1028void
1029CollationAPITest::TestGetAll(/* char* par */)
1030{
1031    int32_t count1, count2;
1032    UErrorCode status = U_ZERO_ERROR;
1033
1034    logln("Trying Collator::getAvailableLocales(int&)");
1035
1036    const Locale* list = Collator::getAvailableLocales(count1);
1037    for (int32_t i = 0; i < count1; ++i) {
1038        UnicodeString dispName;
1039        logln(UnicodeString("Locale name: ")
1040            + UnicodeString(list[i].getName())
1041            + UnicodeString(" , the display name is : ")
1042            + UnicodeString(list[i].getDisplayName(dispName)));
1043    }
1044
1045    if (count1 == 0 || list == NULL) {
1046        dataerrln("getAvailableLocales(int&) returned an empty list");
1047    }
1048
1049    logln("Trying Collator::getAvailableLocales()");
1050    StringEnumeration* localeEnum = Collator::getAvailableLocales();
1051    const UnicodeString* locStr;
1052    const char *locCStr;
1053    count2 = 0;
1054
1055    if (localeEnum == NULL) {
1056        dataerrln("getAvailableLocales() returned NULL");
1057        return;
1058    }
1059
1060    while ((locStr = localeEnum->snext(status)) != NULL)
1061    {
1062        logln(UnicodeString("Locale name is: ") + *locStr);
1063        count2++;
1064    }
1065    if (count1 != count2) {
1066        errln("getAvailableLocales(int&) returned %d and getAvailableLocales() returned %d", count1, count2);
1067    }
1068
1069    logln("Trying Collator::getAvailableLocales() clone");
1070    count1 = 0;
1071    StringEnumeration* localeEnum2 = localeEnum->clone();
1072    localeEnum2->reset(status);
1073    while ((locCStr = localeEnum2->next(NULL, status)) != NULL)
1074    {
1075        logln(UnicodeString("Locale name is: ") + UnicodeString(locCStr));
1076        count1++;
1077    }
1078    if (count1 != count2) {
1079        errln("getAvailableLocales(3rd time) returned %d and getAvailableLocales(2nd time) returned %d", count1, count2);
1080    }
1081    if (localeEnum->count(status) != count1) {
1082        errln("localeEnum->count() returned %d and getAvailableLocales() returned %d", localeEnum->count(status), count1);
1083    }
1084    delete localeEnum;
1085    delete localeEnum2;
1086}
1087
1088void CollationAPITest::TestSortKey()
1089{
1090    UErrorCode status = U_ZERO_ERROR;
1091    /*
1092    this is supposed to open default date format, but later on it treats
1093    it like it is "en_US"
1094    - very bad if you try to run the tests on machine where default
1095      locale is NOT "en_US"
1096    */
1097    Collator *col = Collator::createInstance(Locale::getEnglish(), status);
1098    if (U_FAILURE(status)) {
1099        errcheckln(status, "ERROR: Default collation creation failed.: %s\n", u_errorName(status));
1100        return;
1101    }
1102
1103    if (col->getStrength() != Collator::TERTIARY)
1104    {
1105        errln("ERROR: default collation did not have UCOL_DEFAULT_STRENGTH !\n");
1106    }
1107
1108    /* Need to use identical strength */
1109    col->setAttribute(UCOL_STRENGTH, UCOL_IDENTICAL, status);
1110
1111    UChar test1[6] = {0x41, 0x62, 0x63, 0x64, 0x61, 0},
1112          test2[6] = {0x61, 0x62, 0x63, 0x64, 0x61, 0},
1113          test3[6] = {0x61, 0x62, 0x63, 0x64, 0x61, 0};
1114
1115    uint8_t sortkey1[64];
1116    uint8_t sortkey2[64];
1117    uint8_t sortkey3[64];
1118
1119    logln("Use tertiary comparison level testing ....\n");
1120
1121    CollationKey key1;
1122    col->getCollationKey(test1, u_strlen(test1), key1, status);
1123
1124    CollationKey key2;
1125    col->getCollationKey(test2, u_strlen(test2), key2, status);
1126
1127    CollationKey key3;
1128    col->getCollationKey(test3, u_strlen(test3), key3, status);
1129
1130    doAssert(key1.compareTo(key2) == Collator::GREATER,
1131        "Result should be \"Abcda\" > \"abcda\"");
1132    doAssert(key2.compareTo(key1) == Collator::LESS,
1133        "Result should be \"abcda\" < \"Abcda\"");
1134    doAssert(key2.compareTo(key3) == Collator::EQUAL,
1135        "Result should be \"abcda\" ==  \"abcda\"");
1136
1137    // Clone the key2 sortkey for later.
1138    int32_t keylength = 0;
1139    const uint8_t *key2primary_alias = key2.getByteArray(keylength);
1140    LocalArray<uint8_t> key2primary(new uint8_t[keylength]);
1141    memcpy(key2primary.getAlias(), key2primary_alias, keylength);
1142
1143    col->getSortKey(test1, sortkey1, 64);
1144    col->getSortKey(test2, sortkey2, 64);
1145    col->getSortKey(test3, sortkey3, 64);
1146
1147    const uint8_t *tempkey = key1.getByteArray(keylength);
1148    doAssert(memcmp(tempkey, sortkey1, keylength) == 0,
1149        "Test1 string should have the same collation key and sort key");
1150    tempkey = key2.getByteArray(keylength);
1151    doAssert(memcmp(tempkey, sortkey2, keylength) == 0,
1152        "Test2 string should have the same collation key and sort key");
1153    tempkey = key3.getByteArray(keylength);
1154    doAssert(memcmp(tempkey, sortkey3, keylength) == 0,
1155        "Test3 string should have the same collation key and sort key");
1156
1157    col->getSortKey(test1, 5, sortkey1, 64);
1158    col->getSortKey(test2, 5, sortkey2, 64);
1159    col->getSortKey(test3, 5, sortkey3, 64);
1160
1161    tempkey = key1.getByteArray(keylength);
1162    doAssert(memcmp(tempkey, sortkey1, keylength) == 0,
1163        "Test1 string should have the same collation key and sort key");
1164    tempkey = key2.getByteArray(keylength);
1165    doAssert(memcmp(tempkey, sortkey2, keylength) == 0,
1166        "Test2 string should have the same collation key and sort key");
1167    tempkey = key3.getByteArray(keylength);
1168    doAssert(memcmp(tempkey, sortkey3, keylength) == 0,
1169        "Test3 string should have the same collation key and sort key");
1170
1171    UnicodeString strtest1(test1);
1172    col->getSortKey(strtest1, sortkey1, 64);
1173    UnicodeString strtest2(test2);
1174    col->getSortKey(strtest2, sortkey2, 64);
1175    UnicodeString strtest3(test3);
1176    col->getSortKey(strtest3, sortkey3, 64);
1177
1178    tempkey = key1.getByteArray(keylength);
1179    doAssert(memcmp(tempkey, sortkey1, keylength) == 0,
1180        "Test1 string should have the same collation key and sort key");
1181    tempkey = key2.getByteArray(keylength);
1182    doAssert(memcmp(tempkey, sortkey2, keylength) == 0,
1183        "Test2 string should have the same collation key and sort key");
1184    tempkey = key3.getByteArray(keylength);
1185    doAssert(memcmp(tempkey, sortkey3, keylength) == 0,
1186        "Test3 string should have the same collation key and sort key");
1187
1188    logln("Use secondary comparision level testing ...\n");
1189    col->setStrength(Collator::SECONDARY);
1190
1191    col->getCollationKey(test1, u_strlen(test1), key1, status);
1192    col->getCollationKey(test2, u_strlen(test2), key2, status);
1193    col->getCollationKey(test3, u_strlen(test3), key3, status);
1194
1195    doAssert(key1.compareTo(key2) == Collator::EQUAL,
1196        "Result should be \"Abcda\" == \"abcda\"");
1197    doAssert(key2.compareTo(key3) == Collator::EQUAL,
1198        "Result should be \"abcda\" ==  \"abcda\"");
1199
1200    tempkey = key2.getByteArray(keylength);
1201    doAssert(memcmp(tempkey, key2primary.getAlias(), keylength - 1) == 0,
1202             "Binary format for 'abcda' sortkey different for secondary strength!");
1203
1204    col->getSortKey(test1, sortkey1, 64);
1205    col->getSortKey(test2, sortkey2, 64);
1206    col->getSortKey(test3, sortkey3, 64);
1207
1208    tempkey = key1.getByteArray(keylength);
1209    doAssert(memcmp(tempkey, sortkey1, keylength) == 0,
1210        "Test1 string should have the same collation key and sort key");
1211    tempkey = key2.getByteArray(keylength);
1212    doAssert(memcmp(tempkey, sortkey2, keylength) == 0,
1213        "Test2 string should have the same collation key and sort key");
1214    tempkey = key3.getByteArray(keylength);
1215    doAssert(memcmp(tempkey, sortkey3, keylength) == 0,
1216        "Test3 string should have the same collation key and sort key");
1217
1218    col->getSortKey(test1, 5, sortkey1, 64);
1219    col->getSortKey(test2, 5, sortkey2, 64);
1220    col->getSortKey(test3, 5, sortkey3, 64);
1221
1222    tempkey = key1.getByteArray(keylength);
1223    doAssert(memcmp(tempkey, sortkey1, keylength) == 0,
1224        "Test1 string should have the same collation key and sort key");
1225    tempkey = key2.getByteArray(keylength);
1226    doAssert(memcmp(tempkey, sortkey2, keylength) == 0,
1227        "Test2 string should have the same collation key and sort key");
1228    tempkey = key3.getByteArray(keylength);
1229    doAssert(memcmp(tempkey, sortkey3, keylength) == 0,
1230        "Test3 string should have the same collation key and sort key");
1231
1232    col->getSortKey(strtest1, sortkey1, 64);
1233    col->getSortKey(strtest2, sortkey2, 64);
1234    col->getSortKey(strtest3, sortkey3, 64);
1235
1236    tempkey = key1.getByteArray(keylength);
1237    doAssert(memcmp(tempkey, sortkey1, keylength) == 0,
1238        "Test1 string should have the same collation key and sort key");
1239    tempkey = key2.getByteArray(keylength);
1240    doAssert(memcmp(tempkey, sortkey2, keylength) == 0,
1241        "Test2 string should have the same collation key and sort key");
1242    tempkey = key3.getByteArray(keylength);
1243    doAssert(memcmp(tempkey, sortkey3, keylength) == 0,
1244        "Test3 string should have the same collation key and sort key");
1245
1246    logln("testing sortkey ends...");
1247    delete col;
1248}
1249
1250void CollationAPITest::TestSortKeyOverflow() {
1251    IcuTestErrorCode errorCode(*this, "TestSortKeyOverflow()");
1252    LocalPointer<Collator> col(Collator::createInstance(Locale::getEnglish(), errorCode));
1253    if (errorCode.logDataIfFailureAndReset("Collator::createInstance(English) failed")) {
1254        return;
1255    }
1256    col->setAttribute(UCOL_STRENGTH, UCOL_PRIMARY, errorCode);
1257    UChar i_and_phi[] = { 0x438, 0x3c6 };  // Cyrillic small i & Greek small phi.
1258    // The sort key should be 6 bytes:
1259    // 2 bytes for the Cyrillic i, 1 byte for the primary-compression terminator,
1260    // 2 bytes for the Greek phi, and 1 byte for the NUL terminator.
1261    uint8_t sortKey[12];
1262    int32_t length = col->getSortKey(i_and_phi, 2, sortKey, LENGTHOF(sortKey));
1263    uint8_t sortKey2[12];
1264    for (int32_t capacity = 0; capacity < length; ++capacity) {
1265        uprv_memset(sortKey2, 2, LENGTHOF(sortKey2));
1266        int32_t length2 = col->getSortKey(i_and_phi, 2, sortKey2, capacity);
1267        if (length2 != length || 0 != uprv_memcmp(sortKey, sortKey2, capacity)) {
1268            errln("getSortKey(i_and_phi, capacity=%d) failed to write proper prefix", capacity);
1269        } else if (sortKey2[capacity] != 2 || sortKey2[capacity + 1] != 2) {
1270            errln("getSortKey(i_and_phi, capacity=%d) wrote beyond capacity", capacity);
1271        }
1272    }
1273
1274    // Now try to break getCollationKey().
1275    // Internally, it always starts with a large stack buffer.
1276    // Since we cannot control the initial capacity, we throw an increasing number
1277    // of characters at it, with the problematic part at the end.
1278    const int32_t longCapacity = 2000;
1279    // Each 'a' in the prefix should result in one primary sort key byte.
1280    // For i_and_phi we expect 6 bytes, then the NUL terminator.
1281    const int32_t maxPrefixLength = longCapacity - 6 - 1;
1282    LocalArray<uint8_t> longSortKey(new uint8_t[longCapacity]);
1283    UnicodeString s(FALSE, i_and_phi, 2);
1284    for (int32_t prefixLength = 0; prefixLength < maxPrefixLength; ++prefixLength) {
1285        length = col->getSortKey(s, longSortKey.getAlias(), longCapacity);
1286        CollationKey collKey;
1287        col->getCollationKey(s, collKey, errorCode);
1288        int32_t collKeyLength;
1289        const uint8_t *collSortKey = collKey.getByteArray(collKeyLength);
1290        if (collKeyLength != length || 0 != uprv_memcmp(longSortKey.getAlias(), collSortKey, length)) {
1291            errln("getCollationKey(prefix[%d]+i_and_phi) failed to write proper sort key", prefixLength);
1292        }
1293
1294        // Insert an 'a' to match ++prefixLength.
1295        s.insert(prefixLength, (UChar)0x61);
1296    }
1297}
1298
1299void CollationAPITest::TestMaxExpansion()
1300{
1301    UErrorCode          status = U_ZERO_ERROR;
1302    UChar               ch     = 0;
1303    UChar32             unassigned = 0xEFFFD;
1304    uint32_t            sorder = 0;
1305    uint32_t            temporder = 0;
1306
1307    UnicodeString rule("&a < ab < c/aba < d < z < ch");
1308    RuleBasedCollator coll(rule, status);
1309    if(U_FAILURE(status)) {
1310      errcheckln(status, "Collator creation failed with error %s", u_errorName(status));
1311      return;
1312    }
1313    UnicodeString str(ch);
1314    CollationElementIterator *iter =
1315                                  coll.createCollationElementIterator(str);
1316
1317    while (ch < 0xFFFF && U_SUCCESS(status)) {
1318        int      count = 1;
1319        uint32_t order;
1320        int32_t  size = 0;
1321
1322        ch ++;
1323
1324        str.setCharAt(0, ch);
1325        iter->setText(str, status);
1326        order = iter->previous(status);
1327
1328        /* thai management */
1329        if (order == 0)
1330            order = iter->previous(status);
1331
1332        while (U_SUCCESS(status) && iter->previous(status) != UCOL_NULLORDER) {
1333            count ++;
1334        }
1335
1336        size = coll.getMaxExpansion(order);
1337        if (U_FAILURE(status) || size < count) {
1338            errln("Failure at codepoint U+%04X, maximum expansion count %d < %d",
1339                  ch, size, count);
1340        }
1341    }
1342
1343    /* testing for exact max expansion */
1344    int32_t size;
1345    ch = 0;
1346    while (ch < 0x61) {
1347        uint32_t order;
1348        str.setCharAt(0, ch);
1349        iter->setText(str, status);
1350        order = iter->previous(status);
1351        size  = coll.getMaxExpansion(order);
1352        if (U_FAILURE(status) || size != 1) {
1353            errln("Failure at codepoint U+%04X, maximum expansion count %d < %d",
1354                  ch, size, 1);
1355        }
1356        ch ++;
1357    }
1358
1359    ch = 0x63;
1360    str.setTo(ch);
1361    iter->setText(str, status);
1362    temporder = iter->previous(status);
1363    size = coll.getMaxExpansion(temporder);
1364    if (U_FAILURE(status) || size != 3) {
1365        errln("Failure at codepoint U+%04X, CE %08x, maximum expansion count %d != %d",
1366              ch, temporder, size, 3);
1367    }
1368
1369    ch = 0x64;
1370    str.setTo(ch);
1371    iter->setText(str, status);
1372    temporder = iter->previous(status);
1373    size = coll.getMaxExpansion(temporder);
1374    if (U_FAILURE(status) || size != 1) {
1375        errln("Failure at codepoint U+%04X, CE %08x, maximum expansion count %d != %d",
1376              ch, temporder, size, 1);
1377    }
1378
1379    str.setTo(unassigned);
1380    iter->setText(str, status);
1381    sorder = iter->previous(status);
1382    size = coll.getMaxExpansion(sorder);
1383    if (U_FAILURE(status) || size != 2) {
1384        errln("Failure at supplementary codepoints, maximum expansion count %d < %d",
1385              size, 2);
1386    }
1387
1388    /* testing jamo */
1389    ch = 0x1165;
1390    str.setTo(ch);
1391    iter->setText(str, status);
1392    temporder = iter->previous(status);
1393    size = coll.getMaxExpansion(temporder);
1394    if (U_FAILURE(status) || size > 3) {
1395        errln("Failure at codepoint U+%04X, maximum expansion count %d > %d",
1396              ch, size, 3);
1397    }
1398
1399    delete iter;
1400
1401    /* testing special jamo &a<\u1160 */
1402    rule = CharsToUnicodeString("\\u0026\\u0071\\u003c\\u1165\\u002f\\u0071\\u0071\\u0071\\u0071");
1403
1404    RuleBasedCollator jamocoll(rule, status);
1405    iter = jamocoll.createCollationElementIterator(str);
1406    temporder = iter->previous(status);
1407    size = iter->getMaxExpansion(temporder);
1408    if (U_FAILURE(status) || size != 6) {
1409        errln("Failure at codepoint U+%04X, maximum expansion count %d > %d",
1410              ch, size, 5);
1411    }
1412
1413    delete iter;
1414}
1415
1416void CollationAPITest::TestDisplayName()
1417{
1418    UErrorCode error = U_ZERO_ERROR;
1419    Collator *coll = Collator::createInstance("en_US", error);
1420    if (U_FAILURE(error)) {
1421        errcheckln(error, "Failure creating english collator - %s", u_errorName(error));
1422        return;
1423    }
1424    UnicodeString name;
1425    UnicodeString result;
1426    coll->getDisplayName(Locale::getCanadaFrench(), result);
1427    Locale::getCanadaFrench().getDisplayName(name);
1428    if (result.compare(name)) {
1429        errln("Failure getting the correct name for locale en_US");
1430    }
1431
1432    coll->getDisplayName(Locale::getSimplifiedChinese(), result);
1433    Locale::getSimplifiedChinese().getDisplayName(name);
1434    if (result.compare(name)) {
1435        errln("Failure getting the correct name for locale zh_SG");
1436    }
1437    delete coll;
1438}
1439
1440void CollationAPITest::TestAttribute()
1441{
1442    UErrorCode error = U_ZERO_ERROR;
1443    Collator *coll = Collator::createInstance(error);
1444
1445    if (U_FAILURE(error)) {
1446        errcheckln(error, "Creation of default collator failed - %s", u_errorName(error));
1447        return;
1448    }
1449
1450    coll->setAttribute(UCOL_FRENCH_COLLATION, UCOL_OFF, error);
1451    if (coll->getAttribute(UCOL_FRENCH_COLLATION, error) != UCOL_OFF ||
1452        U_FAILURE(error)) {
1453        errln("Setting and retrieving of the french collation failed");
1454    }
1455
1456    coll->setAttribute(UCOL_FRENCH_COLLATION, UCOL_ON, error);
1457    if (coll->getAttribute(UCOL_FRENCH_COLLATION, error) != UCOL_ON ||
1458        U_FAILURE(error)) {
1459        errln("Setting and retrieving of the french collation failed");
1460    }
1461
1462    coll->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_SHIFTED, error);
1463    if (coll->getAttribute(UCOL_ALTERNATE_HANDLING, error) != UCOL_SHIFTED ||
1464        U_FAILURE(error)) {
1465        errln("Setting and retrieving of the alternate handling failed");
1466    }
1467
1468    coll->setAttribute(UCOL_ALTERNATE_HANDLING, UCOL_NON_IGNORABLE, error);
1469    if (coll->getAttribute(UCOL_ALTERNATE_HANDLING, error) != UCOL_NON_IGNORABLE ||
1470        U_FAILURE(error)) {
1471        errln("Setting and retrieving of the alternate handling failed");
1472    }
1473
1474    coll->setAttribute(UCOL_CASE_FIRST, UCOL_LOWER_FIRST, error);
1475    if (coll->getAttribute(UCOL_CASE_FIRST, error) != UCOL_LOWER_FIRST ||
1476        U_FAILURE(error)) {
1477        errln("Setting and retrieving of the case first attribute failed");
1478    }
1479
1480    coll->setAttribute(UCOL_CASE_FIRST, UCOL_UPPER_FIRST, error);
1481    if (coll->getAttribute(UCOL_CASE_FIRST, error) != UCOL_UPPER_FIRST ||
1482        U_FAILURE(error)) {
1483        errln("Setting and retrieving of the case first attribute failed");
1484    }
1485
1486    coll->setAttribute(UCOL_CASE_LEVEL, UCOL_ON, error);
1487    if (coll->getAttribute(UCOL_CASE_LEVEL, error) != UCOL_ON ||
1488        U_FAILURE(error)) {
1489        errln("Setting and retrieving of the case level attribute failed");
1490    }
1491
1492    coll->setAttribute(UCOL_CASE_LEVEL, UCOL_OFF, error);
1493    if (coll->getAttribute(UCOL_CASE_LEVEL, error) != UCOL_OFF ||
1494        U_FAILURE(error)) {
1495        errln("Setting and retrieving of the case level attribute failed");
1496    }
1497
1498    coll->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, error);
1499    if (coll->getAttribute(UCOL_NORMALIZATION_MODE, error) != UCOL_ON ||
1500        U_FAILURE(error)) {
1501        errln("Setting and retrieving of the normalization on/off attribute failed");
1502    }
1503
1504    coll->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_OFF, error);
1505    if (coll->getAttribute(UCOL_NORMALIZATION_MODE, error) != UCOL_OFF ||
1506        U_FAILURE(error)) {
1507        errln("Setting and retrieving of the normalization on/off attribute failed");
1508    }
1509
1510    coll->setAttribute(UCOL_STRENGTH, UCOL_PRIMARY, error);
1511    if (coll->getAttribute(UCOL_STRENGTH, error) != UCOL_PRIMARY ||
1512        U_FAILURE(error)) {
1513        errln("Setting and retrieving of the collation strength failed");
1514    }
1515
1516    coll->setAttribute(UCOL_STRENGTH, UCOL_SECONDARY, error);
1517    if (coll->getAttribute(UCOL_STRENGTH, error) != UCOL_SECONDARY ||
1518        U_FAILURE(error)) {
1519        errln("Setting and retrieving of the collation strength failed");
1520    }
1521
1522    coll->setAttribute(UCOL_STRENGTH, UCOL_TERTIARY, error);
1523    if (coll->getAttribute(UCOL_STRENGTH, error) != UCOL_TERTIARY ||
1524        U_FAILURE(error)) {
1525        errln("Setting and retrieving of the collation strength failed");
1526    }
1527
1528    coll->setAttribute(UCOL_STRENGTH, UCOL_QUATERNARY, error);
1529    if (coll->getAttribute(UCOL_STRENGTH, error) != UCOL_QUATERNARY ||
1530        U_FAILURE(error)) {
1531        errln("Setting and retrieving of the collation strength failed");
1532    }
1533
1534    coll->setAttribute(UCOL_STRENGTH, UCOL_IDENTICAL, error);
1535    if (coll->getAttribute(UCOL_STRENGTH, error) != UCOL_IDENTICAL ||
1536        U_FAILURE(error)) {
1537        errln("Setting and retrieving of the collation strength failed");
1538    }
1539
1540    delete coll;
1541}
1542
1543void CollationAPITest::TestVariableTopSetting() {
1544  UErrorCode status = U_ZERO_ERROR;
1545
1546  UChar vt[256] = { 0 };
1547
1548  Collator *coll = Collator::createInstance(status);
1549  if(U_FAILURE(status)) {
1550    delete coll;
1551    errcheckln(status, "Collator creation failed with error %s", u_errorName(status));
1552    return;
1553  }
1554
1555  uint32_t oldVarTop = coll->getVariableTop(status);
1556
1557  vt[0] = 0x0041;
1558
1559  uint32_t newVarTop = coll->setVariableTop(vt, 1, status);
1560
1561  if((newVarTop & 0xFFFF0000) != (coll->getVariableTop(status) & 0xFFFF0000)) {
1562    errln("Didn't set vartop properly\n");
1563  }
1564
1565  coll->setVariableTop(oldVarTop, status);
1566
1567  uint32_t newerVarTop = coll->setVariableTop(UnicodeString(vt, 1), status);
1568
1569  if((newVarTop & 0xFFFF0000) != (newerVarTop & 0xFFFF0000)) {
1570    errln("Didn't set vartop properly from UnicodeString!\n");
1571  }
1572
1573  delete coll;
1574
1575}
1576
1577void CollationAPITest::TestGetLocale() {
1578  UErrorCode status = U_ZERO_ERROR;
1579  const char *rules = "&a<x<y<z";
1580  UChar rlz[256] = {0};
1581
1582  Collator *coll = NULL;
1583  Locale locale;
1584
1585  int32_t i = 0;
1586
1587  static const struct {
1588    const char* requestedLocale;
1589    const char* validLocale;
1590    const char* actualLocale;
1591  } testStruct[] = {
1592    { "sr_YU", "sr_YU", "root" },
1593    { "sh_YU", "sh_YU", "sh" },
1594    { "en_US_CALIFORNIA", "en_US", "root" },
1595    { "fr_FR_NONEXISTANT", "fr_FR", "fr" }
1596  };
1597
1598  u_unescape(rules, rlz, 256);
1599
1600  /* test opening collators for different locales */
1601  for(i = 0; i<(int32_t)(sizeof(testStruct)/sizeof(testStruct[0])); i++) {
1602    status = U_ZERO_ERROR;
1603    coll = Collator::createInstance(testStruct[i].requestedLocale, status);
1604    if(U_FAILURE(status)) {
1605      log("Failed to open collator for %s with %s\n", testStruct[i].requestedLocale, u_errorName(status));
1606      delete coll;
1607      continue;
1608    }
1609    locale = coll->getLocale(ULOC_REQUESTED_LOCALE, status);
1610    if(locale != testStruct[i].requestedLocale) {
1611      log("[Coll %s]: Error in requested locale, expected %s, got %s\n", testStruct[i].requestedLocale, testStruct[i].requestedLocale, locale.getName());
1612    }
1613    locale = coll->getLocale(ULOC_VALID_LOCALE, status);
1614    if(locale != testStruct[i].validLocale) {
1615      log("[Coll %s]: Error in valid locale, expected %s, got %s\n", testStruct[i].requestedLocale, testStruct[i].validLocale, locale.getName());
1616    }
1617    locale = coll->getLocale(ULOC_ACTUAL_LOCALE, status);
1618    if(locale != testStruct[i].actualLocale) {
1619      log("[Coll %s]: Error in actual locale, expected %s, got %s\n", testStruct[i].requestedLocale, testStruct[i].actualLocale, locale.getName());
1620    }
1621    delete coll;
1622  }
1623
1624  /* completely non-existant locale for collator should get a default collator */
1625  {
1626    Collator *defaultColl = Collator::createInstance((const Locale)NULL, status);
1627    coll = Collator::createInstance("blahaha", status);
1628    if(U_FAILURE(status)) {
1629      log("Failed to open collator with %s\n", u_errorName(status));
1630      delete coll;
1631      delete defaultColl;
1632      return;
1633    }
1634    if(coll->getLocale(ULOC_REQUESTED_LOCALE, status) != "blahaha") {
1635      log("Nonexisting locale didn't preserve the requested locale\n");
1636    }
1637    if(coll->getLocale(ULOC_VALID_LOCALE, status) !=
1638      defaultColl->getLocale(ULOC_VALID_LOCALE, status)) {
1639      log("Valid locale for nonexisting locale locale collator differs "
1640        "from valid locale for default collator\n");
1641    }
1642    if(coll->getLocale(ULOC_ACTUAL_LOCALE, status) !=
1643      defaultColl->getLocale(ULOC_ACTUAL_LOCALE, status)) {
1644      log("Actual locale for nonexisting locale locale collator differs "
1645        "from actual locale for default collator\n");
1646    }
1647    delete coll;
1648    delete defaultColl;
1649  }
1650
1651
1652
1653  /* collator instantiated from rules should have all three locales NULL */
1654  coll = new RuleBasedCollator(rlz, status);
1655  locale = coll->getLocale(ULOC_REQUESTED_LOCALE, status);
1656  if(!locale.isBogus()) {
1657    log("For collator instantiated from rules, requested locale %s is not bogus\n", locale.getName());
1658  }
1659  locale = coll->getLocale(ULOC_VALID_LOCALE, status);
1660  if(!locale.isBogus()) {
1661    log("For collator instantiated from rules, valid locale %s is not bogus\n", locale.getName());
1662  }
1663  locale = coll->getLocale(ULOC_ACTUAL_LOCALE, status);
1664  if(!locale.isBogus()) {
1665    log("For collator instantiated from rules, actual locale %s is not bogus\n", locale.getName());
1666  }
1667  delete coll;
1668}
1669
1670struct teststruct {
1671    const char *original;
1672    uint8_t key[256];
1673};
1674
1675
1676
1677U_CDECL_BEGIN
1678static int U_CALLCONV
1679compare_teststruct(const void *string1, const void *string2) {
1680  return(strcmp((const char *)((struct teststruct *)string1)->key, (const char *)((struct teststruct *)string2)->key));
1681}
1682U_CDECL_END
1683
1684
1685void CollationAPITest::TestBounds(void) {
1686    UErrorCode status = U_ZERO_ERROR;
1687
1688    Collator *coll = Collator::createInstance(Locale("sh"), status);
1689    if(U_FAILURE(status)) {
1690      delete coll;
1691      errcheckln(status, "Collator creation failed with %s", u_errorName(status));
1692      return;
1693    }
1694
1695    uint8_t sortkey[512], lower[512], upper[512];
1696    UChar buffer[512];
1697
1698    static const char * const test[] = {
1699        "John Smith",
1700        "JOHN SMITH",
1701        "john SMITH",
1702        "j\\u00F6hn sm\\u00EFth",
1703        "J\\u00F6hn Sm\\u00EFth",
1704        "J\\u00D6HN SM\\u00CFTH",
1705        "john smithsonian",
1706        "John Smithsonian"
1707    };
1708
1709    struct teststruct tests[] = {
1710        {"\\u010CAKI MIHALJ", {0}},
1711        {"\\u010CAKI MIHALJ", {0}},
1712        {"\\u010CAKI PIRO\\u0160KA", {0}},
1713        {"\\u010CABAI ANDRIJA", {0}},
1714        {"\\u010CABAI LAJO\\u0160", {0}},
1715        {"\\u010CABAI MARIJA", {0}},
1716        {"\\u010CABAI STEVAN", {0}},
1717        {"\\u010CABAI STEVAN", {0}},
1718        {"\\u010CABARKAPA BRANKO", {0}},
1719        {"\\u010CABARKAPA MILENKO", {0}},
1720        {"\\u010CABARKAPA MIROSLAV", {0}},
1721        {"\\u010CABARKAPA SIMO", {0}},
1722        {"\\u010CABARKAPA STANKO", {0}},
1723        {"\\u010CABARKAPA TAMARA", {0}},
1724        {"\\u010CABARKAPA TOMA\\u0160", {0}},
1725        {"\\u010CABDARI\\u0106 NIKOLA", {0}},
1726        {"\\u010CABDARI\\u0106 ZORICA", {0}},
1727        {"\\u010CABI NANDOR", {0}},
1728        {"\\u010CABOVI\\u0106 MILAN", {0}},
1729        {"\\u010CABRADI AGNEZIJA", {0}},
1730        {"\\u010CABRADI IVAN", {0}},
1731        {"\\u010CABRADI JELENA", {0}},
1732        {"\\u010CABRADI LJUBICA", {0}},
1733        {"\\u010CABRADI STEVAN", {0}},
1734        {"\\u010CABRDA MARTIN", {0}},
1735        {"\\u010CABRILO BOGDAN", {0}},
1736        {"\\u010CABRILO BRANISLAV", {0}},
1737        {"\\u010CABRILO LAZAR", {0}},
1738        {"\\u010CABRILO LJUBICA", {0}},
1739        {"\\u010CABRILO SPASOJA", {0}},
1740        {"\\u010CADE\\u0160 ZDENKA", {0}},
1741        {"\\u010CADESKI BLAGOJE", {0}},
1742        {"\\u010CADOVSKI VLADIMIR", {0}},
1743        {"\\u010CAGLJEVI\\u0106 TOMA", {0}},
1744        {"\\u010CAGOROVI\\u0106 VLADIMIR", {0}},
1745        {"\\u010CAJA VANKA", {0}},
1746        {"\\u010CAJI\\u0106 BOGOLJUB", {0}},
1747        {"\\u010CAJI\\u0106 BORISLAV", {0}},
1748        {"\\u010CAJI\\u0106 RADOSLAV", {0}},
1749        {"\\u010CAK\\u0160IRAN MILADIN", {0}},
1750        {"\\u010CAKAN EUGEN", {0}},
1751        {"\\u010CAKAN EVGENIJE", {0}},
1752        {"\\u010CAKAN IVAN", {0}},
1753        {"\\u010CAKAN JULIJAN", {0}},
1754        {"\\u010CAKAN MIHAJLO", {0}},
1755        {"\\u010CAKAN STEVAN", {0}},
1756        {"\\u010CAKAN VLADIMIR", {0}},
1757        {"\\u010CAKAN VLADIMIR", {0}},
1758        {"\\u010CAKAN VLADIMIR", {0}},
1759        {"\\u010CAKARA ANA", {0}},
1760        {"\\u010CAKAREVI\\u0106 MOMIR", {0}},
1761        {"\\u010CAKAREVI\\u0106 NEDELJKO", {0}},
1762        {"\\u010CAKI \\u0160ANDOR", {0}},
1763        {"\\u010CAKI AMALIJA", {0}},
1764        {"\\u010CAKI ANDRA\\u0160", {0}},
1765        {"\\u010CAKI LADISLAV", {0}},
1766        {"\\u010CAKI LAJO\\u0160", {0}},
1767        {"\\u010CAKI LASLO", {0}}
1768    };
1769
1770
1771
1772    int32_t i = 0, j = 0, k = 0, buffSize = 0, skSize = 0, lowerSize = 0, upperSize = 0;
1773    int32_t arraySize = sizeof(tests)/sizeof(tests[0]);
1774
1775    (void)lowerSize;  // Suppress unused variable warnings.
1776    (void)upperSize;
1777
1778    for(i = 0; i<arraySize; i++) {
1779        buffSize = u_unescape(tests[i].original, buffer, 512);
1780        skSize = coll->getSortKey(buffer, buffSize, tests[i].key, 512);
1781    }
1782
1783    qsort(tests, arraySize, sizeof(struct teststruct), compare_teststruct);
1784
1785    for(i = 0; i < arraySize-1; i++) {
1786        for(j = i+1; j < arraySize; j++) {
1787            lowerSize = coll->getBound(tests[i].key, -1, UCOL_BOUND_LOWER, 1, lower, 512, status);
1788            upperSize = coll->getBound(tests[j].key, -1, UCOL_BOUND_UPPER, 1, upper, 512, status);
1789            for(k = i; k <= j; k++) {
1790                if(strcmp((const char *)lower, (const char *)tests[k].key) > 0) {
1791                    errln("Problem with lower! j = %i (%s vs %s)", k, tests[k].original, tests[i].original);
1792                }
1793                if(strcmp((const char *)upper, (const char *)tests[k].key) <= 0) {
1794                    errln("Problem with upper! j = %i (%s vs %s)", k, tests[k].original, tests[j].original);
1795                }
1796            }
1797        }
1798    }
1799
1800
1801    for(i = 0; i<(int32_t)(sizeof(test)/sizeof(test[0])); i++) {
1802        buffSize = u_unescape(test[i], buffer, 512);
1803        skSize = coll->getSortKey(buffer, buffSize, sortkey, 512);
1804        lowerSize = ucol_getBound(sortkey, skSize, UCOL_BOUND_LOWER, 1, lower, 512, &status);
1805        upperSize = ucol_getBound(sortkey, skSize, UCOL_BOUND_UPPER_LONG, 1, upper, 512, &status);
1806        for(j = i+1; j<(int32_t)(sizeof(test)/sizeof(test[0])); j++) {
1807            buffSize = u_unescape(test[j], buffer, 512);
1808            skSize = coll->getSortKey(buffer, buffSize, sortkey, 512);
1809            if(strcmp((const char *)lower, (const char *)sortkey) > 0) {
1810                errln("Problem with lower! i = %i, j = %i (%s vs %s)", i, j, test[i], test[j]);
1811            }
1812            if(strcmp((const char *)upper, (const char *)sortkey) <= 0) {
1813                errln("Problem with upper! i = %i, j = %i (%s vs %s)", i, j, test[i], test[j]);
1814            }
1815        }
1816    }
1817    delete coll;
1818}
1819
1820
1821void CollationAPITest::TestGetTailoredSet()
1822{
1823  struct {
1824    const char *rules;
1825    const char *tests[20];
1826    int32_t testsize;
1827  } setTest[] = {
1828    { "&a < \\u212b", { "\\u212b", "A\\u030a", "\\u00c5" }, 3},
1829    { "& S < \\u0161 <<< \\u0160", { "\\u0161", "s\\u030C", "\\u0160", "S\\u030C" }, 4}
1830  };
1831
1832  uint32_t i = 0, j = 0;
1833  UErrorCode status = U_ZERO_ERROR;
1834
1835  RuleBasedCollator *coll = NULL;
1836  UnicodeString buff;
1837  UnicodeSet *set = NULL;
1838
1839  for(i = 0; i < sizeof(setTest)/sizeof(setTest[0]); i++) {
1840    buff = UnicodeString(setTest[i].rules, "").unescape();
1841    coll = new RuleBasedCollator(buff, status);
1842    if(U_SUCCESS(status)) {
1843      set = coll->getTailoredSet(status);
1844      if(set->size() != setTest[i].testsize) {
1845        errln("Tailored set size different (%d) than expected (%d)", set->size(), setTest[i].testsize);
1846      }
1847      for(j = 0; j < (uint32_t)setTest[i].testsize; j++) {
1848        buff = UnicodeString(setTest[i].tests[j], "").unescape();
1849        if(!set->contains(buff)) {
1850          errln("Tailored set doesn't contain %s... It should", setTest[i].tests[j]);
1851        }
1852      }
1853      delete set;
1854    } else {
1855      errcheckln(status, "Couldn't open collator with rules %s - %s", setTest[i].rules, u_errorName(status));
1856    }
1857    delete coll;
1858  }
1859}
1860
1861void CollationAPITest::TestUClassID()
1862{
1863    char id = *((char *)RuleBasedCollator::getStaticClassID());
1864    if (id != 0) {
1865        errln("Static class id for RuleBasedCollator should be 0");
1866    }
1867    UErrorCode status = U_ZERO_ERROR;
1868    RuleBasedCollator *coll
1869        = (RuleBasedCollator *)Collator::createInstance(status);
1870    if(U_FAILURE(status)) {
1871      delete coll;
1872      errcheckln(status, "Collator creation failed with %s", u_errorName(status));
1873      return;
1874    }
1875    id = *((char *)coll->getDynamicClassID());
1876    if (id != 0) {
1877        errln("Dynamic class id for RuleBasedCollator should be 0");
1878    }
1879    id = *((char *)CollationKey::getStaticClassID());
1880    if (id != 0) {
1881        errln("Static class id for CollationKey should be 0");
1882    }
1883    CollationKey *key = new CollationKey();
1884    id = *((char *)key->getDynamicClassID());
1885    if (id != 0) {
1886        errln("Dynamic class id for CollationKey should be 0");
1887    }
1888    id = *((char *)CollationElementIterator::getStaticClassID());
1889    if (id != 0) {
1890        errln("Static class id for CollationElementIterator should be 0");
1891    }
1892    UnicodeString str("testing");
1893    CollationElementIterator *iter = coll->createCollationElementIterator(str);
1894    id = *((char *)iter->getDynamicClassID());
1895    if (id != 0) {
1896        errln("Dynamic class id for CollationElementIterator should be 0");
1897    }
1898    delete key;
1899    delete iter;
1900    delete coll;
1901}
1902
1903class TestCollator  : public Collator
1904{
1905public:
1906    virtual Collator* clone(void) const;
1907
1908    using Collator::compare;
1909
1910    virtual UCollationResult compare(const UnicodeString& source,
1911                                      const UnicodeString& target,
1912                                      UErrorCode& status) const;
1913    virtual UCollationResult compare(const UnicodeString& source,
1914                                      const UnicodeString& target,
1915                                      int32_t length,
1916                                      UErrorCode& status) const;
1917    virtual UCollationResult compare(const UChar* source,
1918                                      int32_t sourceLength,
1919                                      const UChar* target,
1920                                      int32_t targetLength,
1921                                      UErrorCode& status) const;
1922    virtual CollationKey& getCollationKey(const UnicodeString&  source,
1923                                          CollationKey& key,
1924                                          UErrorCode& status) const;
1925    virtual CollationKey& getCollationKey(const UChar*source,
1926                                          int32_t sourceLength,
1927                                          CollationKey& key,
1928                                          UErrorCode& status) const;
1929    virtual int32_t hashCode(void) const;
1930    virtual Locale getLocale(ULocDataLocaleType type, UErrorCode& status) const;
1931    virtual ECollationStrength getStrength(void) const;
1932    virtual void setStrength(ECollationStrength newStrength);
1933    virtual UClassID getDynamicClassID(void) const;
1934    virtual void getVersion(UVersionInfo info) const;
1935    virtual void setAttribute(UColAttribute attr, UColAttributeValue value,
1936                              UErrorCode &status);
1937    virtual UColAttributeValue getAttribute(UColAttribute attr,
1938                                            UErrorCode &status) const;
1939    virtual uint32_t setVariableTop(const UChar *varTop, int32_t len,
1940                                    UErrorCode &status);
1941    virtual uint32_t setVariableTop(const UnicodeString &varTop,
1942                                    UErrorCode &status);
1943    virtual void setVariableTop(uint32_t varTop, UErrorCode &status);
1944    virtual uint32_t getVariableTop(UErrorCode &status) const;
1945    virtual int32_t getSortKey(const UnicodeString& source,
1946                            uint8_t* result,
1947                            int32_t resultLength) const;
1948    virtual int32_t getSortKey(const UChar*source, int32_t sourceLength,
1949                             uint8_t*result, int32_t resultLength) const;
1950    virtual UnicodeSet *getTailoredSet(UErrorCode &status) const;
1951    virtual UBool operator==(const Collator& other) const;
1952    // Collator::operator!= calls !Collator::operator== which works for all subclasses.
1953    virtual void setLocales(const Locale& requestedLocale, const Locale& validLocale, const Locale& actualLocale);
1954    TestCollator() : Collator() {};
1955    TestCollator(UCollationStrength collationStrength,
1956           UNormalizationMode decompositionMode) : Collator(collationStrength, decompositionMode) {};
1957};
1958
1959inline UBool TestCollator::operator==(const Collator& other) const {
1960    // TestCollator has no fields, so we test for identity.
1961    return this == &other;
1962
1963    // Normally, subclasses should do something like the following:
1964    //    if (this == &other) { return TRUE; }
1965    //    if (!Collator::operator==(other)) { return FALSE; }  // not the same class
1966    //
1967    //    const TestCollator &o = (const TestCollator&)other;
1968    //    (compare this vs. o's subclass fields)
1969}
1970
1971Collator* TestCollator::clone() const
1972{
1973    return new TestCollator();
1974}
1975
1976UCollationResult TestCollator::compare(const UnicodeString& source,
1977                                        const UnicodeString& target,
1978                                        UErrorCode& status) const
1979{
1980  if(U_SUCCESS(status)) {
1981    return UCollationResult(source.compare(target));
1982  } else {
1983    return UCOL_EQUAL;
1984  }
1985}
1986
1987UCollationResult TestCollator::compare(const UnicodeString& source,
1988                                        const UnicodeString& target,
1989                                        int32_t length,
1990                                        UErrorCode& status) const
1991{
1992  if(U_SUCCESS(status)) {
1993    return UCollationResult(source.compare(0, length, target));
1994  } else {
1995    return UCOL_EQUAL;
1996  }
1997}
1998
1999UCollationResult TestCollator::compare(const UChar* source,
2000                                        int32_t sourceLength,
2001                                        const UChar* target,
2002                                        int32_t targetLength,
2003                                        UErrorCode& status) const
2004{
2005    UnicodeString s(source, sourceLength);
2006    UnicodeString t(target, targetLength);
2007    return compare(s, t, status);
2008}
2009
2010CollationKey& TestCollator::getCollationKey(const UnicodeString& source,
2011                                            CollationKey& key,
2012                                            UErrorCode& status) const
2013{
2014    char temp[100];
2015    int length = 100;
2016    length = source.extract(temp, length, NULL, status);
2017    temp[length] = 0;
2018    CollationKey tempkey((uint8_t*)temp, length);
2019    key = tempkey;
2020    return key;
2021}
2022
2023CollationKey& TestCollator::getCollationKey(const UChar*source,
2024                                          int32_t sourceLength,
2025                                          CollationKey& key,
2026                                          UErrorCode& status) const
2027{
2028    //s tack allocation used since collationkey does not keep the unicodestring
2029    UnicodeString str(source, sourceLength);
2030    return getCollationKey(str, key, status);
2031}
2032
2033int32_t TestCollator::getSortKey(const UnicodeString& source, uint8_t* result,
2034                                 int32_t resultLength) const
2035{
2036    UErrorCode status = U_ZERO_ERROR;
2037    int32_t length = source.extract((char *)result, resultLength, NULL,
2038                                    status);
2039    result[length] = 0;
2040    return length;
2041}
2042
2043int32_t TestCollator::getSortKey(const UChar*source, int32_t sourceLength,
2044                                 uint8_t*result, int32_t resultLength) const
2045{
2046    UnicodeString str(source, sourceLength);
2047    return getSortKey(str, result, resultLength);
2048}
2049
2050int32_t TestCollator::hashCode() const
2051{
2052    return 0;
2053}
2054
2055Locale TestCollator::getLocale(ULocDataLocaleType type, UErrorCode& status) const
2056{
2057    // api not used, this is to make the compiler happy
2058    if (U_FAILURE(status)) {
2059        (void)type;
2060    }
2061    return NULL;
2062}
2063
2064Collator::ECollationStrength TestCollator::getStrength() const
2065{
2066    return TERTIARY;
2067}
2068
2069void TestCollator::setStrength(Collator::ECollationStrength newStrength)
2070{
2071    // api not used, this is to make the compiler happy
2072    (void)newStrength;
2073}
2074
2075UClassID TestCollator::getDynamicClassID(void) const
2076{
2077    return 0;
2078}
2079
2080void TestCollator::getVersion(UVersionInfo info) const
2081{
2082    // api not used, this is to make the compiler happy
2083    memset(info, 0, U_MAX_VERSION_LENGTH);
2084}
2085
2086void TestCollator::setAttribute(UColAttribute /*attr*/, UColAttributeValue /*value*/,
2087                                UErrorCode & /*status*/)
2088{
2089}
2090
2091UColAttributeValue TestCollator::getAttribute(UColAttribute attr,
2092                                              UErrorCode &status) const
2093{
2094    // api not used, this is to make the compiler happy
2095    if (U_FAILURE(status) || attr == UCOL_ATTRIBUTE_COUNT) {
2096        return UCOL_OFF;
2097    }
2098    return UCOL_DEFAULT;
2099}
2100
2101uint32_t TestCollator::setVariableTop(const UChar *varTop, int32_t len,
2102                                  UErrorCode &status)
2103{
2104    // api not used, this is to make the compiler happy
2105    if (U_SUCCESS(status) && (varTop == 0 || len < -1)) {
2106        status = U_ILLEGAL_ARGUMENT_ERROR;
2107    }
2108    return 0;
2109}
2110
2111uint32_t TestCollator::setVariableTop(const UnicodeString &varTop,
2112                                  UErrorCode &status)
2113{
2114    // api not used, this is to make the compiler happy
2115    if (U_SUCCESS(status) && varTop.length() == 0) {
2116        status = U_ILLEGAL_ARGUMENT_ERROR;
2117    }
2118    return 0;
2119}
2120
2121void TestCollator::setVariableTop(uint32_t varTop, UErrorCode &status)
2122{
2123    // api not used, this is to make the compiler happy
2124    if (U_SUCCESS(status) && varTop == 0) {
2125        status = U_ILLEGAL_ARGUMENT_ERROR;
2126    }
2127}
2128
2129uint32_t TestCollator::getVariableTop(UErrorCode &status) const
2130{
2131
2132    // api not used, this is to make the compiler happy
2133    if (U_SUCCESS(status)) {
2134        return 0;
2135    }
2136    return (uint32_t)(0xFFFFFFFFu);
2137}
2138
2139UnicodeSet * TestCollator::getTailoredSet(UErrorCode &status) const
2140{
2141    return Collator::getTailoredSet(status);
2142}
2143
2144void TestCollator::setLocales(const Locale& requestedLocale, const Locale& validLocale, const Locale& actualLocale)
2145{
2146    Collator::setLocales(requestedLocale, validLocale, actualLocale);
2147}
2148
2149
2150void CollationAPITest::TestSubclass()
2151{
2152    TestCollator col1;
2153    TestCollator col2;
2154    doAssert(col1 != col2, "2 instances of TestCollator should be different");
2155    if (col1.hashCode() != col2.hashCode()) {
2156        errln("Every TestCollator has the same hashcode");
2157    }
2158    UnicodeString abc("abc", 3);
2159    UnicodeString bcd("bcd", 3);
2160    if (col1.compare(abc, bcd) != abc.compare(bcd)) {
2161        errln("TestCollator compare should be the same as the default "
2162              "string comparison");
2163    }
2164    CollationKey key;
2165    UErrorCode status = U_ZERO_ERROR;
2166    col1.getCollationKey(abc, key, status);
2167    int32_t length = 0;
2168    const char* bytes = (const char *)key.getByteArray(length);
2169    UnicodeString keyarray(bytes, length, NULL, status);
2170    if (abc != keyarray) {
2171        errln("TestCollator collationkey API is returning wrong values");
2172    }
2173
2174    UnicodeSet expectedset(0, 0x10FFFF);
2175    UnicodeSet *defaultset = col1.getTailoredSet(status);
2176    if (!defaultset->containsAll(expectedset)
2177        || !expectedset.containsAll(*defaultset)) {
2178        errln("Error: expected default tailoring to be 0 to 0x10ffff");
2179    }
2180    delete defaultset;
2181
2182    // use base class implementation
2183    Locale loc1 = Locale::getGermany();
2184    Locale loc2 = Locale::getFrance();
2185    col1.setLocales(loc1, loc2, loc2); // default implementation has no effect
2186
2187    UnicodeString displayName;
2188    col1.getDisplayName(loc1, loc2, displayName); // de_DE collator in fr_FR locale
2189
2190    TestCollator col3(UCOL_TERTIARY, UNORM_NONE);
2191    UnicodeString a("a");
2192    UnicodeString b("b");
2193    Collator::EComparisonResult result = Collator::EComparisonResult(a.compare(b));
2194    if(col1.compare(a, b) != result) {
2195      errln("Collator doesn't give default result");
2196    }
2197    if(col1.compare(a, b, 1) != result) {
2198      errln("Collator doesn't give default result");
2199    }
2200    if(col1.compare(a.getBuffer(), a.length(), b.getBuffer(), b.length()) != result) {
2201      errln("Collator doesn't give default result");
2202    }
2203}
2204
2205void CollationAPITest::TestNULLCharTailoring()
2206{
2207    UErrorCode status = U_ZERO_ERROR;
2208    UChar buf[256] = {0};
2209    int32_t len = u_unescape("&a < '\\u0000'", buf, 256);
2210    UnicodeString first((UChar)0x0061);
2211    UnicodeString second((UChar)0);
2212    RuleBasedCollator *coll = new RuleBasedCollator(UnicodeString(buf, len), status);
2213    if(U_FAILURE(status)) {
2214        delete coll;
2215        errcheckln(status, "Failed to open collator - %s", u_errorName(status));
2216        return;
2217    }
2218    UCollationResult res = coll->compare(first, second, status);
2219    if(res != UCOL_LESS) {
2220        errln("a should be less then NULL after tailoring");
2221    }
2222    delete coll;
2223}
2224
2225void CollationAPITest::TestClone() {
2226    logln("\ninit c0");
2227    UErrorCode status = U_ZERO_ERROR;
2228    RuleBasedCollator* c0 = (RuleBasedCollator*)Collator::createInstance(status);
2229
2230    if (U_FAILURE(status)) {
2231        errcheckln(status, "Collator::CreateInstance(status) failed with %s", u_errorName(status));
2232        return;
2233    }
2234
2235    c0->setStrength(Collator::TERTIARY);
2236    dump("c0", c0, status);
2237
2238    logln("\ninit c1");
2239    RuleBasedCollator* c1 = (RuleBasedCollator*)Collator::createInstance(status);
2240    c1->setStrength(Collator::TERTIARY);
2241    UColAttributeValue val = c1->getAttribute(UCOL_CASE_FIRST, status);
2242    if(val == UCOL_LOWER_FIRST){
2243        c1->setAttribute(UCOL_CASE_FIRST, UCOL_UPPER_FIRST, status);
2244    }else{
2245        c1->setAttribute(UCOL_CASE_FIRST, UCOL_LOWER_FIRST, status);
2246    }
2247    dump("c0", c0, status);
2248    dump("c1", c1, status);
2249
2250    logln("\ninit c2");
2251    RuleBasedCollator* c2 = (RuleBasedCollator*)c1->clone();
2252    val = c2->getAttribute(UCOL_CASE_FIRST, status);
2253    if(val == UCOL_LOWER_FIRST){
2254        c2->setAttribute(UCOL_CASE_FIRST, UCOL_UPPER_FIRST, status);
2255    }else{
2256        c2->setAttribute(UCOL_CASE_FIRST, UCOL_LOWER_FIRST, status);
2257    }
2258    if(U_FAILURE(status)){
2259        errln("set and get attributes of collator failed. %s\n", u_errorName(status));
2260        return;
2261    }
2262    dump("c0", c0, status);
2263    dump("c1", c1, status);
2264    dump("c2", c2, status);
2265    if(*c1 == *c2){
2266        errln("The cloned objects refer to same data");
2267    }
2268    delete c0;
2269    delete c1;
2270    delete c2;
2271}
2272
2273void CollationAPITest::TestIterNumeric() {
2274    // Regression test for ticket #9915.
2275    // The collation code sometimes masked the continuation marker away
2276    // but later tested the result for isContinuation().
2277    // This test case failed because the third bytes of the computed numeric-collation primaries
2278    // were permutated with the script reordering table.
2279    // It should have been possible to reproduce this with the root collator
2280    // and characters with appropriate 3-byte primary weights.
2281    // The effectiveness of this test depends completely on the collation elements
2282    // and on the implementation code.
2283    IcuTestErrorCode errorCode(*this, "TestIterNumeric");
2284    RuleBasedCollator coll(UnicodeString("[reorder Hang Hani]"), errorCode);
2285    if(errorCode.logDataIfFailureAndReset("RuleBasedCollator constructor")) {
2286        return;
2287    }
2288    coll.setAttribute(UCOL_NUMERIC_COLLATION, UCOL_ON, errorCode);
2289    UCharIterator iter40, iter72;
2290    uiter_setUTF8(&iter40, "\x34\x30", 2);
2291    uiter_setUTF8(&iter72, "\x37\x32", 2);
2292    UCollationResult result = coll.compare(iter40, iter72, errorCode);
2293    assertEquals("40<72", (int32_t)UCOL_LESS, (int32_t)result);
2294}
2295
2296 void CollationAPITest::dump(UnicodeString msg, RuleBasedCollator* c, UErrorCode& status) {
2297    const char* bigone = "One";
2298    const char* littleone = "one";
2299
2300    logln(msg + " " + c->compare(bigone, littleone) +
2301                        " s: " + c->getStrength() +
2302                        " u: " + c->getAttribute(UCOL_CASE_FIRST, status));
2303}
2304void CollationAPITest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par */)
2305{
2306    if (exec) logln("TestSuite CollationAPITest: ");
2307    TESTCASE_AUTO_BEGIN;
2308    TESTCASE_AUTO(TestProperty);
2309    TESTCASE_AUTO(TestOperators);
2310    TESTCASE_AUTO(TestDuplicate);
2311    TESTCASE_AUTO(TestCompare);
2312    TESTCASE_AUTO(TestHashCode);
2313    TESTCASE_AUTO(TestCollationKey);
2314    TESTCASE_AUTO(TestElemIter);
2315    TESTCASE_AUTO(TestGetAll);
2316    TESTCASE_AUTO(TestRuleBasedColl);
2317    TESTCASE_AUTO(TestDecomposition);
2318    TESTCASE_AUTO(TestSafeClone);
2319    TESTCASE_AUTO(TestSortKey);
2320    TESTCASE_AUTO(TestSortKeyOverflow);
2321    TESTCASE_AUTO(TestMaxExpansion);
2322    TESTCASE_AUTO(TestDisplayName);
2323    TESTCASE_AUTO(TestAttribute);
2324    TESTCASE_AUTO(TestVariableTopSetting);
2325    TESTCASE_AUTO(TestRules);
2326    TESTCASE_AUTO(TestGetLocale);
2327    TESTCASE_AUTO(TestBounds);
2328    TESTCASE_AUTO(TestGetTailoredSet);
2329    TESTCASE_AUTO(TestUClassID);
2330    TESTCASE_AUTO(TestSubclass);
2331    TESTCASE_AUTO(TestNULLCharTailoring);
2332    TESTCASE_AUTO(TestClone);
2333    TESTCASE_AUTO(TestIterNumeric);
2334    TESTCASE_AUTO_END;
2335}
2336
2337#endif /* #if !UCONFIG_NO_COLLATION */
2338