OLD | NEW |
1 /******************************************************************** | 1 /******************************************************************** |
2 * COPYRIGHT: | 2 * COPYRIGHT: |
3 * Copyright (c) 1997-2011, International Business Machines Corporation and | 3 * Copyright (c) 1997-2014, International Business Machines Corporation and |
4 * others. All Rights Reserved. | 4 * others. All Rights Reserved. |
5 ********************************************************************/ | 5 ********************************************************************/ |
6 | 6 |
7 #include "unicode/utypes.h" | 7 #include "unicode/utypes.h" |
8 | 8 |
9 #if !UCONFIG_NO_COLLATION | 9 #if !UCONFIG_NO_COLLATION |
10 | 10 |
11 #include "unicode/coll.h" | 11 #include "unicode/coll.h" |
| 12 #include "unicode/localpointer.h" |
12 #include "unicode/tblcoll.h" | 13 #include "unicode/tblcoll.h" |
13 #include "unicode/unistr.h" | 14 #include "unicode/unistr.h" |
14 #include "unicode/sortkey.h" | 15 #include "unicode/sortkey.h" |
15 #include "regcoll.h" | 16 #include "regcoll.h" |
16 #include "sfwdchit.h" | 17 #include "sfwdchit.h" |
17 #include "testutil.h" | 18 #include "testutil.h" |
18 #include "cmemory.h" | 19 #include "cmemory.h" |
19 | 20 |
20 #define ARRAY_LENGTH(array) ((int32_t)(sizeof array / sizeof array[0])) | 21 #define ARRAY_LENGTH(array) ((int32_t)(sizeof array / sizeof array[0])) |
21 | 22 |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
77 delete i1; | 78 delete i1; |
78 delete i2; | 79 delete i2; |
79 } | 80 } |
80 | 81 |
81 // @bug 4051866 | 82 // @bug 4051866 |
82 // | 83 // |
83 // Collator -> rules -> Collator round-trip broken for expanding characters | 84 // Collator -> rules -> Collator round-trip broken for expanding characters |
84 // | 85 // |
85 void CollationRegressionTest::Test4051866(/* char* par */) | 86 void CollationRegressionTest::Test4051866(/* char* par */) |
86 { | 87 { |
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; | 88 UnicodeString rules; |
97 UErrorCode status = U_ZERO_ERROR; | 89 UErrorCode status = U_ZERO_ERROR; |
98 | 90 |
99 rules += "< o "; | 91 rules += "&n < o "; |
100 rules += "& oe ,o"; | 92 rules += "& oe ,o"; |
101 rules += (UChar)0x3080; | 93 rules += (UChar)0x3080; |
102 rules += "& oe ,"; | 94 rules += "& oe ,"; |
103 rules += (UChar)0x1530; | 95 rules += (UChar)0x1530; |
104 rules += " ,O"; | 96 rules += " ,O"; |
105 rules += "& OE ,O"; | 97 rules += "& OE ,O"; |
106 rules += (UChar)0x3080; | 98 rules += (UChar)0x3080; |
107 rules += "& OE ,"; | 99 rules += "& OE ,"; |
108 rules += (UChar)0x1520; | 100 rules += (UChar)0x1520; |
109 rules += "< p ,P"; | 101 rules += "< p ,P"; |
110 | 102 |
111 // Build a collator containing expanding characters | 103 // Build a collator containing expanding characters |
112 RuleBasedCollator *c1 = new RuleBasedCollator(rules, status); | 104 LocalPointer<RuleBasedCollator> c1(new RuleBasedCollator(rules, status)); |
113 | 105 |
114 // Build another using the rules from the first | 106 // Build another using the rules from the first |
115 RuleBasedCollator *c2 = new RuleBasedCollator(c1->getRules(), status); | 107 LocalPointer<RuleBasedCollator> c2(new RuleBasedCollator(c1->getRules(), sta
tus)); |
| 108 if (U_FAILURE(status)) { |
| 109 errln("RuleBasedCollator(rule string) failed - %s", u_errorName(status))
; |
| 110 return; |
| 111 } |
116 | 112 |
117 // Make sure they're the same | 113 // Make sure they're the same |
118 if (!(c1->getRules() == c2->getRules())) | 114 if (!(c1->getRules() == c2->getRules())) |
119 { | 115 { |
120 errln("Rules are not equal"); | 116 errln("Rules are not equal"); |
121 } | 117 } |
122 | |
123 delete c2; | |
124 delete c1; | |
125 } | 118 } |
126 | 119 |
127 // @bug 4053636 | 120 // @bug 4053636 |
128 // | 121 // |
129 // Collator thinks "black-bird" == "black" | 122 // Collator thinks "black-bird" == "black" |
130 // | 123 // |
131 void CollationRegressionTest::Test4053636(/* char* par */) | 124 void CollationRegressionTest::Test4053636(/* char* par */) |
132 { | 125 { |
133 if (en_us->equals("black_bird", "black")) | 126 if (en_us->equals("black_bird", "black")) |
134 { | 127 { |
(...skipping 131 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
266 // @bug 4059820 | 259 // @bug 4059820 |
267 // | 260 // |
268 // RuleBasedCollator.getRules does not return the exact pattern as input | 261 // RuleBasedCollator.getRules does not return the exact pattern as input |
269 // for expanding character sequences | 262 // for expanding character sequences |
270 // | 263 // |
271 void CollationRegressionTest::Test4059820(/* char* par */) | 264 void CollationRegressionTest::Test4059820(/* char* par */) |
272 { | 265 { |
273 UErrorCode status = U_ZERO_ERROR; | 266 UErrorCode status = U_ZERO_ERROR; |
274 | 267 |
275 RuleBasedCollator *c = NULL; | 268 RuleBasedCollator *c = NULL; |
276 UnicodeString rules = "< a < b , c/a < d < z"; | 269 UnicodeString rules = "&9 < a < b , c/a < d < z"; |
277 | 270 |
278 c = new RuleBasedCollator(rules, status); | 271 c = new RuleBasedCollator(rules, status); |
279 | 272 |
280 if (c == NULL || U_FAILURE(status)) | 273 if (c == NULL || U_FAILURE(status)) |
281 { | 274 { |
282 errln("Failure building a collator."); | 275 errln("Failure building a collator."); |
283 delete c; | 276 delete c; |
284 return; | 277 return; |
285 } | 278 } |
286 | 279 |
287 if ( c->getRules().indexOf("c/a") == -1) | 280 if ( c->getRules().indexOf("c/a") == -1) |
288 { | 281 { |
289 errln("returned rules do not contain 'c/a'"); | 282 errln("returned rules do not contain 'c/a'"); |
290 } | 283 } |
291 | 284 |
292 delete c; | 285 delete c; |
293 } | 286 } |
294 | 287 |
295 // @bug 4060154 | 288 // @bug 4060154 |
296 // | 289 // |
297 // MergeCollation::fixEntry broken for "& H < \u0131, \u0130, i, I" | 290 // MergeCollation::fixEntry broken for "& H < \u0131, \u0130, i, I" |
298 // | 291 // |
299 void CollationRegressionTest::Test4060154(/* char* par */) | 292 void CollationRegressionTest::Test4060154(/* char* par */) |
300 { | 293 { |
301 UErrorCode status = U_ZERO_ERROR; | 294 UErrorCode status = U_ZERO_ERROR; |
302 UnicodeString rules; | 295 UnicodeString rules; |
303 | 296 |
304 rules += "< g, G < h, H < i, I < j, J"; | 297 rules += "&f < g, G < h, H < i, I < j, J"; |
305 rules += " & H < "; | 298 rules += " & H < "; |
306 rules += (UChar)0x0131; | 299 rules += (UChar)0x0131; |
307 rules += ", "; | 300 rules += ", "; |
308 rules += (UChar)0x0130; | 301 rules += (UChar)0x0130; |
309 rules += ", i, I"; | 302 rules += ", i, I"; |
310 | 303 |
311 RuleBasedCollator *c = NULL; | 304 RuleBasedCollator *c = NULL; |
312 | 305 |
313 c = new RuleBasedCollator(rules, status); | 306 c = new RuleBasedCollator(rules, status); |
314 | 307 |
(...skipping 222 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
537 */ | 530 */ |
538 } | 531 } |
539 | 532 |
540 // @bug 4078588 | 533 // @bug 4078588 |
541 // | 534 // |
542 // RuleBasedCollator breaks on "< a < bb" rule | 535 // RuleBasedCollator breaks on "< a < bb" rule |
543 // | 536 // |
544 void CollationRegressionTest::Test4078588(/* char *par */) | 537 void CollationRegressionTest::Test4078588(/* char *par */) |
545 { | 538 { |
546 UErrorCode status = U_ZERO_ERROR; | 539 UErrorCode status = U_ZERO_ERROR; |
547 RuleBasedCollator *rbc = new RuleBasedCollator((UnicodeString)"< a < bb", st
atus); | 540 RuleBasedCollator *rbc = new RuleBasedCollator("&9 < a < bb", status); |
548 | 541 |
549 if (rbc == NULL || U_FAILURE(status)) | 542 if (rbc == NULL || U_FAILURE(status)) |
550 { | 543 { |
551 errln("Failed to create RuleBasedCollator."); | 544 errln("Failed to create RuleBasedCollator."); |
552 delete rbc; | 545 delete rbc; |
553 return; | 546 return; |
554 } | 547 } |
555 | 548 |
556 Collator::EComparisonResult result = rbc->compare("a","bb"); | 549 Collator::EComparisonResult result = rbc->compare("a","bb"); |
557 | 550 |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
609 errln("Failed to create collator for da_DK locale"); | 602 errln("Failed to create collator for da_DK locale"); |
610 delete c; | 603 delete c; |
611 return; | 604 return; |
612 } | 605 } |
613 | 606 |
614 c->setStrength(Collator::SECONDARY); | 607 c->setStrength(Collator::SECONDARY); |
615 | 608 |
616 static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] = | 609 static const UChar tests[][CollationRegressionTest::MAX_TOKEN_LEN] = |
617 { | 610 { |
618 {0x7a, 0}, {0x3c, 0}, {0x00E6, 0}, // z < ae | 611 {0x7a, 0}, {0x3c, 0}, {0x00E6, 0}, // z < ae |
619 {0x61, 0x0308, 0}, {0x3c, 0}, {0x61, 0x030A, 0}, // a-unlaut < a-ri
ng | 612 {0x61, 0x0308, 0}, {0x3c, 0}, {0x61, 0x030A, 0}, // a-umlaut < a-r
ing |
620 {0x59, 0}, {0x3c, 0}, {0x75, 0x0308, 0}, // Y < u-u
mlaut | 613 {0x59, 0}, {0x3c, 0}, {0x75, 0x0308, 0}, // Y < u-u
mlaut |
621 }; | 614 }; |
622 | 615 |
623 compareArray(*c, tests, ARRAY_LENGTH(tests)); | 616 compareArray(*c, tests, ARRAY_LENGTH(tests)); |
624 | 617 |
625 delete c; | 618 delete c; |
626 } | 619 } |
627 | 620 |
628 // @bug 4087243 | 621 // @bug 4087243 |
629 // | 622 // |
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
704 | 697 |
705 delete c; | 698 delete c; |
706 } | 699 } |
707 | 700 |
708 // @bug 4101940 | 701 // @bug 4101940 |
709 // | 702 // |
710 void CollationRegressionTest::Test4101940(/* char* par */) | 703 void CollationRegressionTest::Test4101940(/* char* par */) |
711 { | 704 { |
712 UErrorCode status = U_ZERO_ERROR; | 705 UErrorCode status = U_ZERO_ERROR; |
713 RuleBasedCollator *c = NULL; | 706 RuleBasedCollator *c = NULL; |
714 UnicodeString rules = "< a < b"; | 707 UnicodeString rules = "&9 < a < b"; |
715 UnicodeString nothing = ""; | 708 UnicodeString nothing = ""; |
716 | 709 |
717 c = new RuleBasedCollator(rules, status); | 710 c = new RuleBasedCollator(rules, status); |
718 | 711 |
719 if (c == NULL || U_FAILURE(status)) | 712 if (c == NULL || U_FAILURE(status)) |
720 { | 713 { |
721 errln("Failed to create RuleBasedCollator"); | 714 errln("Failed to create RuleBasedCollator"); |
722 delete c; | 715 delete c; |
723 return; | 716 return; |
724 } | 717 } |
(...skipping 346 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1071 | 1064 |
1072 if (My4146160Collator::count < 1) | 1065 if (My4146160Collator::count < 1) |
1073 { | 1066 { |
1074 errln("My4146160Collator::createtCollationElementIterator not called for
compare"); | 1067 errln("My4146160Collator::createtCollationElementIterator not called for
compare"); |
1075 } | 1068 } |
1076 | 1069 |
1077 delete mc; | 1070 delete mc; |
1078 #endif | 1071 #endif |
1079 } | 1072 } |
1080 | 1073 |
| 1074 void CollationRegressionTest::Test4179216() { |
| 1075 // you can position a CollationElementIterator in the middle of |
| 1076 // a contracting character sequence, yielding a bogus collation |
| 1077 // element |
| 1078 IcuTestErrorCode errorCode(*this, "Test4179216"); |
| 1079 RuleBasedCollator coll(en_us->getRules() + " & C < ch , cH , Ch , CH < cat <
crunchy", errorCode); |
| 1080 UnicodeString testText = "church church catcatcher runcrunchynchy"; |
| 1081 CollationElementIterator *iter = coll.createCollationElementIterator(testTex
t); |
| 1082 |
| 1083 // test that the "ch" combination works properly |
| 1084 iter->setOffset(4, errorCode); |
| 1085 int32_t elt4 = CollationElementIterator::primaryOrder(iter->next(errorCode))
; |
| 1086 |
| 1087 iter->reset(); |
| 1088 int32_t elt0 = CollationElementIterator::primaryOrder(iter->next(errorCode))
; |
| 1089 |
| 1090 iter->setOffset(5, errorCode); |
| 1091 int32_t elt5 = CollationElementIterator::primaryOrder(iter->next(errorCode))
; |
| 1092 |
| 1093 // Compares and prints only 16-bit primary weights. |
| 1094 if (elt4 != elt0 || elt5 != elt0) { |
| 1095 errln("The collation elements at positions 0 (0x%04x), " |
| 1096 "4 (0x%04x), and 5 (0x%04x) don't match.", |
| 1097 elt0, elt4, elt5); |
| 1098 } |
| 1099 |
| 1100 // test that the "cat" combination works properly |
| 1101 iter->setOffset(14, errorCode); |
| 1102 int32_t elt14 = CollationElementIterator::primaryOrder(iter->next(errorCode)
); |
| 1103 |
| 1104 iter->setOffset(15, errorCode); |
| 1105 int32_t elt15 = CollationElementIterator::primaryOrder(iter->next(errorCode)
); |
| 1106 |
| 1107 iter->setOffset(16, errorCode); |
| 1108 int32_t elt16 = CollationElementIterator::primaryOrder(iter->next(errorCode)
); |
| 1109 |
| 1110 iter->setOffset(17, errorCode); |
| 1111 int32_t elt17 = CollationElementIterator::primaryOrder(iter->next(errorCode)
); |
| 1112 |
| 1113 iter->setOffset(18, errorCode); |
| 1114 int32_t elt18 = CollationElementIterator::primaryOrder(iter->next(errorCode)
); |
| 1115 |
| 1116 iter->setOffset(19, errorCode); |
| 1117 int32_t elt19 = CollationElementIterator::primaryOrder(iter->next(errorCode)
); |
| 1118 |
| 1119 // Compares and prints only 16-bit primary weights. |
| 1120 if (elt14 != elt15 || elt14 != elt16 || elt14 != elt17 |
| 1121 || elt14 != elt18 || elt14 != elt19) { |
| 1122 errln("\"cat\" elements don't match: elt14 = 0x%04x, " |
| 1123 "elt15 = 0x%04x, elt16 = 0x%04x, elt17 = 0x%04x, " |
| 1124 "elt18 = 0x%04x, elt19 = 0x%04x", |
| 1125 elt14, elt15, elt16, elt17, elt18, elt19); |
| 1126 } |
| 1127 |
| 1128 // now generate a complete list of the collation elements, |
| 1129 // first using next() and then using setOffset(), and |
| 1130 // make sure both interfaces return the same set of elements |
| 1131 iter->reset(); |
| 1132 |
| 1133 int32_t elt = iter->next(errorCode); |
| 1134 int32_t count = 0; |
| 1135 while (elt != CollationElementIterator::NULLORDER) { |
| 1136 ++count; |
| 1137 elt = iter->next(errorCode); |
| 1138 } |
| 1139 |
| 1140 LocalArray<UnicodeString> nextElements(new UnicodeString[count]); |
| 1141 LocalArray<UnicodeString> setOffsetElements(new UnicodeString[count]); |
| 1142 int32_t lastPos = 0; |
| 1143 |
| 1144 iter->reset(); |
| 1145 elt = iter->next(errorCode); |
| 1146 count = 0; |
| 1147 while (elt != CollationElementIterator::NULLORDER) { |
| 1148 nextElements[count++] = testText.tempSubStringBetween(lastPos, iter->get
Offset()); |
| 1149 lastPos = iter->getOffset(); |
| 1150 elt = iter->next(errorCode); |
| 1151 } |
| 1152 int32_t nextElementsLength = count; |
| 1153 count = 0; |
| 1154 for (int32_t i = 0; i < testText.length(); ) { |
| 1155 iter->setOffset(i, errorCode); |
| 1156 lastPos = iter->getOffset(); |
| 1157 elt = iter->next(errorCode); |
| 1158 setOffsetElements[count++] = testText.tempSubStringBetween(lastPos, iter
->getOffset()); |
| 1159 i = iter->getOffset(); |
| 1160 } |
| 1161 for (int32_t i = 0; i < nextElementsLength; i++) { |
| 1162 if (nextElements[i] == setOffsetElements[i]) { |
| 1163 logln(nextElements[i]); |
| 1164 } else { |
| 1165 errln(UnicodeString("Error: next() yielded ") + nextElements[i] + |
| 1166 ", but setOffset() yielded " + setOffsetElements[i]); |
| 1167 } |
| 1168 } |
| 1169 delete iter; |
| 1170 } |
| 1171 |
1081 // Ticket 7189 | 1172 // Ticket 7189 |
1082 // | 1173 // |
1083 // nextSortKeyPart incorrect for EO_S1 collation | 1174 // nextSortKeyPart incorrect for EO_S1 collation |
1084 static int32_t calcKeyIncremental(UCollator *coll, const UChar* text, int32_t le
n, uint8_t *keyBuf, int32_t /*keyBufLen*/, UErrorCode& status) { | 1175 static int32_t calcKeyIncremental(UCollator *coll, const UChar* text, int32_t le
n, uint8_t *keyBuf, int32_t /*keyBufLen*/, UErrorCode& status) { |
1085 UCharIterator uiter; | 1176 UCharIterator uiter; |
1086 uint32_t state[2] = { 0, 0 }; | 1177 uint32_t state[2] = { 0, 0 }; |
1087 int32_t keyLen; | 1178 int32_t keyLen; |
1088 int32_t count = 8; | 1179 int32_t count = 8; |
1089 | 1180 |
1090 uiter_setString(&uiter, text, len); | 1181 uiter_setString(&uiter, text, len); |
(...skipping 118 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1209 if (U_FAILURE(status)) { | 1300 if (U_FAILURE(status)) { |
1210 errln("Error in caseFirstCompressionSub"); | 1301 errln("Error in caseFirstCompressionSub"); |
1211 } else if (cmpKey != cmpCol) { | 1302 } else if (cmpKey != cmpCol) { |
1212 errln((UnicodeString)"Inconsistent comparison(" + opt | 1303 errln((UnicodeString)"Inconsistent comparison(" + opt |
1213 + "): str1=" + UnicodeString(str1, len) + ", str2=" + UnicodeStr
ing(str2, len) | 1304 + "): str1=" + UnicodeString(str1, len) + ", str2=" + UnicodeStr
ing(str2, len) |
1214 + ", cmpKey=" + cmpKey + ", cmpCol=" + cmpCol); | 1305 + ", cmpKey=" + cmpKey + ", cmpCol=" + cmpCol); |
1215 } | 1306 } |
1216 } | 1307 } |
1217 } | 1308 } |
1218 | 1309 |
| 1310 void CollationRegressionTest::TestTrailingComment() { |
| 1311 // ICU ticket #8070: |
| 1312 // Check that the rule parser handles a comment without terminating end-of-l
ine. |
| 1313 IcuTestErrorCode errorCode(*this, "TestTrailingComment"); |
| 1314 RuleBasedCollator coll(UNICODE_STRING_SIMPLE("&c<b#comment1\n<a#comment2"),
errorCode); |
| 1315 UnicodeString a((UChar)0x61), b((UChar)0x62), c((UChar)0x63); |
| 1316 assertTrue("c<b", coll.compare(c, b) < 0); |
| 1317 assertTrue("b<a", coll.compare(b, a) < 0); |
| 1318 } |
1219 | 1319 |
| 1320 void CollationRegressionTest::TestBeforeWithTooStrongAfter() { |
| 1321 // ICU ticket #9959: |
| 1322 // Forbid rules with a before-reset followed by a stronger relation. |
| 1323 IcuTestErrorCode errorCode(*this, "TestBeforeWithTooStrongAfter"); |
| 1324 RuleBasedCollator before2(UNICODE_STRING_SIMPLE("&[before 2]x<<q<p"), errorC
ode); |
| 1325 if(errorCode.isSuccess()) { |
| 1326 errln("should forbid before-2-reset followed by primary relation"); |
| 1327 } else { |
| 1328 errorCode.reset(); |
| 1329 } |
| 1330 RuleBasedCollator before3(UNICODE_STRING_SIMPLE("&[before 3]x<<<q<<s<p"), er
rorCode); |
| 1331 if(errorCode.isSuccess()) { |
| 1332 errln("should forbid before-3-reset followed by primary or secondary rel
ation"); |
| 1333 } else { |
| 1334 errorCode.reset(); |
| 1335 } |
| 1336 } |
1220 | 1337 |
1221 void CollationRegressionTest::compareArray(Collator &c, | 1338 void CollationRegressionTest::compareArray(Collator &c, |
1222 const UChar tests[][CollationRegressi
onTest::MAX_TOKEN_LEN], | 1339 const UChar tests[][CollationRegressi
onTest::MAX_TOKEN_LEN], |
1223 int32_t testCount) | 1340 int32_t testCount) |
1224 { | 1341 { |
1225 int32_t i; | 1342 int32_t i; |
1226 Collator::EComparisonResult expectedResult = Collator::EQUAL; | 1343 Collator::EComparisonResult expectedResult = Collator::EQUAL; |
1227 | 1344 |
1228 for (i = 0; i < testCount; i += 3) | 1345 for (i = 0; i < testCount; i += 3) |
1229 { | 1346 { |
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1308 while (c1 != CollationElementIterator::NULLORDER); | 1425 while (c1 != CollationElementIterator::NULLORDER); |
1309 } | 1426 } |
1310 | 1427 |
1311 void CollationRegressionTest::runIndexedTest(int32_t index, UBool exec, const ch
ar* &name, char* /* par */) | 1428 void CollationRegressionTest::runIndexedTest(int32_t index, UBool exec, const ch
ar* &name, char* /* par */) |
1312 { | 1429 { |
1313 if (exec) | 1430 if (exec) |
1314 { | 1431 { |
1315 logln("Collation Regression Tests: "); | 1432 logln("Collation Regression Tests: "); |
1316 } | 1433 } |
1317 | 1434 |
1318 if(en_us) { | 1435 if(en_us == NULL) { |
1319 switch (index) | 1436 dataerrln("Class collator not instantiated"); |
1320 { | 1437 name = ""; |
1321 case 0: name = "Test4048446"; if (exec) Test4048446(/* par */); break
; | 1438 return; |
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) TestCaseFirstCom
pression(); break; | |
1354 default: name = ""; break; | |
1355 } | |
1356 } else { | |
1357 dataerrln("Class collator not instantiated"); | |
1358 name = ""; | |
1359 } | 1439 } |
| 1440 TESTCASE_AUTO_BEGIN; |
| 1441 TESTCASE_AUTO(Test4048446); |
| 1442 TESTCASE_AUTO(Test4051866); |
| 1443 TESTCASE_AUTO(Test4053636); |
| 1444 TESTCASE_AUTO(Test4054238); |
| 1445 TESTCASE_AUTO(Test4054734); |
| 1446 TESTCASE_AUTO(Test4054736); |
| 1447 TESTCASE_AUTO(Test4058613); |
| 1448 TESTCASE_AUTO(Test4059820); |
| 1449 TESTCASE_AUTO(Test4060154); |
| 1450 TESTCASE_AUTO(Test4062418); |
| 1451 TESTCASE_AUTO(Test4065540); |
| 1452 TESTCASE_AUTO(Test4066189); |
| 1453 TESTCASE_AUTO(Test4066696); |
| 1454 TESTCASE_AUTO(Test4076676); |
| 1455 TESTCASE_AUTO(Test4078588); |
| 1456 TESTCASE_AUTO(Test4079231); |
| 1457 TESTCASE_AUTO(Test4081866); |
| 1458 TESTCASE_AUTO(Test4087241); |
| 1459 TESTCASE_AUTO(Test4087243); |
| 1460 TESTCASE_AUTO(Test4092260); |
| 1461 TESTCASE_AUTO(Test4095316); |
| 1462 TESTCASE_AUTO(Test4101940); |
| 1463 TESTCASE_AUTO(Test4103436); |
| 1464 TESTCASE_AUTO(Test4114076); |
| 1465 TESTCASE_AUTO(Test4114077); |
| 1466 TESTCASE_AUTO(Test4124632); |
| 1467 TESTCASE_AUTO(Test4132736); |
| 1468 TESTCASE_AUTO(Test4133509); |
| 1469 TESTCASE_AUTO(Test4139572); |
| 1470 TESTCASE_AUTO(Test4141640); |
| 1471 TESTCASE_AUTO(Test4146160); |
| 1472 TESTCASE_AUTO(Test4179216); |
| 1473 TESTCASE_AUTO(TestT7189); |
| 1474 TESTCASE_AUTO(TestCaseFirstCompression); |
| 1475 TESTCASE_AUTO(TestTrailingComment); |
| 1476 TESTCASE_AUTO(TestBeforeWithTooStrongAfter); |
| 1477 TESTCASE_AUTO_END; |
1360 } | 1478 } |
1361 | 1479 |
1362 #endif /* #if !UCONFIG_NO_COLLATION */ | 1480 #endif /* #if !UCONFIG_NO_COLLATION */ |
OLD | NEW |