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