icuSources/test/intltest/strcase.cpp

   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 }