1 /* 2 ******************************************************************************* 3 * 4 * Copyright (C) 2002-2012, International Business Machines 5 * Corporation and others. All Rights Reserved. 6 * 7 ******************************************************************************* 8 * file name: strcase.cpp 9 * encoding: US-ASCII 10 * tab size: 8 (not used) 11 * indentation:4 12 * 13 * created on: 2002mar12 14 * created by: Markus W. Scherer 15 * 16 * Test file for string casing C++ API functions. 17 */ 18 19 #include "unicode/uchar.h" 20 #include "unicode/ures.h" 21 #include "unicode/uloc.h" 22 #include "unicode/locid.h" 23 #include "unicode/ubrk.h" 24 #include "unicode/unistr.h" 25 #include "unicode/ucasemap.h" 26 #include "ucase.h" 27 #include "ustrtest.h" 28 #include "unicode/tstdtmod.h" 29 30 #define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) 31 32 StringCaseTest::~StringCaseTest() {} 33 34 void 35 StringCaseTest::runIndexedTest(int32_t index, UBool exec, const char *&name, char * /*par*/) { 36 if(exec) { 37 logln("TestSuite StringCaseTest: "); 38 } 39 TESTCASE_AUTO_BEGIN; 40 TESTCASE_AUTO(TestCaseConversion); 41 #if !UCONFIG_NO_BREAK_ITERATION && !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION 42 TESTCASE_AUTO(TestCasing); 43 #endif 44 TESTCASE_AUTO(TestFullCaseFoldingIterator); 45 TESTCASE_AUTO_END; 46 } 47 48 void 49 StringCaseTest::TestCaseConversion() 50 { 51 static const UChar uppercaseGreek[] = 52 { 0x399, 0x395, 0x3a3, 0x3a5, 0x3a3, 0x20, 0x03a7, 0x3a1, 0x399, 0x3a3, 0x3a4, 53 0x39f, 0x3a3, 0 }; 54 // "IESUS CHRISTOS" 55 56 static const UChar lowercaseGreek[] = 57 { 0x3b9, 0x3b5, 0x3c3, 0x3c5, 0x3c2, 0x20, 0x03c7, 0x3c1, 0x3b9, 0x3c3, 0x3c4, 58 0x3bf, 0x3c2, 0 }; 59 // "iesus christos" 60 61 static const UChar lowercaseTurkish[] = 62 { 0x69, 0x73, 0x74, 0x61, 0x6e, 0x62, 0x75, 0x6c, 0x2c, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x63, 0x6f, 63 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x74, 0x0131, 0x6e, 0x6f, 0x70, 0x6c, 0x65, 0x21, 0 }; 64 65 static const UChar uppercaseTurkish[] = 66 { 0x54, 0x4f, 0x50, 0x4b, 0x41, 0x50, 0x49, 0x20, 0x50, 0x41, 0x4c, 0x41, 0x43, 0x45, 0x2c, 0x20, 67 0x0130, 0x53, 0x54, 0x41, 0x4e, 0x42, 0x55, 0x4c, 0 }; 68 69 UnicodeString expectedResult; 70 UnicodeString test3; 71 72 test3 += (UChar32)0x0130; 73 test3 += "STANBUL, NOT CONSTANTINOPLE!"; 74 75 UnicodeString test4(test3); 76 test4.toLower(Locale("")); 77 expectedResult = UnicodeString("i\\u0307stanbul, not constantinople!", "").unescape(); 78 if (test4 != expectedResult) 79 errln("1. toLower failed: expected \"" + expectedResult + "\", got \"" + test4 + "\"."); 80 81 test4 = test3; 82 test4.toLower(Locale("tr", "TR")); 83 expectedResult = lowercaseTurkish; 84 if (test4 != expectedResult) 85 errln("2. toLower failed: expected \"" + expectedResult + "\", got \"" + test4 + "\"."); 86 87 test3 = "topkap"; 88 test3 += (UChar32)0x0131; 89 test3 += " palace, istanbul"; 90 test4 = test3; 91 92 test4.toUpper(Locale("")); 93 expectedResult = "TOPKAPI PALACE, ISTANBUL"; 94 if (test4 != expectedResult) 95 errln("toUpper failed: expected \"" + expectedResult + "\", got \"" + test4 + "\"."); 96 97 test4 = test3; 98 test4.toUpper(Locale("tr", "TR")); 99 expectedResult = uppercaseTurkish; 100 if (test4 != expectedResult) 101 errln("toUpper failed: expected \"" + expectedResult + "\", got \"" + test4 + "\"."); 102 103 test3 = CharsToUnicodeString("S\\u00FC\\u00DFmayrstra\\u00DFe"); 104 105 test3.toUpper(Locale("de", "DE")); 106 expectedResult = CharsToUnicodeString("S\\u00DCSSMAYRSTRASSE"); 107 if (test3 != expectedResult) 108 errln("toUpper failed: expected \"" + expectedResult + "\", got \"" + test3 + "\"."); 109 110 test4.replace(0, test4.length(), uppercaseGreek); 111 112 test4.toLower(Locale("el", "GR")); 113 expectedResult = lowercaseGreek; 114 if (test4 != expectedResult) 115 errln("toLower failed: expected \"" + expectedResult + "\", got \"" + test4 + "\"."); 116 117 test4.replace(0, test4.length(), lowercaseGreek); 118 119 test4.toUpper(); 120 expectedResult = uppercaseGreek; 121 if (test4 != expectedResult) 122 errln("toUpper failed: expected \"" + expectedResult + "\", got \"" + test4 + "\"."); 123 124 // more string case mapping tests with the new implementation 125 { 126 static const UChar 127 128 beforeLower[]= { 0x61, 0x42, 0x49, 0x3a3, 0xdf, 0x3a3, 0x2f, 0xd93f, 0xdfff }, 129 lowerRoot[]= { 0x61, 0x62, 0x69, 0x3c3, 0xdf, 0x3c2, 0x2f, 0xd93f, 0xdfff }, 130 lowerTurkish[]={ 0x61, 0x62, 0x131, 0x3c3, 0xdf, 0x3c2, 0x2f, 0xd93f, 0xdfff }, 131 132 beforeUpper[]= { 0x61, 0x42, 0x69, 0x3c2, 0xdf, 0x3c3, 0x2f, 0xfb03, 0xfb03, 0xfb03, 0xd93f, 0xdfff }, 133 upperRoot[]= { 0x41, 0x42, 0x49, 0x3a3, 0x53, 0x53, 0x3a3, 0x2f, 0x46, 0x46, 0x49, 0x46, 0x46, 0x49, 0x46, 0x46, 0x49, 0xd93f, 0xdfff }, 134 upperTurkish[]={ 0x41, 0x42, 0x130, 0x3a3, 0x53, 0x53, 0x3a3, 0x2f, 0x46, 0x46, 0x49, 0x46, 0x46, 0x49, 0x46, 0x46, 0x49, 0xd93f, 0xdfff }, 135 136 beforeMiniUpper[]= { 0xdf, 0x61 }, 137 miniUpper[]= { 0x53, 0x53, 0x41 }; 138 139 UnicodeString s; 140 141 /* lowercase with root locale */ 142 s=UnicodeString(FALSE, beforeLower, (int32_t)(sizeof(beforeLower)/U_SIZEOF_UCHAR)); 143 s.toLower(""); 144 if( s.length()!=(sizeof(lowerRoot)/U_SIZEOF_UCHAR) || 145 s!=UnicodeString(FALSE, lowerRoot, s.length()) 146 ) { 147 errln("error in toLower(root locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, lowerRoot, (int32_t)(sizeof(lowerRoot)/U_SIZEOF_UCHAR)) + "\""); 148 } 149 150 /* lowercase with turkish locale */ 151 s=UnicodeString(FALSE, beforeLower, (int32_t)(sizeof(beforeLower)/U_SIZEOF_UCHAR)); 152 s.setCharAt(0, beforeLower[0]).toLower(Locale("tr")); 153 if( s.length()!=(sizeof(lowerTurkish)/U_SIZEOF_UCHAR) || 154 s!=UnicodeString(FALSE, lowerTurkish, s.length()) 155 ) { 156 errln("error in toLower(turkish locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, lowerTurkish, (int32_t)(sizeof(lowerTurkish)/U_SIZEOF_UCHAR)) + "\""); 157 } 158 159 /* uppercase with root locale */ 160 s=UnicodeString(FALSE, beforeUpper, (int32_t)(sizeof(beforeUpper)/U_SIZEOF_UCHAR)); 161 s.setCharAt(0, beforeUpper[0]).toUpper(Locale("")); 162 if( s.length()!=(sizeof(upperRoot)/U_SIZEOF_UCHAR) || 163 s!=UnicodeString(FALSE, upperRoot, s.length()) 164 ) { 165 errln("error in toUpper(root locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, upperRoot, (int32_t)(sizeof(upperRoot)/U_SIZEOF_UCHAR)) + "\""); 166 } 167 168 /* uppercase with turkish locale */ 169 s=UnicodeString(FALSE, beforeUpper, (int32_t)(sizeof(beforeUpper)/U_SIZEOF_UCHAR)); 170 s.toUpper(Locale("tr")); 171 if( s.length()!=(sizeof(upperTurkish)/U_SIZEOF_UCHAR) || 172 s!=UnicodeString(FALSE, upperTurkish, s.length()) 173 ) { 174 errln("error in toUpper(turkish locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, upperTurkish, (int32_t)(sizeof(upperTurkish)/U_SIZEOF_UCHAR)) + "\""); 175 } 176 177 /* uppercase a short string with root locale */ 178 s=UnicodeString(FALSE, beforeMiniUpper, (int32_t)(sizeof(beforeMiniUpper)/U_SIZEOF_UCHAR)); 179 s.setCharAt(0, beforeMiniUpper[0]).toUpper(""); 180 if( s.length()!=(sizeof(miniUpper)/U_SIZEOF_UCHAR) || 181 s!=UnicodeString(FALSE, miniUpper, s.length()) 182 ) { 183 errln("error in toUpper(root locale)=\"" + s + "\" expected \"" + UnicodeString(FALSE, miniUpper, (int32_t)(sizeof(miniUpper)/U_SIZEOF_UCHAR)) + "\""); 184 } 185 } 186 187 // test some supplementary characters (>= Unicode 3.1) 188 { 189 UnicodeString t; 190 191 UnicodeString 192 deseretInput=UnicodeString("\\U0001043C\\U00010414", "").unescape(), 193 deseretLower=UnicodeString("\\U0001043C\\U0001043C", "").unescape(), 194 deseretUpper=UnicodeString("\\U00010414\\U00010414", "").unescape(); 195 (t=deseretInput).toLower(); 196 if(t!=deseretLower) { 197 errln("error lowercasing Deseret (plane 1) characters"); 198 } 199 (t=deseretInput).toUpper(); 200 if(t!=deseretUpper) { 201 errln("error uppercasing Deseret (plane 1) characters"); 202 } 203 } 204 205 // test some more cases that looked like problems 206 { 207 UnicodeString t; 208 209 UnicodeString 210 ljInput=UnicodeString("ab'cD \\uFB00i\\u0131I\\u0130 \\u01C7\\u01C8\\u01C9 \\U0001043C\\U00010414", "").unescape(), 211 ljLower=UnicodeString("ab'cd \\uFB00i\\u0131ii\\u0307 \\u01C9\\u01C9\\u01C9 \\U0001043C\\U0001043C", "").unescape(), 212 ljUpper=UnicodeString("AB'CD FFIII\\u0130 \\u01C7\\u01C7\\u01C7 \\U00010414\\U00010414", "").unescape(); 213 (t=ljInput).toLower("en"); 214 if(t!=ljLower) { 215 errln("error lowercasing LJ characters"); 216 } 217 (t=ljInput).toUpper("en"); 218 if(t!=ljUpper) { 219 errln("error uppercasing LJ characters"); 220 } 221 } 222 223 #if !UCONFIG_NO_NORMALIZATION 224 // some context-sensitive casing depends on normalization data being present 225 226 // Unicode 3.1.1 SpecialCasing tests 227 { 228 UnicodeString t; 229 230 // sigmas preceded and/or followed by cased letters 231 UnicodeString 232 sigmas=UnicodeString("i\\u0307\\u03a3\\u0308j \\u0307\\u03a3\\u0308j i\\u00ad\\u03a3\\u0308 \\u0307\\u03a3\\u0308 ", "").unescape(), 233 sigmasLower=UnicodeString("i\\u0307\\u03c3\\u0308j \\u0307\\u03c3\\u0308j i\\u00ad\\u03c2\\u0308 \\u0307\\u03c3\\u0308 ", "").unescape(), 234 sigmasUpper=UnicodeString("I\\u0307\\u03a3\\u0308J \\u0307\\u03a3\\u0308J I\\u00ad\\u03a3\\u0308 \\u0307\\u03a3\\u0308 ", "").unescape(); 235 236 (t=sigmas).toLower(); 237 if(t!=sigmasLower) { 238 errln("error in sigmas.toLower()=\"" + t + "\" expected \"" + sigmasLower + "\""); 239 } 240 241 (t=sigmas).toUpper(Locale("")); 242 if(t!=sigmasUpper) { 243 errln("error in sigmas.toUpper()=\"" + t + "\" expected \"" + sigmasUpper + "\""); 244 } 245 246 // turkish & azerbaijani dotless i & dotted I 247 // remove dot above if there was a capital I before and there are no more accents above 248 UnicodeString 249 dots=UnicodeString("I \\u0130 I\\u0307 I\\u0327\\u0307 I\\u0301\\u0307 I\\u0327\\u0307\\u0301", "").unescape(), 250 dotsTurkish=UnicodeString("\\u0131 i i i\\u0327 \\u0131\\u0301\\u0307 i\\u0327\\u0301", "").unescape(), 251 dotsDefault=UnicodeString("i i\\u0307 i\\u0307 i\\u0327\\u0307 i\\u0301\\u0307 i\\u0327\\u0307\\u0301", "").unescape(); 252 253 (t=dots).toLower("tr"); 254 if(t!=dotsTurkish) { 255 errln("error in dots.toLower(tr)=\"" + t + "\" expected \"" + dotsTurkish + "\""); 256 } 257 258 (t=dots).toLower("de"); 259 if(t!=dotsDefault) { 260 errln("error in dots.toLower(de)=\"" + t + "\" expected \"" + dotsDefault + "\""); 261 } 262 } 263 264 // more Unicode 3.1.1 tests 265 { 266 UnicodeString t; 267 268 // lithuanian dot above in uppercasing 269 UnicodeString 270 dots=UnicodeString("a\\u0307 \\u0307 i\\u0307 j\\u0327\\u0307 j\\u0301\\u0307", "").unescape(), 271 dotsLithuanian=UnicodeString("A\\u0307 \\u0307 I J\\u0327 J\\u0301\\u0307", "").unescape(), 272 dotsDefault=UnicodeString("A\\u0307 \\u0307 I\\u0307 J\\u0327\\u0307 J\\u0301\\u0307", "").unescape(); 273 274 (t=dots).toUpper("lt"); 275 if(t!=dotsLithuanian) { 276 errln("error in dots.toUpper(lt)=\"" + t + "\" expected \"" + dotsLithuanian + "\""); 277 } 278 279 (t=dots).toUpper("de"); 280 if(t!=dotsDefault) { 281 errln("error in dots.toUpper(de)=\"" + t + "\" expected \"" + dotsDefault + "\""); 282 } 283 284 // lithuanian adds dot above to i in lowercasing if there are more above accents 285 UnicodeString 286 i=UnicodeString("I I\\u0301 J J\\u0301 \\u012e \\u012e\\u0301 \\u00cc\\u00cd\\u0128", "").unescape(), 287 iLithuanian=UnicodeString("i i\\u0307\\u0301 j j\\u0307\\u0301 \\u012f \\u012f\\u0307\\u0301 i\\u0307\\u0300i\\u0307\\u0301i\\u0307\\u0303", "").unescape(), 288 iDefault=UnicodeString("i i\\u0301 j j\\u0301 \\u012f \\u012f\\u0301 \\u00ec\\u00ed\\u0129", "").unescape(); 289 290 (t=i).toLower("lt"); 291 if(t!=iLithuanian) { 292 errln("error in i.toLower(lt)=\"" + t + "\" expected \"" + iLithuanian + "\""); 293 } 294 295 (t=i).toLower("de"); 296 if(t!=iDefault) { 297 errln("error in i.toLower(de)=\"" + t + "\" expected \"" + iDefault + "\""); 298 } 299 } 300 301 #endif 302 303 // test case folding 304 { 305 UnicodeString 306 s=UnicodeString("A\\u00df\\u00b5\\ufb03\\U0001040c\\u0130\\u0131", "").unescape(), 307 f=UnicodeString("ass\\u03bcffi\\U00010434i\\u0307\\u0131", "").unescape(), 308 g=UnicodeString("ass\\u03bcffi\\U00010434i\\u0131", "").unescape(), 309 t; 310 311 (t=s).foldCase(); 312 if(f!=t) { 313 errln("error in foldCase(\"" + s + "\", default)=\"" + t + "\" but expected \"" + f + "\""); 314 } 315 316 // alternate handling for dotted I/dotless i (U+0130, U+0131) 317 (t=s).foldCase(U_FOLD_CASE_EXCLUDE_SPECIAL_I); 318 if(g!=t) { 319 errln("error in foldCase(\"" + s + "\", U_FOLD_CASE_EXCLUDE_SPECIAL_I)=\"" + t + "\" but expected \"" + g + "\""); 320 } 321 } 322 } 323 324 // data-driven case mapping tests ------------------------------------------ *** 325 326 enum { 327 TEST_LOWER, 328 TEST_UPPER, 329 TEST_TITLE, 330 TEST_FOLD, 331 TEST_COUNT 332 }; 333 334 // names of TestData children in casing.txt 335 static const char *const dataNames[TEST_COUNT+1]={ 336 "lowercasing", 337 "uppercasing", 338 "titlecasing", 339 "casefolding", 340 "" 341 }; 342 343 void 344 StringCaseTest::TestCasingImpl(const UnicodeString &input, 345 const UnicodeString &output, 346 int32_t whichCase, 347 void *iter, const char *localeID, uint32_t options) { 348 // UnicodeString 349 UnicodeString result; 350 const char *name; 351 Locale locale(localeID); 352 353 result=input; 354 switch(whichCase) { 355 case TEST_LOWER: 356 name="toLower"; 357 result.toLower(locale); 358 break; 359 case TEST_UPPER: 360 name="toUpper"; 361 result.toUpper(locale); 362 break; 363 #if !UCONFIG_NO_BREAK_ITERATION 364 case TEST_TITLE: 365 name="toTitle"; 366 result.toTitle((BreakIterator *)iter, locale, options); 367 break; 368 #endif 369 case TEST_FOLD: 370 name="foldCase"; 371 result.foldCase(options); 372 break; 373 default: 374 name=""; 375 break; // won't happen 376 } 377 if(result!=output) { 378 dataerrln("error: UnicodeString.%s() got a wrong result for a test case from casing.res", name); 379 } 380 #if !UCONFIG_NO_BREAK_ITERATION 381 if(whichCase==TEST_TITLE && options==0) { 382 result=input; 383 result.toTitle((BreakIterator *)iter, locale); 384 if(result!=output) { 385 dataerrln("error: UnicodeString.toTitle(options=0) got a wrong result for a test case from casing.res"); 386 } 387 } 388 #endif 389 390 // UTF-8 391 char utf8In[100], utf8Out[100]; 392 int32_t utf8InLength, utf8OutLength, resultLength; 393 UChar *buffer; 394 395 IcuTestErrorCode errorCode(*this, "TestCasingImpl"); 396 LocalUCaseMapPointer csm(ucasemap_open(localeID, options, errorCode)); 397 #if !UCONFIG_NO_BREAK_ITERATION 398 if(iter!=NULL) { 399 // Clone the break iterator so that the UCaseMap can safely adopt it. 400 int32_t size=1; // Not 0 because that only gives preflighting. 401 UBreakIterator *clone=ubrk_safeClone((UBreakIterator *)iter, NULL, &size, errorCode); 402 ucasemap_setBreakIterator(csm.getAlias(), clone, errorCode); 403 } 404 #endif 405 406 u_strToUTF8(utf8In, (int32_t)sizeof(utf8In), &utf8InLength, input.getBuffer(), input.length(), errorCode); 407 switch(whichCase) { 408 case TEST_LOWER: 409 name="ucasemap_utf8ToLower"; 410 utf8OutLength=ucasemap_utf8ToLower(csm.getAlias(), 411 utf8Out, (int32_t)sizeof(utf8Out), 412 utf8In, utf8InLength, errorCode); 413 break; 414 case TEST_UPPER: 415 name="ucasemap_utf8ToUpper"; 416 utf8OutLength=ucasemap_utf8ToUpper(csm.getAlias(), 417 utf8Out, (int32_t)sizeof(utf8Out), 418 utf8In, utf8InLength, errorCode); 419 break; 420 #if !UCONFIG_NO_BREAK_ITERATION 421 case TEST_TITLE: 422 name="ucasemap_utf8ToTitle"; 423 utf8OutLength=ucasemap_utf8ToTitle(csm.getAlias(), 424 utf8Out, (int32_t)sizeof(utf8Out), 425 utf8In, utf8InLength, errorCode); 426 break; 427 #endif 428 case TEST_FOLD: 429 name="ucasemap_utf8FoldCase"; 430 utf8OutLength=ucasemap_utf8FoldCase(csm.getAlias(), 431 utf8Out, (int32_t)sizeof(utf8Out), 432 utf8In, utf8InLength, errorCode); 433 break; 434 default: 435 name=""; 436 utf8OutLength=0; 437 break; // won't happen 438 } 439 buffer=result.getBuffer(utf8OutLength); 440 u_strFromUTF8(buffer, result.getCapacity(), &resultLength, utf8Out, utf8OutLength, errorCode); 441 result.releaseBuffer(errorCode.isSuccess() ? resultLength : 0); 442 443 if(errorCode.isFailure()) { 444 errcheckln(errorCode, "error: %s() got an error for a test case from casing.res - %s", name, u_errorName(errorCode)); 445 errorCode.reset(); 446 } else if(result!=output) { 447 errln("error: %s() got a wrong result for a test case from casing.res", name); 448 errln("expected \"" + output + "\" got \"" + result + "\"" ); 449 } 450 } 451 452 void 453 StringCaseTest::TestCasing() { 454 UErrorCode status = U_ZERO_ERROR; 455 #if !UCONFIG_NO_BREAK_ITERATION 456 LocalUBreakIteratorPointer iter; 457 #endif 458 char cLocaleID[100]; 459 UnicodeString locale, input, output, optionsString, result; 460 uint32_t options; 461 int32_t whichCase, type; 462 LocalPointer<TestDataModule> driver(TestDataModule::getTestDataModule("casing", *this, status)); 463 if(U_SUCCESS(status)) { 464 for(whichCase=0; whichCase<TEST_COUNT; ++whichCase) { 465 #if UCONFIG_NO_BREAK_ITERATION 466 if(whichCase==TEST_TITLE) { 467 continue; 468 } 469 #endif 470 LocalPointer<TestData> casingTest(driver->createTestData(dataNames[whichCase], status)); 471 if(U_FAILURE(status)) { 472 errln("TestCasing failed to createTestData(%s) - %s", dataNames[whichCase], u_errorName(status)); 473 break; 474 } 475 const DataMap *myCase = NULL; 476 while(casingTest->nextCase(myCase, status)) { 477 input = myCase->getString("Input", status); 478 output = myCase->getString("Output", status); 479 480 if(whichCase!=TEST_FOLD) { 481 locale = myCase->getString("Locale", status); 482 } 483 locale.extract(0, 0x7fffffff, cLocaleID, sizeof(cLocaleID), ""); 484 485 #if !UCONFIG_NO_BREAK_ITERATION 486 if(whichCase==TEST_TITLE) { 487 type = myCase->getInt("Type", status); 488 if(type>=0) { 489 iter.adoptInstead(ubrk_open((UBreakIteratorType)type, cLocaleID, NULL, 0, &status)); 490 } else if(type==-2) { 491 // Open a trivial break iterator that only delivers { 0, length } 492 // or even just { 0 } as boundaries. 493 static const UChar rules[] = { 0x2e, 0x2a, 0x3b }; // ".*;" 494 UParseError parseError; 495 iter.adoptInstead(ubrk_openRules(rules, LENGTHOF(rules), NULL, 0, &parseError, &status)); 496 } 497 } 498 #endif 499 options = 0; 500 if(whichCase==TEST_TITLE || whichCase==TEST_FOLD) { 501 optionsString = myCase->getString("Options", status); 502 if(optionsString.indexOf((UChar)0x54)>=0) { // T 503 options|=U_FOLD_CASE_EXCLUDE_SPECIAL_I; 504 } 505 if(optionsString.indexOf((UChar)0x4c)>=0) { // L 506 options|=U_TITLECASE_NO_LOWERCASE; 507 } 508 if(optionsString.indexOf((UChar)0x41)>=0) { // A 509 options|=U_TITLECASE_NO_BREAK_ADJUSTMENT; 510 } 511 } 512 513 if(U_FAILURE(status)) { 514 dataerrln("error: TestCasing() setup failed for %s test case from casing.res: %s", dataNames[whichCase], u_errorName(status)); 515 status = U_ZERO_ERROR; 516 } else { 517 #if UCONFIG_NO_BREAK_ITERATION 518 LocalPointer<UMemory> iter; 519 #endif 520 TestCasingImpl(input, output, whichCase, iter.getAlias(), cLocaleID, options); 521 } 522 523 #if !UCONFIG_NO_BREAK_ITERATION 524 iter.adoptInstead(NULL); 525 #endif 526 } 527 } 528 } 529 530 #if !UCONFIG_NO_BREAK_ITERATION 531 // more tests for API coverage 532 status=U_ZERO_ERROR; 533 input=UNICODE_STRING_SIMPLE("sTrA\\u00dfE").unescape(); 534 (result=input).toTitle(NULL); 535 if(result!=UNICODE_STRING_SIMPLE("Stra\\u00dfe").unescape()) { 536 dataerrln("UnicodeString::toTitle(NULL) failed."); 537 } 538 #endif 539 } 540 541 void 542 StringCaseTest::TestFullCaseFoldingIterator() { 543 UnicodeString ffi=UNICODE_STRING_SIMPLE("ffi"); 544 UnicodeString ss=UNICODE_STRING_SIMPLE("ss"); 545 FullCaseFoldingIterator iter; 546 int32_t count=0; 547 int32_t countSpecific=0; 548 UChar32 c; 549 UnicodeString full; 550 while((c=iter.next(full))>=0) { 551 ++count; 552 // Check that the full Case_Folding has more than 1 code point. 553 if(!full.hasMoreChar32Than(0, 0x7fffffff, 1)) { 554 errln("error: FullCaseFoldingIterator.next()=U+%04lX full Case_Folding has at most 1 code point", (long)c); 555 continue; 556 } 557 // Check that full == Case_Folding(c). 558 UnicodeString cf(c); 559 cf.foldCase(); 560 if(full!=cf) { 561 errln("error: FullCaseFoldingIterator.next()=U+%04lX full Case_Folding != cf(c)", (long)c); 562 continue; 563 } 564 // Spot-check a couple of specific cases. 565 if((full==ffi && c==0xfb03) || (full==ss && (c==0xdf || c==0x1e9e))) { 566 ++countSpecific; 567 } 568 } 569 if(countSpecific!=3) { 570 errln("error: FullCaseFoldingIterator did not yield exactly the expected specific cases"); 571 } 572 if(count<70) { 573 errln("error: FullCaseFoldingIterator yielded only %d (cp, full) pairs", (int)count); 574 } 575 } 576
