Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(10)

Side by Side Diff: source/test/intltest/regcoll.cpp

Issue 845603002: Update ICU to 54.1 step 1 (Closed) Base URL: https://chromium.googlesource.com/chromium/deps/icu.git@master
Patch Set: remove unusued directories Created 5 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « source/test/intltest/regcoll.h ('k') | source/test/intltest/regextst.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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
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
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
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
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
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
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
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
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 */
OLDNEW
« no previous file with comments | « source/test/intltest/regcoll.h ('k') | source/test/intltest/regextst.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698