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