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