]> git.saurik.com Git - apple/icu.git/blob - icuSources/test/intltest/regcoll.cpp
projects / apple / icu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ICU-511.27.tar.gz
[apple/icu.git] / icuSources / test / intltest / regcoll.cpp
1 /********************************************************************
2 * COPYRIGHT:
3 * Copyright (c) 1997-2011, International Business Machines Corporation and
4 * others. All Rights Reserved.
5 ********************************************************************/
6
7 #include "unicode/utypes.h"
8
9 #if !UCONFIG_NO_COLLATION
10
11 #include "unicode/coll.h"
12 #include "unicode/tblcoll.h"
13 #include "unicode/unistr.h"
14 #include "unicode/sortkey.h"
15 #include "regcoll.h"
16 #include "sfwdchit.h"
17 #include "testutil.h"
18 #include "cmemory.h"
19
20 #define ARRAY_LENGTH(array) ((int32_t)(sizeof array / sizeof array[0]))
21
22 CollationRegressionTest::CollationRegressionTest()
23 {
24 UErrorCode status = U_ZERO_ERROR;
25
26 en_us = (RuleBasedCollator *)Collator::createInstance(Locale::getUS(), status);
27 if(U_FAILURE(status)) {
28 delete en_us;
29 en_us = 0;
30 errcheckln(status, "Collator creation failed with %s", u_errorName(status));
31 return;
32 }
33 }
34
35 CollationRegressionTest::~CollationRegressionTest()
36 {
37 delete en_us;
38 }
39
40
41 // @bug 4048446
42 //
43 // CollationElementIterator.reset() doesn't work
44 //
45 void CollationRegressionTest::Test4048446(/* char* par */)
46 {
47 const UnicodeString test1 = "XFILE What subset of all possible test cases has the highest probability of detecting the most errors?";
48 const UnicodeString test2 = "Xf_ile What subset of all possible test cases has the lowest probability of detecting the least errors?";
49 CollationElementIterator *i1 = en_us->createCollationElementIterator(test1);
50 CollationElementIterator *i2 = en_us->createCollationElementIterator(test1);
51 UErrorCode status = U_ZERO_ERROR;
52
53 if (i1 == NULL|| i2 == NULL)
54 {
55 errln("Could not create CollationElementIterator's");
56 delete i1;
57 delete i2;
58 return;
59 }
60
61 while (i1->next(status) != CollationElementIterator::NULLORDER)
62 {
63 if (U_FAILURE(status))
64 {
65 errln("error calling next()");
66
67 delete i1;
68 delete i2;
69 return;
70 }
71 }
72
73 i1->reset();
74
75 assertEqual(*i1, *i2);
76
77 delete i1;
78 delete i2;
79 }
80
81 // @bug 4051866
82 //
83 // Collator -> rules -> Collator round-trip broken for expanding characters
84 //
85 void CollationRegressionTest::Test4051866(/* char* par */)
86 {
87 /*
88 RuleBasedCollator c1 = new RuleBasedCollator("< o "
89 +"& oe ,o\u3080"
90 +"& oe ,\u1530 ,O"
91 +"& OE ,O\u3080"
92 +"& OE ,\u1520"
93 +"< p ,P");
94 */
95
96 UnicodeString rules;
97 UErrorCode status = U_ZERO_ERROR;
98
99 rules += "< o ";
100 rules += "& oe ,o";
101 rules += (UChar)0x3080;
102 rules += "& oe ,";
103 rules += (UChar)0x1530;
104 rules += " ,O";
105 rules += "& OE ,O";
106 rules += (UChar)0x3080;
107 rules += "& OE ,";
108 rules += (UChar)0x1520;
109 rules += "< p ,P";
110
111 // Build a collator containing expanding characters
112 RuleBasedCollator *c1 = new RuleBasedCollator(rules, status);
113
114 // Build another using the rules from the first
115 RuleBasedCollator *c2 = new RuleBasedCollator(c1->getRules(), status);
116
117 // Make sure they're the same
118 if (!(c1->getRules() == c2->getRules()))
119 {
120 errln("Rules are not equal");
121 }
122
123 delete c2;
124 delete c1;
125 }
126
127 // @bug 4053636
128 //
129 // Collator thinks "black-bird" == "black"
130 //
131 void CollationRegressionTest::Test4053636(/* char* par */)
132 {
133 if (en_us->equals("black_bird", "black"))
134 {
135 errln("black-bird == black");
136 }
137 }
138
139 // @bug 4054238
140 //
141 // CollationElementIterator will not work correctly if the associated
142 // Collator object's mode is changed
143 //
144 void CollationRegressionTest::Test4054238(/* char* par */)
145 {
146 const UChar chars3[] = {0x61, 0x00FC, 0x62, 0x65, 0x63, 0x6b, 0x20, 0x47, 0x72, 0x00F6, 0x00DF, 0x65, 0x20, 0x4c, 0x00FC, 0x62, 0x63, 0x6b, 0};
147 const UnicodeString test3(chars3);
148 RuleBasedCollator *c = (RuleBasedCollator *) en_us->clone();
149
150 // NOTE: The Java code uses en_us to create the CollationElementIterators
151 // but I'm pretty sure that's wrong, so I've changed this to use c.
152 UErrorCode status = U_ZERO_ERROR;
153 c->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
154 CollationElementIterator *i1 = c->createCollationElementIterator(test3);
155 delete i1;
156 delete c;
157 }
158
159 // @bug 4054734
160 //
161 // Collator::IDENTICAL documented but not implemented
162 //
163 void CollationRegressionTest::Test4054734(/* char* par */)
164 {
165 /*
166 Here's the original Java:
167
168 String[] decomp = {
169 "\u0001", "<", "\u0002",
170 "\u0001", "=", "\u0001",
171 "A\u0001", ">", "~\u0002", // Ensure A and ~ are not compared bitwise
172 "\u00C0", "=", "A\u0300" // Decomp should make these equal
173 };
174
175 String[] nodecomp = {
176 "\u00C0", ">", "A\u0300" // A-grave vs. A combining-grave
177 };
178 */
179
180 static const UChar decomp[][CollationRegressionTest::MAX_TOKEN_LEN] =
181 {
182 {0x0001, 0}, {0x3c, 0}, {0x0002, 0},
183 {0x0001, 0}, {0x3d, 0}, {0x0001, 0},
184 {0x41, 0x0001, 0}, {0x3e, 0}, {0x7e, 0x0002, 0},
185 {0x00c0, 0}, {0x3d, 0}, {0x41, 0x0300, 0}
186 };
187
188
189 UErrorCode status = U_ZERO_ERROR;
190 RuleBasedCollator *c = (RuleBasedCollator *) en_us->clone();
191
192 c->setStrength(Collator::IDENTICAL);
193
194 c->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
195 compareArray(*c, decomp, ARRAY_LENGTH(decomp));
196
197 delete c;
198 }
199
200 // @bug 4054736
201 //
202 // Full Decomposition mode not implemented
203 //
204 void CollationRegressionTest::Test4054736(/* char* par */)
205 {
206 UErrorCode status = U_ZERO_ERROR;
207 RuleBasedCollator *c = (RuleBasedCollator *) en_us->clone();
208
209 c->setStrength(Collator::SECONDARY);
210 c->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
211
212 static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] =
213 {
214 {0xFB4F, 0}, {0x3d, 0}, {0x05D0, 0x05DC} // Alef-Lamed vs. Alef, Lamed
215 };
216
217 compareArray(*c, tests, ARRAY_LENGTH(tests));
218
219 delete c;
220 }
221
222 // @bug 4058613
223 //
224 // Collator::createInstance() causes an ArrayIndexOutofBoundsException for Korean
225 //
226 void CollationRegressionTest::Test4058613(/* char* par */)
227 {
228 // Creating a default collator doesn't work when Korean is the default
229 // locale
230
231 Locale oldDefault = Locale::getDefault();
232 UErrorCode status = U_ZERO_ERROR;
233
234 Locale::setDefault(Locale::getKorean(), status);
235
236 if (U_FAILURE(status))
237 {
238 errln("Could not set default locale to Locale::KOREAN");
239 return;
240 }
241
242 Collator *c = NULL;
243
244 c = Collator::createInstance("en_US", status);
245
246 if (c == NULL || U_FAILURE(status))
247 {
248 errln("Could not create a Korean collator");
249 Locale::setDefault(oldDefault, status);
250 delete c;
251 return;
252 }
253
254 // Since the fix to this bug was to turn off decomposition for Korean collators,
255 // ensure that's what we got
256 if (c->getAttribute(UCOL_NORMALIZATION_MODE, status) != UCOL_OFF)
257 {
258 errln("Decomposition is not set to NO_DECOMPOSITION for Korean collator");
259 }
260
261 delete c;
262
263 Locale::setDefault(oldDefault, status);
264 }
265
266 // @bug 4059820
267 //
268 // RuleBasedCollator.getRules does not return the exact pattern as input
269 // for expanding character sequences
270 //
271 void CollationRegressionTest::Test4059820(/* char* par */)
272 {
273 UErrorCode status = U_ZERO_ERROR;
274
275 RuleBasedCollator *c = NULL;
276 UnicodeString rules = "< a < b , c/a < d < z";
277
278 c = new RuleBasedCollator(rules, status);
279
280 if (c == NULL || U_FAILURE(status))
281 {
282 errln("Failure building a collator.");
283 delete c;
284 return;
285 }
286
287 if ( c->getRules().indexOf("c/a") == -1)
288 {
289 errln("returned rules do not contain 'c/a'");
290 }
291
292 delete c;
293 }
294
295 // @bug 4060154
296 //
297 // MergeCollation::fixEntry broken for "& H < \u0131, \u0130, i, I"
298 //
299 void CollationRegressionTest::Test4060154(/* char* par */)
300 {
301 UErrorCode status = U_ZERO_ERROR;
302 UnicodeString rules;
303
304 rules += "< g, G < h, H < i, I < j, J";
305 rules += " & H < ";
306 rules += (UChar)0x0131;
307 rules += ", ";
308 rules += (UChar)0x0130;
309 rules += ", i, I";
310
311 RuleBasedCollator *c = NULL;
312
313 c = new RuleBasedCollator(rules, status);
314
315 if (c == NULL || U_FAILURE(status))
316 {
317 errln("failure building collator.");
318 delete c;
319 return;
320 }
321
322 c->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
323
324 /*
325 String[] tertiary = {
326 "A", "<", "B",
327 "H", "<", "\u0131",
328 "H", "<", "I",
329 "\u0131", "<", "\u0130",
330 "\u0130", "<", "i",
331 "\u0130", ">", "H",
332 };
333 */
334
335 static const UChar tertiary[][CollationRegressionTest::MAX_TOKEN_LEN] =
336 {
337 {0x41, 0}, {0x3c, 0}, {0x42, 0},
338 {0x48, 0}, {0x3c, 0}, {0x0131, 0},
339 {0x48, 0}, {0x3c, 0}, {0x49, 0},
340 {0x0131, 0}, {0x3c, 0}, {0x0130, 0},
341 {0x0130, 0}, {0x3c, 0}, {0x69, 0},
342 {0x0130, 0}, {0x3e, 0}, {0x48, 0}
343 };
344
345 c->setStrength(Collator::TERTIARY);
346 compareArray(*c, tertiary, ARRAY_LENGTH(tertiary));
347
348 /*
349 String[] secondary = {
350 "H", "<", "I",
351 "\u0131", "=", "\u0130",
352 };
353 */
354 static const UChar secondary[][CollationRegressionTest::MAX_TOKEN_LEN] =
355 {
356 {0x48, 0}, {0x3c, 0}, {0x49, 0},
357 {0x0131, 0}, {0x3d, 0}, {0x0130, 0}
358 };
359
360 c->setStrength(Collator::PRIMARY);
361 compareArray(*c, secondary, ARRAY_LENGTH(secondary));
362
363 delete c;
364 }
365
366 // @bug 4062418
367 //
368 // Secondary/Tertiary comparison incorrect in French Secondary
369 //
370 void CollationRegressionTest::Test4062418(/* char* par */)
371 {
372 UErrorCode status = U_ZERO_ERROR;
373
374 RuleBasedCollator *c = NULL;
375
376 c = (RuleBasedCollator *) Collator::createInstance(Locale::getCanadaFrench(), status);
377
378 if (c == NULL || U_FAILURE(status))
379 {
380 errln("Failed to create collator for Locale::getCanadaFrench()");
381 delete c;
382 return;
383 }
384
385 c->setStrength(Collator::SECONDARY);
386
387 /*
388 String[] tests = {
389 "p\u00eache", "<", "p\u00e9ch\u00e9", // Comparing accents from end, p\u00e9ch\u00e9 is greater
390 };
391 */
392 static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] =
393 {
394 {0x70, 0x00EA, 0x63, 0x68, 0x65, 0}, {0x3c, 0}, {0x70, 0x00E9, 0x63, 0x68, 0x00E9, 0}
395 };
396
397 compareArray(*c, tests, ARRAY_LENGTH(tests));
398
399 delete c;
400 }
401
402 // @bug 4065540
403 //
404 // Collator::compare() method broken if either string contains spaces
405 //
406 void CollationRegressionTest::Test4065540(/* char* par */)
407 {
408 if (en_us->compare("abcd e", "abcd f") == 0)
409 {
410 errln("'abcd e' == 'abcd f'");
411 }
412 }
413
414 // @bug 4066189
415 //
416 // Unicode characters need to be recursively decomposed to get the
417 // correct result. For example,
418 // u1EB1 -> \u0103 + \u0300 -> a + \u0306 + \u0300.
419 //
420 void CollationRegressionTest::Test4066189(/* char* par */)
421 {
422 static const UChar chars1[] = {0x1EB1, 0};
423 static const UChar chars2[] = {0x61, 0x0306, 0x0300, 0};
424 const UnicodeString test1(chars1);
425 const UnicodeString test2(chars2);
426 UErrorCode status = U_ZERO_ERROR;
427
428 // NOTE: The java code used en_us to create the
429 // CollationElementIterator's. I'm pretty sure that
430 // was wrong, so I've change the code to use c1 and c2
431 RuleBasedCollator *c1 = (RuleBasedCollator *) en_us->clone();
432 c1->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
433 CollationElementIterator *i1 = c1->createCollationElementIterator(test1);
434
435 RuleBasedCollator *c2 = (RuleBasedCollator *) en_us->clone();
436 c2->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_OFF, status);
437 CollationElementIterator *i2 = c2->createCollationElementIterator(test2);
438
439 assertEqual(*i1, *i2);
440
441 delete i2;
442 delete c2;
443 delete i1;
444 delete c1;
445 }
446
447 // @bug 4066696
448 //
449 // French secondary collation checking at the end of compare iteration fails
450 //
451 void CollationRegressionTest::Test4066696(/* char* par */)
452 {
453 UErrorCode status = U_ZERO_ERROR;
454 RuleBasedCollator *c = NULL;
455
456 c = (RuleBasedCollator *)Collator::createInstance(Locale::getCanadaFrench(), status);
457
458 if (c == NULL || U_FAILURE(status))
459 {
460 errln("Failure creating collator for Locale::getCanadaFrench()");
461 delete c;
462 return;
463 }
464
465 c->setStrength(Collator::SECONDARY);
466
467 /*
468 String[] tests = {
469 "\u00e0", "<", "\u01fa", // a-grave < A-ring-acute
470 };
471
472 should be:
473
474 String[] tests = {
475 "\u00e0", ">", "\u01fa", // a-grave < A-ring-acute
476 };
477
478 */
479
480 static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] =
481 {
482 {0x00E0, 0}, {0x3e, 0}, {0x01FA, 0}
483 };
484
485 compareArray(*c, tests, ARRAY_LENGTH(tests));
486
487 delete c;
488 }
489
490 // @bug 4076676
491 //
492 // Bad canonicalization of same-class combining characters
493 //
494 void CollationRegressionTest::Test4076676(/* char* par */)
495 {
496 // These combining characters are all in the same class, so they should not
497 // be reordered, and they should compare as unequal.
498 static const UChar s1[] = {0x41, 0x0301, 0x0302, 0x0300, 0};
499 static const UChar s2[] = {0x41, 0x0302, 0x0300, 0x0301, 0};
500
501 RuleBasedCollator *c = (RuleBasedCollator *) en_us->clone();
502 c->setStrength(Collator::TERTIARY);
503
504 if (c->compare(s1,s2) == 0)
505 {
506 errln("Same-class combining chars were reordered");
507 }
508
509 delete c;
510 }
511
512 // @bug 4079231
513 //
514 // RuleBasedCollator::operator==(NULL) throws NullPointerException
515 //
516 void CollationRegressionTest::Test4079231(/* char* par */)
517 {
518 // I don't think there's any way to write this test
519 // in C++. The following is equivalent to the Java,
520 // but doesn't compile 'cause NULL can't be converted
521 // to Collator&
522 //
523 // if (en_us->operator==(NULL))
524 // {
525 // errln("en_us->operator==(NULL) returned TRUE");
526 // }
527
528 /*
529 try {
530 if (en_us->equals(null)) {
531 errln("en_us->equals(null) returned true");
532 }
533 }
534 catch (Exception e) {
535 errln("en_us->equals(null) threw " + e.toString());
536 }
537 */
538 }
539
540 // @bug 4078588
541 //
542 // RuleBasedCollator breaks on "< a < bb" rule
543 //
544 void CollationRegressionTest::Test4078588(/* char *par */)
545 {
546 UErrorCode status = U_ZERO_ERROR;
547 RuleBasedCollator *rbc = new RuleBasedCollator((UnicodeString)"< a < bb", status);
548
549 if (rbc == NULL || U_FAILURE(status))
550 {
551 errln("Failed to create RuleBasedCollator.");
552 delete rbc;
553 return;
554 }
555
556 Collator::EComparisonResult result = rbc->compare("a","bb");
557
558 if (result != Collator::LESS)
559 {
560 errln((UnicodeString)"Compare(a,bb) returned " + (int)result
561 + (UnicodeString)"; expected -1");
562 }
563
564 delete rbc;
565 }
566
567 // @bug 4081866
568 //
569 // Combining characters in different classes not reordered properly.
570 //
571 void CollationRegressionTest::Test4081866(/* char* par */)
572 {
573 // These combining characters are all in different classes,
574 // so they should be reordered and the strings should compare as equal.
575 static const UChar s1[] = {0x41, 0x0300, 0x0316, 0x0327, 0x0315, 0};
576 static const UChar s2[] = {0x41, 0x0327, 0x0316, 0x0315, 0x0300, 0};
577
578 UErrorCode status = U_ZERO_ERROR;
579 RuleBasedCollator *c = (RuleBasedCollator *) en_us->clone();
580 c->setStrength(Collator::TERTIARY);
581
582 // Now that the default collators are set to NO_DECOMPOSITION
583 // (as a result of fixing bug 4114077), we must set it explicitly
584 // when we're testing reordering behavior. -- lwerner, 5/5/98
585 c->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
586
587 if (c->compare(s1,s2) != 0)
588 {
589 errln("Combining chars were not reordered");
590 }
591
592 delete c;
593 }
594
595 // @bug 4087241
596 //
597 // string comparison errors in Scandinavian collators
598 //
599 void CollationRegressionTest::Test4087241(/* char* par */)
600 {
601 UErrorCode status = U_ZERO_ERROR;
602 Locale da_DK("da", "DK");
603 RuleBasedCollator *c = NULL;
604
605 c = (RuleBasedCollator *) Collator::createInstance(da_DK, status);
606
607 if (c == NULL || U_FAILURE(status))
608 {
609 errln("Failed to create collator for da_DK locale");
610 delete c;
611 return;
612 }
613
614 c->setStrength(Collator::SECONDARY);
615
616 static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] =
617 {
618 {0x7a, 0}, {0x3c, 0}, {0x00E6, 0}, // z < ae
619 {0x61, 0x0308, 0}, {0x3c, 0}, {0x61, 0x030A, 0}, // a-unlaut < a-ring
620 {0x59, 0}, {0x3c, 0}, {0x75, 0x0308, 0}, // Y < u-umlaut
621 };
622
623 compareArray(*c, tests, ARRAY_LENGTH(tests));
624
625 delete c;
626 }
627
628 // @bug 4087243
629 //
630 // CollationKey takes ignorable strings into account when it shouldn't
631 //
632 void CollationRegressionTest::Test4087243(/* char* par */)
633 {
634 RuleBasedCollator *c = (RuleBasedCollator *) en_us->clone();
635 c->setStrength(Collator::TERTIARY);
636
637 static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] =
638 {
639 {0x31, 0x32, 0x33, 0}, {0x3d, 0}, {0x31, 0x32, 0x33, 0x0001, 0} // 1 2 3 = 1 2 3 ctrl-A
640 };
641
642 compareArray(*c, tests, ARRAY_LENGTH(tests));
643
644 delete c;
645 }
646
647 // @bug 4092260
648 //
649 // Mu/micro conflict
650 // Micro symbol and greek lowercase letter Mu should sort identically
651 //
652 void CollationRegressionTest::Test4092260(/* char* par */)
653 {
654 UErrorCode status = U_ZERO_ERROR;
655 Locale el("el", "");
656 Collator *c = NULL;
657
658 c = Collator::createInstance(el, status);
659
660 if (c == NULL || U_FAILURE(status))
661 {
662 errln("Failed to create collator for el locale.");
663 delete c;
664 return;
665 }
666
667 // These now have tertiary differences in UCA
668 c->setAttribute(UCOL_STRENGTH, UCOL_SECONDARY, status);
669
670 static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] =
671 {
672 {0x00B5, 0}, {0x3d, 0}, {0x03BC, 0}
673 };
674
675 compareArray(*c, tests, ARRAY_LENGTH(tests));
676
677 delete c;
678 }
679
680 // @bug 4095316
681 //
682 void CollationRegressionTest::Test4095316(/* char* par */)
683 {
684 UErrorCode status = U_ZERO_ERROR;
685 Locale el_GR("el", "GR");
686 Collator *c = Collator::createInstance(el_GR, status);
687
688 if (c == NULL || U_FAILURE(status))
689 {
690 errln("Failed to create collator for el_GR locale");
691 delete c;
692 return;
693 }
694 // These now have tertiary differences in UCA
695 //c->setStrength(Collator::TERTIARY);
696 c->setAttribute(UCOL_STRENGTH, UCOL_SECONDARY, status);
697
698 static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] =
699 {
700 {0x03D4, 0}, {0x3d, 0}, {0x03AB, 0}
701 };
702
703 compareArray(*c, tests, ARRAY_LENGTH(tests));
704
705 delete c;
706 }
707
708 // @bug 4101940
709 //
710 void CollationRegressionTest::Test4101940(/* char* par */)
711 {
712 UErrorCode status = U_ZERO_ERROR;
713 RuleBasedCollator *c = NULL;
714 UnicodeString rules = "< a < b";
715 UnicodeString nothing = "";
716
717 c = new RuleBasedCollator(rules, status);
718
719 if (c == NULL || U_FAILURE(status))
720 {
721 errln("Failed to create RuleBasedCollator");
722 delete c;
723 return;
724 }
725
726 CollationElementIterator *i = c->createCollationElementIterator(nothing);
727 i->reset();
728
729 if (i->next(status) != CollationElementIterator::NULLORDER)
730 {
731 errln("next did not return NULLORDER");
732 }
733
734 delete i;
735 delete c;
736 }
737
738 // @bug 4103436
739 //
740 // Collator::compare not handling spaces properly
741 //
742 void CollationRegressionTest::Test4103436(/* char* par */)
743 {
744 RuleBasedCollator *c = (RuleBasedCollator *) en_us->clone();
745 c->setStrength(Collator::TERTIARY);
746
747 static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] =
748 {
749 {0x66, 0x69, 0x6c, 0x65, 0}, {0x3c, 0}, {0x66, 0x69, 0x6c, 0x65, 0x20, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0},
750 {0x66, 0x69, 0x6c, 0x65, 0}, {0x3c, 0}, {0x66, 0x69, 0x6c, 0x65, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0}
751 };
752
753 compareArray(*c, tests, ARRAY_LENGTH(tests));
754
755 delete c;
756 }
757
758 // @bug 4114076
759 //
760 // Collation not Unicode conformant with Hangul syllables
761 //
762 void CollationRegressionTest::Test4114076(/* char* par */)
763 {
764 UErrorCode status = U_ZERO_ERROR;
765 RuleBasedCollator *c = (RuleBasedCollator *) en_us->clone();
766 c->setStrength(Collator::TERTIARY);
767
768 //
769 // With Canonical decomposition, Hangul syllables should get decomposed
770 // into Jamo, but Jamo characters should not be decomposed into
771 // conjoining Jamo
772 //
773 static const UChar test1[][CollationRegressionTest::MAX_TOKEN_LEN] =
774 {
775 {0xd4db, 0}, {0x3d, 0}, {0x1111, 0x1171, 0x11b6, 0}
776 };
777
778 c->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
779 compareArray(*c, test1, ARRAY_LENGTH(test1));
780
781 // From UTR #15:
782 // *In earlier versions of Unicode, jamo characters like ksf
783 // had compatibility mappings to kf + sf. These mappings were
784 // removed in Unicode 2.1.9 to ensure that Hangul syllables are maintained.)
785 // That is, the following test is obsolete as of 2.1.9
786
787 //obsolete- // With Full decomposition, it should go all the way down to
788 //obsolete- // conjoining Jamo characters.
789 //obsolete- //
790 //obsolete- static const UChar test2[][CollationRegressionTest::MAX_TOKEN_LEN] =
791 //obsolete- {
792 //obsolete- {0xd4db, 0}, {0x3d, 0}, {0x1111, 0x116e, 0x1175, 0x11af, 0x11c2, 0}
793 //obsolete- };
794 //obsolete-
795 //obsolete- c->setDecomposition(Normalizer::DECOMP_COMPAT);
796 //obsolete- compareArray(*c, test2, ARRAY_LENGTH(test2));
797
798 delete c;
799 }
800
801
802 // @bug 4124632
803 //
804 // Collator::getCollationKey was hanging on certain character sequences
805 //
806 void CollationRegressionTest::Test4124632(/* char* par */)
807 {
808 UErrorCode status = U_ZERO_ERROR;
809 Collator *coll = NULL;
810
811 coll = Collator::createInstance(Locale::getJapan(), status);
812
813 if (coll == NULL || U_FAILURE(status))
814 {
815 errln("Failed to create collator for Locale::JAPAN");
816 delete coll;
817 return;
818 }
819
820 static const UChar test[] = {0x41, 0x0308, 0x62, 0x63, 0};
821 CollationKey key;
822
823 coll->getCollationKey(test, key, status);
824
825 if (key.isBogus() || U_FAILURE(status))
826 {
827 errln("CollationKey creation failed.");
828 }
829
830 delete coll;
831 }
832
833 // @bug 4132736
834 //
835 // sort order of french words with multiple accents has errors
836 //
837 void CollationRegressionTest::Test4132736(/* char* par */)
838 {
839 UErrorCode status = U_ZERO_ERROR;
840
841 Collator *c = NULL;
842
843 c = Collator::createInstance(Locale::getCanadaFrench(), status);
844 c->setStrength(Collator::TERTIARY);
845
846 if (c == NULL || U_FAILURE(status))
847 {
848 errln("Failed to create a collator for Locale::getCanadaFrench()");
849 delete c;
850 return;
851 }
852
853 static const UChar test1[][CollationRegressionTest::MAX_TOKEN_LEN] =
854 {
855 {0x65, 0x0300, 0x65, 0x0301, 0}, {0x3c, 0}, {0x65, 0x0301, 0x65, 0x0300, 0},
856 {0x65, 0x0300, 0x0301, 0}, {0x3c, 0}, {0x65, 0x0301, 0x0300, 0}
857 };
858
859 compareArray(*c, test1, ARRAY_LENGTH(test1));
860
861 delete c;
862 }
863
864 // @bug 4133509
865 //
866 // The sorting using java.text.CollationKey is not in the exact order
867 //
868 void CollationRegressionTest::Test4133509(/* char* par */)
869 {
870 static const UChar test1[][CollationRegressionTest::MAX_TOKEN_LEN] =
871 {
872 {0x45, 0x78, 0x63, 0x65, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0}, {0x3c, 0}, {0x45, 0x78, 0x63, 0x65, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x49, 0x6e, 0x69, 0x74, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x72, 0x45, 0x72, 0x72, 0x6f, 0x72, 0},
873 {0x47, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x73, 0}, {0x3c, 0}, {0x47, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x73, 0x45, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74, 0},
874 {0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0}, {0x3c, 0}, {0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x42, 0x75, 0x66, 0x66, 0x65, 0x72, 0}
875 };
876
877 compareArray(*en_us, test1, ARRAY_LENGTH(test1));
878 }
879
880 // @bug 4114077
881 //
882 // Collation with decomposition off doesn't work for Europe
883 //
884 void CollationRegressionTest::Test4114077(/* char* par */)
885 {
886 // Ensure that we get the same results with decomposition off
887 // as we do with it on....
888
889 UErrorCode status = U_ZERO_ERROR;
890 RuleBasedCollator *c = (RuleBasedCollator *) en_us->clone();
891 c->setStrength(Collator::TERTIARY);
892
893 static const UChar test1[][CollationRegressionTest::MAX_TOKEN_LEN] =
894 {
895 {0x00C0, 0}, {0x3d, 0}, {0x41, 0x0300, 0}, // Should be equivalent
896 {0x70, 0x00ea, 0x63, 0x68, 0x65, 0}, {0x3e, 0}, {0x70, 0x00e9, 0x63, 0x68, 0x00e9, 0},
897 {0x0204, 0}, {0x3d, 0}, {0x45, 0x030F, 0},
898 {0x01fa, 0}, {0x3d, 0}, {0x41, 0x030a, 0x0301, 0}, // a-ring-acute -> a-ring, acute
899 // -> a, ring, acute
900 {0x41, 0x0300, 0x0316, 0}, {0x3c, 0}, {0x41, 0x0316, 0x0300, 0} // No reordering --> unequal
901 };
902
903 c->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_OFF, status);
904 compareArray(*c, test1, ARRAY_LENGTH(test1));
905
906 static const UChar test2[][CollationRegressionTest::MAX_TOKEN_LEN] =
907 {
908 {0x41, 0x0300, 0x0316, 0}, {0x3d, 0}, {0x41, 0x0316, 0x0300, 0} // Reordering --> equal
909 };
910
911 c->setAttribute(UCOL_NORMALIZATION_MODE, UCOL_ON, status);
912 compareArray(*c, test2, ARRAY_LENGTH(test2));
913
914 delete c;
915 }
916
917 // @bug 4141640
918 //
919 // Support for Swedish gone in 1.1.6 (Can't create Swedish collator)
920 //
921 void CollationRegressionTest::Test4141640(/* char* par */)
922 {
923 //
924 // Rather than just creating a Swedish collator, we might as well
925 // try to instantiate one for every locale available on the system
926 // in order to prevent this sort of bug from cropping up in the future
927 //
928 UErrorCode status = U_ZERO_ERROR;
929 int32_t i, localeCount;
930 const Locale *locales = Locale::getAvailableLocales(localeCount);
931
932 for (i = 0; i < localeCount; i += 1)
933 {
934 Collator *c = NULL;
935
936 status = U_ZERO_ERROR;
937 c = Collator::createInstance(locales[i], status);
938
939 if (c == NULL || U_FAILURE(status))
940 {
941 UnicodeString msg, localeName;
942
943 msg += "Could not create collator for locale ";
944 msg += locales[i].getName();
945
946 errln(msg);
947 }
948
949 delete c;
950 }
951 }
952
953 // @bug 4139572
954 //
955 // getCollationKey throws exception for spanish text
956 // Cannot reproduce this bug on 1.2, however it DOES fail on 1.1.6
957 //
958 void CollationRegressionTest::Test4139572(/* char* par */)
959 {
960 //
961 // Code pasted straight from the bug report
962 // (and then translated to C++ ;-)
963 //
964 // create spanish locale and collator
965 UErrorCode status = U_ZERO_ERROR;
966 Locale l("es", "es");
967 Collator *col = NULL;
968
969 col = Collator::createInstance(l, status);
970
971 if (col == NULL || U_FAILURE(status))
972 {
973 errln("Failed to create a collator for es_es locale.");
974 delete col;
975 return;
976 }
977
978 CollationKey key;
979
980 // this spanish phrase kills it!
981 col->getCollationKey("Nombre De Objeto", key, status);
982
983 if (key.isBogus() || U_FAILURE(status))
984 {
985 errln("Error creating CollationKey for \"Nombre De Ojbeto\"");
986 }
987
988 delete col;
989 }
990 /* HSYS : RuleBasedCollator::compare() performance enhancements
991 compare() does not create CollationElementIterator() anymore.*/
992
993 class My4146160Collator : public RuleBasedCollator
994 {
995 public:
996 My4146160Collator(RuleBasedCollator &rbc, UErrorCode &status);
997 ~My4146160Collator();
998
999 CollationElementIterator *createCollationElementIterator(const UnicodeString &text) const;
1000
1001 CollationElementIterator *createCollationElementIterator(const CharacterIterator &text) const;
1002
1003 static int32_t count;
1004 };
1005
1006 int32_t My4146160Collator::count = 0;
1007
1008 My4146160Collator::My4146160Collator(RuleBasedCollator &rbc, UErrorCode &status)
1009 : RuleBasedCollator(rbc.getRules(), status)
1010 {
1011 }
1012
1013 My4146160Collator::~My4146160Collator()
1014 {
1015 }
1016
1017 CollationElementIterator *My4146160Collator::createCollationElementIterator(const UnicodeString &text) const
1018 {
1019 count += 1;
1020 return RuleBasedCollator::createCollationElementIterator(text);
1021 }
1022
1023 CollationElementIterator *My4146160Collator::createCollationElementIterator(const CharacterIterator &text) const
1024 {
1025 count += 1;
1026 return RuleBasedCollator::createCollationElementIterator(text);
1027 }
1028
1029 // @bug 4146160
1030 //
1031 // RuleBasedCollator doesn't use createCollationElementIterator internally
1032 //
1033 void CollationRegressionTest::Test4146160(/* char* par */)
1034 {
1035 #if 0
1036 //
1037 // Use a custom collator class whose createCollationElementIterator
1038 // methods increment a count....
1039 //
1040 UErrorCode status = U_ZERO_ERROR;
1041 CollationKey key;
1042
1043 My4146160Collator::count = 0;
1044 My4146160Collator *mc = NULL;
1045
1046 mc = new My4146160Collator(*en_us, status);
1047
1048 if (mc == NULL || U_FAILURE(status))
1049 {
1050 errln("Failed to create a My4146160Collator.");
1051 delete mc;
1052 return;
1053 }
1054
1055 mc->getCollationKey("1", key, status);
1056
1057 if (key.isBogus() || U_FAILURE(status))
1058 {
1059 errln("Failure to get a CollationKey from a My4146160Collator.");
1060 delete mc;
1061 return;
1062 }
1063
1064 if (My4146160Collator::count < 1)
1065 {
1066 errln("My4146160Collator::createCollationElementIterator not called for getCollationKey");
1067 }
1068
1069 My4146160Collator::count = 0;
1070 mc->compare("1", "2");
1071
1072 if (My4146160Collator::count < 1)
1073 {
1074 errln("My4146160Collator::createtCollationElementIterator not called for compare");
1075 }
1076
1077 delete mc;
1078 #endif
1079 }
1080
1081 // Ticket 7189
1082 //
1083 // nextSortKeyPart incorrect for EO_S1 collation
1084 static int32_t calcKeyIncremental(UCollator *coll, const UChar* text, int32_t len, uint8_t *keyBuf, int32_t /*keyBufLen*/, UErrorCode& status) {
1085 UCharIterator uiter;
1086 uint32_t state[2] = { 0, 0 };
1087 int32_t keyLen;
1088 int32_t count = 8;
1089
1090 uiter_setString(&uiter, text, len);
1091 keyLen = 0;
1092 while (TRUE) {
1093 int32_t keyPartLen = ucol_nextSortKeyPart(coll, &uiter, state, &keyBuf[keyLen], count, &status);
1094 if (U_FAILURE(status)) {
1095 return -1;
1096 }
1097 if (keyPartLen == 0) {
1098 break;
1099 }
1100 keyLen += keyPartLen;
1101 }
1102 return keyLen;
1103 }
1104
1105 void CollationRegressionTest::TestT7189() {
1106 UErrorCode status = U_ZERO_ERROR;
1107 UCollator *coll;
1108 uint32_t i;
1109
1110 static const UChar text1[][CollationRegressionTest::MAX_TOKEN_LEN] = {
1111 // "Achter De Hoven"
1112 { 0x41, 0x63, 0x68, 0x74, 0x65, 0x72, 0x20, 0x44, 0x65, 0x20, 0x48, 0x6F, 0x76, 0x65, 0x6E, 0x00 },
1113 // "ABC"
1114 { 0x41, 0x42, 0x43, 0x00 },
1115 // "HELLO world!"
1116 { 0x48, 0x45, 0x4C, 0x4C, 0x4F, 0x20, 0x77, 0x6F, 0x72, 0x6C, 0x64, 0x21, 0x00 }
1117 };
1118
1119 static const UChar text2[][CollationRegressionTest::MAX_TOKEN_LEN] = {
1120 // "Achter de Hoven"
1121 { 0x41, 0x63, 0x68, 0x74, 0x65, 0x72, 0x20, 0x64, 0x65, 0x20, 0x48, 0x6F, 0x76, 0x65, 0x6E, 0x00 },
1122 // "abc"
1123 { 0x61, 0x62, 0x63, 0x00 },
1124 // "hello world!"
1125 { 0x68, 0x65, 0x6C, 0x6C, 0x6F, 0x20, 0x77, 0x6F, 0x72, 0x6C, 0x64, 0x21, 0x00 }
1126 };
1127
1128 // Open the collator
1129 coll = ucol_openFromShortString("EO_S1", FALSE, NULL, &status);
1130 if (U_FAILURE(status)) {
1131 errln("Failed to create a collator for short string EO_S1");
1132 return;
1133 }
1134
1135 for (i = 0; i < sizeof(text1) / (CollationRegressionTest::MAX_TOKEN_LEN * sizeof(UChar)); i++) {
1136 uint8_t key1[100], key2[100];
1137 int32_t len1, len2;
1138
1139 len1 = calcKeyIncremental(coll, text1[i], -1, key1, sizeof(key1), status);
1140 if (U_FAILURE(status)) {
1141 errln(UnicodeString("Failed to get a partial collation key for ") + text1[i]);
1142 break;
1143 }
1144 len2 = calcKeyIncremental(coll, text2[i], -1, key2, sizeof(key2), status);
1145 if (U_FAILURE(status)) {
1146 errln(UnicodeString("Failed to get a partial collation key for ") + text2[i]);
1147 break;
1148 }
1149
1150 if (len1 == len2 && uprv_memcmp(key1, key2, len1) == 0) {
1151 errln(UnicodeString("Failed: Identical key\n") + " text1: " + text1[i] + "\n" + " text2: " + text2[i] + "\n" + " key : " + TestUtility::hex(key1, len1));
1152 } else {
1153 logln(UnicodeString("Keys produced -\n") + " text1: " + text1[i] + "\n" + " key1 : " + TestUtility::hex(key1, len1) + "\n" + " text2: " + text2[i] + "\n" + " key2 : "
1154 + TestUtility::hex(key2, len2));
1155 }
1156 }
1157 ucol_close(coll);
1158 }
1159
1160 void CollationRegressionTest::TestCaseFirstCompression() {
1161 RuleBasedCollator *col = (RuleBasedCollator *) en_us->clone();
1162 UErrorCode status = U_ZERO_ERROR;
1163
1164 // default
1165 caseFirstCompressionSub(col, "default");
1166
1167 // Upper first
1168 col->setAttribute(UCOL_CASE_FIRST, UCOL_UPPER_FIRST, status);
1169 if (U_FAILURE(status)) {
1170 errln("Failed to set UCOL_UPPER_FIRST");
1171 return;
1172 }
1173 caseFirstCompressionSub(col, "upper first");
1174
1175 // Lower first
1176 col->setAttribute(UCOL_CASE_FIRST, UCOL_LOWER_FIRST, status);
1177 if (U_FAILURE(status)) {
1178 errln("Failed to set UCOL_LOWER_FIRST");
1179 return;
1180 }
1181 caseFirstCompressionSub(col, "lower first");
1182
1183 delete col;
1184 }
1185
1186 void CollationRegressionTest::caseFirstCompressionSub(Collator *col, UnicodeString opt) {
1187 const int32_t maxLength = 50;
1188
1189 UChar str1[maxLength];
1190 UChar str2[maxLength];
1191
1192 CollationKey key1, key2;
1193
1194 for (int32_t len = 1; len <= maxLength; len++) {
1195 int32_t i = 0;
1196 for (; i < len - 1; i++) {
1197 str1[i] = str2[i] = (UChar)0x61; // 'a'
1198 }
1199 str1[i] = (UChar)0x41; // 'A'
1200 str2[i] = (UChar)0x61; // 'a'
1201
1202 UErrorCode status = U_ZERO_ERROR;
1203 col->getCollationKey(str1, len, key1, status);
1204 col->getCollationKey(str2, len, key2, status);
1205
1206 UCollationResult cmpKey = key1.compareTo(key2, status);
1207 UCollationResult cmpCol = col->compare(str1, len, str2, len, status);
1208
1209 if (U_FAILURE(status)) {
1210 errln("Error in caseFirstCompressionSub");
1211 } else if (cmpKey != cmpCol) {
1212 errln((UnicodeString)"Inconsistent comparison(" + opt
1213 + "): str1=" + UnicodeString(str1, len) + ", str2=" + UnicodeString(str2, len)
1214 + ", cmpKey=" + cmpKey + ", cmpCol=" + cmpCol);
1215 }
1216 }
1217 }
1218
1219
1220
1221 void CollationRegressionTest::compareArray(Collator &c,
1222 const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN],
1223 int32_t testCount)
1224 {
1225 int32_t i;
1226 Collator::EComparisonResult expectedResult = Collator::EQUAL;
1227
1228 for (i = 0; i < testCount; i += 3)
1229 {
1230 UnicodeString source(tests[i]);
1231 UnicodeString comparison(tests[i + 1]);
1232 UnicodeString target(tests[i + 2]);
1233
1234 if (comparison == "<")
1235 {
1236 expectedResult = Collator::LESS;
1237 }
1238 else if (comparison == ">")
1239 {
1240 expectedResult = Collator::GREATER;
1241 }
1242 else if (comparison == "=")
1243 {
1244 expectedResult = Collator::EQUAL;
1245 }
1246 else
1247 {
1248 UnicodeString bogus1("Bogus comparison string \"");
1249 UnicodeString bogus2("\"");
1250 errln(bogus1 + comparison + bogus2);
1251 }
1252
1253 Collator::EComparisonResult compareResult = c.compare(source, target);
1254
1255 CollationKey sourceKey, targetKey;
1256 UErrorCode status = U_ZERO_ERROR;
1257
1258 c.getCollationKey(source, sourceKey, status);
1259
1260 if (U_FAILURE(status))
1261 {
1262 errln("Couldn't get collationKey for source");
1263 continue;
1264 }
1265
1266 c.getCollationKey(target, targetKey, status);
1267
1268 if (U_FAILURE(status))
1269 {
1270 errln("Couldn't get collationKey for target");
1271 continue;
1272 }
1273
1274 Collator::EComparisonResult keyResult = sourceKey.compareTo(targetKey);
1275
1276 reportCResult( source, target, sourceKey, targetKey, compareResult, keyResult, compareResult, expectedResult );
1277
1278 }
1279 }
1280
1281 void CollationRegressionTest::assertEqual(CollationElementIterator &i1, CollationElementIterator &i2)
1282 {
1283 int32_t c1, c2, count = 0;
1284 UErrorCode status = U_ZERO_ERROR;
1285
1286 do
1287 {
1288 c1 = i1.next(status);
1289 c2 = i2.next(status);
1290
1291 if (c1 != c2)
1292 {
1293 UnicodeString msg, msg1(" ");
1294
1295 msg += msg1 + count;
1296 msg += ": strength(0x";
1297 appendHex(c1, 8, msg);
1298 msg += ") != strength(0x";
1299 appendHex(c2, 8, msg);
1300 msg += ")";
1301
1302 errln(msg);
1303 break;
1304 }
1305
1306 count += 1;
1307 }
1308 while (c1 != CollationElementIterator::NULLORDER);
1309 }
1310
1311 void CollationRegressionTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /* par */)
1312 {
1313 if (exec)
1314 {
1315 logln("Collation Regression Tests: ");
1316 }
1317
1318 if(en_us) {
1319 switch (index)
1320 {
1321 case 0: name = "Test4048446"; if (exec) Test4048446(/* par */); break;
1322 case 1: name = "Test4051866"; if (exec) Test4051866(/* par */); break;
1323 case 2: name = "Test4053636"; if (exec) Test4053636(/* par */); break;
1324 case 3: name = "Test4054238"; if (exec) Test4054238(/* par */); break;
1325 case 4: name = "Test4054734"; if (exec) Test4054734(/* par */); break;
1326 case 5: name = "Test4054736"; if (exec) Test4054736(/* par */); break;
1327 case 6: name = "Test4058613"; if (exec) Test4058613(/* par */); break;
1328 case 7: name = "Test4059820"; if (exec) Test4059820(/* par */); break;
1329 case 8: name = "Test4060154"; if (exec) Test4060154(/* par */); break;
1330 case 9: name = "Test4062418"; if (exec) Test4062418(/* par */); break;
1331 case 10: name = "Test4065540"; if (exec) Test4065540(/* par */); break;
1332 case 11: name = "Test4066189"; if (exec) Test4066189(/* par */); break;
1333 case 12: name = "Test4066696"; if (exec) Test4066696(/* par */); break;
1334 case 13: name = "Test4076676"; if (exec) Test4076676(/* par */); break;
1335 case 14: name = "Test4078588"; if (exec) Test4078588(/* par */); break;
1336 case 15: name = "Test4079231"; if (exec) Test4079231(/* par */); break;
1337 case 16: name = "Test4081866"; if (exec) Test4081866(/* par */); break;
1338 case 17: name = "Test4087241"; if (exec) Test4087241(/* par */); break;
1339 case 18: name = "Test4087243"; if (exec) Test4087243(/* par */); break;
1340 case 19: name = "Test4092260"; if (exec) Test4092260(/* par */); break;
1341 case 20: name = "Test4095316"; if (exec) Test4095316(/* par */); break;
1342 case 21: name = "Test4101940"; if (exec) Test4101940(/* par */); break;
1343 case 22: name = "Test4103436"; if (exec) Test4103436(/* par */); break;
1344 case 23: name = "Test4114076"; if (exec) Test4114076(/* par */); break;
1345 case 24: name = "Test4114077"; if (exec) Test4114077(/* par */); break;
1346 case 25: name = "Test4124632"; if (exec) Test4124632(/* par */); break;
1347 case 26: name = "Test4132736"; if (exec) Test4132736(/* par */); break;
1348 case 27: name = "Test4133509"; if (exec) Test4133509(/* par */); break;
1349 case 28: name = "Test4139572"; if (exec) Test4139572(/* par */); break;
1350 case 29: name = "Test4141640"; if (exec) Test4141640(/* par */); break;
1351 case 30: name = "Test4146160"; if (exec) Test4146160(/* par */); break;
1352 case 31: name = "TestT7189"; if (exec) TestT7189(); break;
1353 case 32: name = "TestCaseFirstCompression"; if (exec) TestCaseFirstCompression(); break;
1354 default: name = ""; break;
1355 }
1356 } else {
1357 dataerrln("Class collator not instantiated");
1358 name = "";
1359 }
1360 }
1361
1362 #endif /* #if !UCONFIG_NO_COLLATION */
mirror of ICU