icuSources/test/cintltst/cstrcase.c

   1 /*
   2 *******************************************************************************
   3 *
   4 *   Copyright (C) 2002-2009, International Business Machines
   5 *   Corporation and others.  All Rights Reserved.
   6 *
   7 *******************************************************************************
   8 *   file name:  cstrcase.c
   9 *   encoding:   US-ASCII
  10 *   tab size:   8 (not used)
  11 *   indentation:4
  12 *
  13 *   created on: 2002feb21
  14 *   created by: Markus W. Scherer
  15 *
  16 *   Test file for string casing C API functions.
  17 */
  18
  19 #include <string.h>
  20 #include "unicode/utypes.h"
  21 #include "unicode/uchar.h"
  22 #include "unicode/ustring.h"
  23 #include "unicode/uloc.h"
  24 #include "unicode/ubrk.h"
  25 #include "unicode/ucasemap.h"
  26 #include "cmemory.h"
  27 #include "cintltst.h"
  28
  29 #define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
  30
  31 /* test string case mapping functions --------------------------------------- */
  32
  33 static void
  34 TestCaseLower(void) {
  35     static const UChar
  36
  37     beforeLower[]= { 0x61, 0x42, 0x49,  0x3a3, 0xdf, 0x3a3, 0x2f, 0xd93f, 0xdfff },
  38     lowerRoot[]=   { 0x61, 0x62, 0x69,  0x3c3, 0xdf, 0x3c2, 0x2f, 0xd93f, 0xdfff },
  39     lowerTurkish[]={ 0x61, 0x62, 0x131, 0x3c3, 0xdf, 0x3c2, 0x2f, 0xd93f, 0xdfff };
  40
  41     UChar buffer[32];
  42     int32_t length;
  43     UErrorCode errorCode;
  44
  45     /* lowercase with root locale and separate buffers */
  46     buffer[0]=0xabcd;
  47     errorCode=U_ZERO_ERROR;
  48     length=u_strToLower(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
  49                         beforeLower, sizeof(beforeLower)/U_SIZEOF_UCHAR,
  50                         "",
  51                         &errorCode);
  52     if( U_FAILURE(errorCode) ||
  53         length!=(sizeof(lowerRoot)/U_SIZEOF_UCHAR) ||
  54         uprv_memcmp(lowerRoot, buffer, length*U_SIZEOF_UCHAR)!=0 ||
  55         buffer[length]!=0
  56     ) {
  57         log_err("error in u_strToLower(root locale)=%ld error=%s string matches: %s\t\nlowerRoot=%s\t\nbuffer=%s\n",
  58             length,
  59             u_errorName(errorCode),
  60             uprv_memcmp(lowerRoot, buffer, length*U_SIZEOF_UCHAR)==0 &&
  61 buffer[length]==0 ? "yes" : "no",
  62             aescstrdup(lowerRoot,-1),
  63             aescstrdup(buffer,-1));
  64     }
  65
  66     /* lowercase with turkish locale and in the same buffer */
  67     uprv_memcpy(buffer, beforeLower, sizeof(beforeLower));
  68     buffer[sizeof(beforeLower)/U_SIZEOF_UCHAR]=0;
  69     errorCode=U_ZERO_ERROR;
  70     length=u_strToLower(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
  71                         buffer, -1, /* implicit srcLength */
  72                         "tr",
  73                         &errorCode);
  74     if( U_FAILURE(errorCode) ||
  75         length!=(sizeof(lowerTurkish)/U_SIZEOF_UCHAR) ||
  76         uprv_memcmp(lowerTurkish, buffer, length*U_SIZEOF_UCHAR)!=0 ||
  77         buffer[length]!=0
  78     ) {
  79         log_err("error in u_strToLower(turkish locale)=%ld error=%s string matches: %s\n",
  80             length,
  81             u_errorName(errorCode),
  82             uprv_memcmp(lowerTurkish, buffer, length*U_SIZEOF_UCHAR)==0 && buffer[length]==0 ? "yes" : "no");
  83     }
  84
  85     /* test preflighting */
  86     buffer[0]=buffer[2]=0xabcd;
  87     errorCode=U_ZERO_ERROR;
  88     length=u_strToLower(buffer, 2, /* set destCapacity=2 */
  89                         beforeLower, sizeof(beforeLower)/U_SIZEOF_UCHAR,
  90                         "",
  91                         &errorCode);
  92     if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
  93         length!=(sizeof(lowerRoot)/U_SIZEOF_UCHAR) ||
  94         uprv_memcmp(lowerRoot, buffer, 2*U_SIZEOF_UCHAR)!=0 ||
  95         buffer[2]!=0xabcd
  96     ) {
  97         log_err("error in u_strToLower(root locale preflighting)=%ld error=%s string matches: %s\n",
  98             length,
  99             u_errorName(errorCode),
 100             uprv_memcmp(lowerRoot, buffer, 2*U_SIZEOF_UCHAR)==0 && buffer[2]==0xabcd ? "yes" : "no");
 101     }
 102
 103     /* test error handling */
 104     errorCode=U_ZERO_ERROR;
 105     length=u_strToLower(NULL, sizeof(buffer)/U_SIZEOF_UCHAR,
 106                         beforeLower, sizeof(beforeLower)/U_SIZEOF_UCHAR,
 107                         "",
 108                         &errorCode);
 109     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
 110         log_err("error in u_strToLower(root locale dest=NULL)=%ld error=%s\n",
 111             length,
 112             u_errorName(errorCode));
 113     }
 114
 115     buffer[0]=0xabcd;
 116     errorCode=U_ZERO_ERROR;
 117     length=u_strToLower(buffer, -1,
 118                         beforeLower, sizeof(beforeLower)/U_SIZEOF_UCHAR,
 119                         "",
 120                         &errorCode);
 121     if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
 122         buffer[0]!=0xabcd
 123     ) {
 124         log_err("error in u_strToLower(root locale destCapacity=-1)=%ld error=%s buffer[0]==0x%lx\n",
 125             length,
 126             u_errorName(errorCode),
 127             buffer[0]);
 128     }
 129 }
 130
 131 static void
 132 TestCaseUpper(void) {
 133     static const UChar
 134
 135     beforeUpper[]= { 0x61, 0x42, 0x69,  0x3c2, 0xdf,       0x3c3, 0x2f, 0xfb03,           0xd93f, 0xdfff },
 136     upperRoot[]=   { 0x41, 0x42, 0x49,  0x3a3, 0x53, 0x53, 0x3a3, 0x2f, 0x46, 0x46, 0x49, 0xd93f, 0xdfff },
 137     upperTurkish[]={ 0x41, 0x42, 0x130, 0x3a3, 0x53, 0x53, 0x3a3, 0x2f, 0x46, 0x46, 0x49, 0xd93f, 0xdfff };
 138
 139     UChar buffer[32];
 140     int32_t length;
 141     UErrorCode errorCode;
 142
 143     /* uppercase with root locale and in the same buffer */
 144     uprv_memcpy(buffer, beforeUpper, sizeof(beforeUpper));
 145     errorCode=U_ZERO_ERROR;
 146     length=u_strToUpper(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
 147                         buffer, sizeof(beforeUpper)/U_SIZEOF_UCHAR,
 148                         "",
 149                         &errorCode);
 150     if( U_FAILURE(errorCode) ||
 151         length!=(sizeof(upperRoot)/U_SIZEOF_UCHAR) ||
 152         uprv_memcmp(upperRoot, buffer, length*U_SIZEOF_UCHAR)!=0 ||
 153         buffer[length]!=0
 154     ) {
 155         log_err("error in u_strToUpper(root locale)=%ld error=%s string matches: %s\n",
 156             length,
 157             u_errorName(errorCode),
 158             uprv_memcmp(upperRoot, buffer, length*U_SIZEOF_UCHAR)==0 && buffer[length]==0 ? "yes" : "no");
 159     }
 160
 161     /* uppercase with turkish locale and separate buffers */
 162     buffer[0]=0xabcd;
 163     errorCode=U_ZERO_ERROR;
 164     length=u_strToUpper(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
 165                         beforeUpper, sizeof(beforeUpper)/U_SIZEOF_UCHAR,
 166                         "tr",
 167                         &errorCode);
 168     if( U_FAILURE(errorCode) ||
 169         length!=(sizeof(upperTurkish)/U_SIZEOF_UCHAR) ||
 170         uprv_memcmp(upperTurkish, buffer, length*U_SIZEOF_UCHAR)!=0 ||
 171         buffer[length]!=0
 172     ) {
 173         log_err("error in u_strToUpper(turkish locale)=%ld error=%s string matches: %s\n",
 174             length,
 175             u_errorName(errorCode),
 176             uprv_memcmp(upperTurkish, buffer, length*U_SIZEOF_UCHAR)==0 && buffer[length]==0 ? "yes" : "no");
 177     }
 178
 179     /* test preflighting */
 180     errorCode=U_ZERO_ERROR;
 181     length=u_strToUpper(NULL, 0,
 182                         beforeUpper, sizeof(beforeUpper)/U_SIZEOF_UCHAR,
 183                         "tr",
 184                         &errorCode);
 185     if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
 186         length!=(sizeof(upperTurkish)/U_SIZEOF_UCHAR)
 187     ) {
 188         log_err("error in u_strToUpper(turkish locale pure preflighting)=%ld error=%s\n",
 189             length,
 190             u_errorName(errorCode));
 191     }
 192
 193     /* test error handling */
 194     buffer[0]=0xabcd;
 195     errorCode=U_ZERO_ERROR;
 196     length=u_strToUpper(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
 197                         NULL, sizeof(beforeUpper)/U_SIZEOF_UCHAR,
 198                         "tr",
 199                         &errorCode);
 200     if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
 201         buffer[0]!=0xabcd
 202     ) {
 203         log_err("error in u_strToUpper(turkish locale src=NULL)=%ld error=%s buffer[0]==0x%lx\n",
 204             length,
 205             u_errorName(errorCode),
 206             buffer[0]);
 207     }
 208
 209     buffer[0]=0xabcd;
 210     errorCode=U_ZERO_ERROR;
 211     length=u_strToUpper(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
 212                         beforeUpper, -2,
 213                         "tr",
 214                         &errorCode);
 215     if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
 216         buffer[0]!=0xabcd
 217     ) {
 218         log_err("error in u_strToUpper(turkish locale srcLength=-2)=%ld error=%s buffer[0]==0x%lx\n",
 219             length,
 220             u_errorName(errorCode),
 221             buffer[0]);
 222     }
 223 }
 224
 225 #if !UCONFIG_NO_BREAK_ITERATION
 226
 227 static void
 228 TestCaseTitle(void) {
 229     static const UChar
 230
 231     beforeTitle[]= { 0x61, 0x42, 0x20, 0x69,  0x3c2, 0x20, 0xdf,       0x3c3, 0x2f, 0xfb03,           0xd93f, 0xdfff },
 232     titleWord[]=   { 0x41, 0x62, 0x20, 0x49,  0x3c2, 0x20, 0x53, 0x73, 0x3c3, 0x2f, 0x46, 0x66, 0x69, 0xd93f, 0xdfff },
 233     titleChar[]=   { 0x41, 0x42, 0x20, 0x49,  0x3a3, 0x20, 0x53, 0x73, 0x3a3, 0x2f, 0x46, 0x66, 0x69, 0xd93f, 0xdfff };
 234
 235     UChar buffer[32];
 236     UBreakIterator *titleIterChars;
 237     int32_t length;
 238     UErrorCode errorCode;
 239
 240     errorCode=U_ZERO_ERROR;
 241     titleIterChars=ubrk_open(UBRK_CHARACTER, "", beforeTitle, sizeof(beforeTitle)/U_SIZEOF_UCHAR, &errorCode);
 242     if(U_FAILURE(errorCode)) {
 243         log_err_status(errorCode, "error: ubrk_open(UBRK_CHARACTER)->%s\n", u_errorName(errorCode));
 244         return;
 245     }
 246
 247     /* titlecase with standard break iterator and in the same buffer */
 248     uprv_memcpy(buffer, beforeTitle, sizeof(beforeTitle));
 249     errorCode=U_ZERO_ERROR;
 250     length=u_strToTitle(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
 251                         buffer, sizeof(beforeTitle)/U_SIZEOF_UCHAR,
 252                         NULL, "",
 253                         &errorCode);
 254     if( U_FAILURE(errorCode) ||
 255         length!=(sizeof(titleWord)/U_SIZEOF_UCHAR) ||
 256         uprv_memcmp(titleWord, buffer, length*U_SIZEOF_UCHAR)!=0 ||
 257         buffer[length]!=0
 258     ) {
 259         log_err("error in u_strToTitle(standard iterator)=%ld error=%s string matches: %s\n",
 260             length,
 261             u_errorName(errorCode),
 262             uprv_memcmp(titleWord, buffer, length*U_SIZEOF_UCHAR)==0 && buffer[length]==0 ? "yes" : "no");
 263     }
 264
 265     /* titlecase with UBRK_CHARACTERS and separate buffers */
 266     buffer[0]=0xabcd;
 267     errorCode=U_ZERO_ERROR;
 268     length=u_strToTitle(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
 269                         beforeTitle, sizeof(beforeTitle)/U_SIZEOF_UCHAR,
 270                         titleIterChars, "",
 271                         &errorCode);
 272     if( U_FAILURE(errorCode) ||
 273         length!=(sizeof(titleChar)/U_SIZEOF_UCHAR) ||
 274         uprv_memcmp(titleChar, buffer, length*U_SIZEOF_UCHAR)!=0 ||
 275         buffer[length]!=0
 276     ) {
 277         log_err("error in u_strToTitle(UBRK_CHARACTERS)=%ld error=%s string matches: %s\n",
 278             length,
 279             u_errorName(errorCode),
 280             uprv_memcmp(titleChar, buffer, length*U_SIZEOF_UCHAR)==0 && buffer[length]==0 ? "yes" : "no");
 281     }
 282
 283     /* test preflighting */
 284     errorCode=U_ZERO_ERROR;
 285     length=u_strToTitle(NULL, 0,
 286                         beforeTitle, sizeof(beforeTitle)/U_SIZEOF_UCHAR,
 287                         titleIterChars, "",
 288                         &errorCode);
 289     if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
 290         length!=(sizeof(titleChar)/U_SIZEOF_UCHAR)
 291     ) {
 292         log_err("error in u_strToTitle(UBRK_CHARACTERS pure preflighting)=%ld error=%s\n",
 293             length,
 294             u_errorName(errorCode));
 295     }
 296
 297     /* test error handling */
 298     buffer[0]=0xabcd;
 299     errorCode=U_ZERO_ERROR;
 300     length=u_strToTitle(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
 301                         NULL, sizeof(beforeTitle)/U_SIZEOF_UCHAR,
 302                         titleIterChars, "",
 303                         &errorCode);
 304     if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
 305         buffer[0]!=0xabcd
 306     ) {
 307         log_err("error in u_strToTitle(UBRK_CHARACTERS src=NULL)=%ld error=%s buffer[0]==0x%lx\n",
 308             length,
 309             u_errorName(errorCode),
 310             buffer[0]);
 311     }
 312
 313     buffer[0]=0xabcd;
 314     errorCode=U_ZERO_ERROR;
 315     length=u_strToTitle(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
 316                         beforeTitle, -2,
 317                         titleIterChars, "",
 318                         &errorCode);
 319     if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
 320         buffer[0]!=0xabcd
 321     ) {
 322         log_err("error in u_strToTitle(UBRK_CHARACTERS srcLength=-2)=%ld error=%s buffer[0]==0x%lx\n",
 323             length,
 324             u_errorName(errorCode),
 325             buffer[0]);
 326     }
 327
 328     ubrk_close(titleIterChars);
 329 }
 330
 331 static void
 332 TestCaseDutchTitle(void) {
 333     static const UChar
 334
 335     beforeTitle[]= { 0x69, 0x6A, 0x73, 0x73,  0x45, 0x6c, 0x20, 0x69, 0x67, 0x6c, 0x4f, 0x6f , 0x20 , 0x49, 0x4A, 0x53, 0x53, 0x45, 0x4C },
 336     titleRoot[]=   { 0x49, 0x6A, 0x73, 0x73,  0x65, 0x6c, 0x20, 0x49, 0x67, 0x6c, 0x6f, 0x6f , 0x20 , 0x49, 0x6A, 0x73, 0x73, 0x65, 0x6C },
 337     titleDutch[]=  { 0x49, 0x4A, 0x73, 0x73,  0x65, 0x6c, 0x20, 0x49, 0x67, 0x6c, 0x6f, 0x6f , 0x20 , 0x49, 0x4A, 0x73, 0x73, 0x65, 0x6C };
 338
 339     UChar buffer[32];
 340     UBreakIterator *titleIterWord;
 341     int32_t length;
 342     UErrorCode errorCode;
 343
 344     errorCode=U_ZERO_ERROR;
 345     titleIterWord=ubrk_open(UBRK_WORD, "", beforeTitle, sizeof(beforeTitle)/U_SIZEOF_UCHAR, &errorCode);
 346     if(U_FAILURE(errorCode)) {
 347         log_err_status(errorCode, "error: ubrk_open(UBRK_WORD)->%s\n", u_errorName(errorCode));
 348         return;
 349     }
 350
 351     /* titlecase with default locale */
 352     buffer[0]=0xabcd;
 353     errorCode=U_ZERO_ERROR;
 354     length=u_strToTitle(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
 355                         beforeTitle, sizeof(beforeTitle)/U_SIZEOF_UCHAR,
 356                         titleIterWord, "",
 357                         &errorCode);
 358     if( U_FAILURE(errorCode) ||
 359         length!=(sizeof(titleRoot)/U_SIZEOF_UCHAR) ||
 360         uprv_memcmp(titleRoot, buffer, length*U_SIZEOF_UCHAR)!=0 ||
 361         buffer[length]!=0
 362     ) {
 363         char charsOut[21];
 364         u_UCharsToChars(buffer,charsOut,sizeof(charsOut));
 365         log_err("error in u_strToTitle(UBRK_CHARACTERS)=%ld error=%s root locale string matches: %s\noutput buffer is {%s}\n",
 366             length,
 367             u_errorName(errorCode),
 368             uprv_memcmp(titleRoot, buffer, length*U_SIZEOF_UCHAR)==0 && buffer[length]==0 ? "yes" : "no", charsOut);
 369     }
 370     /* titlecase with Dutch locale */
 371     buffer[0]=0xabcd;
 372     errorCode=U_ZERO_ERROR;
 373     length=u_strToTitle(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
 374                         beforeTitle, sizeof(beforeTitle)/U_SIZEOF_UCHAR,
 375                         titleIterWord, "nl",
 376                         &errorCode);
 377     if( U_FAILURE(errorCode) ||
 378         length!=(sizeof(titleDutch)/U_SIZEOF_UCHAR) ||
 379         uprv_memcmp(titleDutch, buffer, length*U_SIZEOF_UCHAR)!=0 ||
 380         buffer[length]!=0
 381     ) {
 382         char charsOut[21];
 383         u_UCharsToChars(buffer,charsOut,sizeof(charsOut));
 384         log_err("error in u_strToTitle(UBRK_CHARACTERS)=%ld error=%s dutch locale string matches: %s\noutput buffer is {%s}\n",
 385             length,
 386             u_errorName(errorCode),
 387             uprv_memcmp(titleDutch, buffer, length*U_SIZEOF_UCHAR)==0 && buffer[length]==0 ? "yes" : "no", charsOut);
 388     }
 389
 390     ubrk_close(titleIterWord);
 391 }
 392
 393 #endif
 394
 395 /* test case folding and case-insensitive string compare -------------------- */
 396
 397 static void
 398 TestCaseFolding(void) {
 399     /*
 400      * CaseFolding.txt says about i and its cousins:
 401      *   0049; C; 0069; # LATIN CAPITAL LETTER I
 402      *   0049; T; 0131; # LATIN CAPITAL LETTER I
 403      *
 404      *   0130; F; 0069 0307; # LATIN CAPITAL LETTER I WITH DOT ABOVE
 405      *   0130; T; 0069; # LATIN CAPITAL LETTER I WITH DOT ABOVE
 406      * That's all.
 407      * See CaseFolding.txt and the Unicode Standard for how to apply the case foldings.
 408      */
 409     static const UChar32
 410     simple[]={
 411         /* input, default, exclude special i */
 412         0x61,   0x61,  0x61,
 413         0x49,   0x69,  0x131,
 414         0x130,  0x130, 0x69,
 415         0x131,  0x131, 0x131,
 416         0xdf,   0xdf,  0xdf,
 417         0xfb03, 0xfb03, 0xfb03,
 418         0x1040e,0x10436,0x10436,
 419         0x5ffff,0x5ffff,0x5ffff
 420     };
 421
 422     static const UChar
 423     mixed[]=                { 0x61, 0x42, 0x130,       0x49,  0x131, 0x3d0, 0xdf,       0xfb03,           0xd93f, 0xdfff },
 424     foldedDefault[]=        { 0x61, 0x62, 0x69, 0x307, 0x69,  0x131, 0x3b2, 0x73, 0x73, 0x66, 0x66, 0x69, 0xd93f, 0xdfff },
 425     foldedExcludeSpecialI[]={ 0x61, 0x62, 0x69,        0x131, 0x131, 0x3b2, 0x73, 0x73, 0x66, 0x66, 0x69, 0xd93f, 0xdfff };
 426
 427     UVersionInfo unicodeVersion={ 0, 0, 17, 89 }, unicode_3_1={ 3, 1, 0, 0 };
 428
 429     const UChar32 *p;
 430     int32_t i;
 431
 432     UChar buffer[32];
 433     int32_t length;
 434     UErrorCode errorCode;
 435     UBool isUnicode_3_1;
 436
 437     /* if unicodeVersion()>=3.1 then test exclude-special-i cases as well */
 438     u_getUnicodeVersion(unicodeVersion);
 439     isUnicode_3_1= uprv_memcmp(unicodeVersion, unicode_3_1, 4)>=0;
 440
 441     /* test simple case folding */
 442     p=simple;
 443     for(i=0; i<sizeof(simple)/12; p+=3, ++i) {
 444         if(u_foldCase(p[0], U_FOLD_CASE_DEFAULT)!=p[1]) {
 445             log_err("error: u_foldCase(0x%04lx, default)=0x%04lx instead of 0x%04lx\n",
 446                     p[0], u_foldCase(p[0], U_FOLD_CASE_DEFAULT), p[1]);
 447             return;
 448         }
 449
 450         if(isUnicode_3_1 && u_foldCase(p[0], U_FOLD_CASE_EXCLUDE_SPECIAL_I)!=p[2]) {
 451             log_err("error: u_foldCase(0x%04lx, exclude special i)=0x%04lx instead of 0x%04lx\n",
 452                     p[0], u_foldCase(p[0], U_FOLD_CASE_EXCLUDE_SPECIAL_I), p[2]);
 453             return;
 454         }
 455     }
 456
 457     /* test full string case folding with default option and separate buffers */
 458     buffer[0]=0xabcd;
 459     errorCode=U_ZERO_ERROR;
 460     length=u_strFoldCase(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
 461                         mixed, sizeof(mixed)/U_SIZEOF_UCHAR,
 462                         U_FOLD_CASE_DEFAULT,
 463                         &errorCode);
 464     if( U_FAILURE(errorCode) ||
 465         length!=(sizeof(foldedDefault)/U_SIZEOF_UCHAR) ||
 466         uprv_memcmp(foldedDefault, buffer, length*U_SIZEOF_UCHAR)!=0 ||
 467         buffer[length]!=0
 468     ) {
 469         log_err("error in u_strFoldCase(default)=%ld error=%s string matches: %s\n",
 470             length,
 471             u_errorName(errorCode),
 472             uprv_memcmp(foldedDefault, buffer, length*U_SIZEOF_UCHAR)==0 && buffer[length]==0 ? "yes" : "no");
 473     }
 474
 475     /* exclude special i */
 476     if(isUnicode_3_1) {
 477         buffer[0]=0xabcd;
 478         errorCode=U_ZERO_ERROR;
 479         length=u_strFoldCase(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
 480                             mixed, sizeof(mixed)/U_SIZEOF_UCHAR,
 481                             U_FOLD_CASE_EXCLUDE_SPECIAL_I,
 482                             &errorCode);
 483         if( U_FAILURE(errorCode) ||
 484             length!=(sizeof(foldedExcludeSpecialI)/U_SIZEOF_UCHAR) ||
 485             uprv_memcmp(foldedExcludeSpecialI, buffer, length*U_SIZEOF_UCHAR)!=0 ||
 486             buffer[length]!=0
 487         ) {
 488             log_err("error in u_strFoldCase(exclude special i)=%ld error=%s string matches: %s\n",
 489                 length,
 490                 u_errorName(errorCode),
 491                 uprv_memcmp(foldedExcludeSpecialI, buffer, length*U_SIZEOF_UCHAR)==0 && buffer[length]==0 ? "yes" : "no");
 492         }
 493     }
 494
 495     /* test full string case folding with default option and in the same buffer */
 496     uprv_memcpy(buffer, mixed, sizeof(mixed));
 497     buffer[sizeof(mixed)/U_SIZEOF_UCHAR]=0;
 498     errorCode=U_ZERO_ERROR;
 499     length=u_strFoldCase(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
 500                         buffer, -1, /* implicit srcLength */
 501                         U_FOLD_CASE_DEFAULT,
 502                         &errorCode);
 503     if( U_FAILURE(errorCode) ||
 504         length!=(sizeof(foldedDefault)/U_SIZEOF_UCHAR) ||
 505         uprv_memcmp(foldedDefault, buffer, length*U_SIZEOF_UCHAR)!=0 ||
 506         buffer[length]!=0
 507     ) {
 508         log_err("error in u_strFoldCase(default same buffer)=%ld error=%s string matches: %s\n",
 509             length,
 510             u_errorName(errorCode),
 511             uprv_memcmp(foldedDefault, buffer, length*U_SIZEOF_UCHAR)==0 && buffer[length]==0 ? "yes" : "no");
 512     }
 513
 514     /* test full string case folding, exclude special i, in the same buffer */
 515     if(isUnicode_3_1) {
 516         uprv_memcpy(buffer, mixed, sizeof(mixed));
 517         errorCode=U_ZERO_ERROR;
 518         length=u_strFoldCase(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
 519                             buffer, sizeof(mixed)/U_SIZEOF_UCHAR,
 520                             U_FOLD_CASE_EXCLUDE_SPECIAL_I,
 521                             &errorCode);
 522         if( U_FAILURE(errorCode) ||
 523             length!=(sizeof(foldedExcludeSpecialI)/U_SIZEOF_UCHAR) ||
 524             uprv_memcmp(foldedExcludeSpecialI, buffer, length*U_SIZEOF_UCHAR)!=0 ||
 525             buffer[length]!=0
 526         ) {
 527             log_err("error in u_strFoldCase(exclude special i same buffer)=%ld error=%s string matches: %s\n",
 528                 length,
 529                 u_errorName(errorCode),
 530                 uprv_memcmp(foldedExcludeSpecialI, buffer, length*U_SIZEOF_UCHAR)==0 && buffer[length]==0 ? "yes" : "no");
 531         }
 532     }
 533
 534     /* test preflighting */
 535     buffer[0]=buffer[2]=0xabcd;
 536     errorCode=U_ZERO_ERROR;
 537     length=u_strFoldCase(buffer, 2, /* set destCapacity=2 */
 538                         mixed, sizeof(mixed)/U_SIZEOF_UCHAR,
 539                         U_FOLD_CASE_DEFAULT,
 540                         &errorCode);
 541     if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
 542         length!=(sizeof(foldedDefault)/U_SIZEOF_UCHAR) ||
 543         uprv_memcmp(foldedDefault, buffer, 2*U_SIZEOF_UCHAR)!=0 ||
 544         buffer[2]!=0xabcd
 545     ) {
 546         log_err("error in u_strFoldCase(default preflighting)=%ld error=%s string matches: %s\n",
 547             length,
 548             u_errorName(errorCode),
 549             uprv_memcmp(foldedDefault, buffer, 2*U_SIZEOF_UCHAR)==0 && buffer[2]==0xabcd ? "yes" : "no");
 550     }
 551
 552     errorCode=U_ZERO_ERROR;
 553     length=u_strFoldCase(NULL, 0,
 554                         mixed, sizeof(mixed)/U_SIZEOF_UCHAR,
 555                         U_FOLD_CASE_DEFAULT,
 556                         &errorCode);
 557     if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
 558         length!=(sizeof(foldedDefault)/U_SIZEOF_UCHAR)
 559     ) {
 560         log_err("error in u_strFoldCase(default pure preflighting)=%ld error=%s\n",
 561             length,
 562             u_errorName(errorCode));
 563     }
 564
 565     /* test error handling */
 566     errorCode=U_ZERO_ERROR;
 567     length=u_strFoldCase(NULL, sizeof(buffer)/U_SIZEOF_UCHAR,
 568                         mixed, sizeof(mixed)/U_SIZEOF_UCHAR,
 569                         U_FOLD_CASE_DEFAULT,
 570                         &errorCode);
 571     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
 572         log_err("error in u_strFoldCase(default dest=NULL)=%ld error=%s\n",
 573             length,
 574             u_errorName(errorCode));
 575     }
 576
 577     buffer[0]=0xabcd;
 578     errorCode=U_ZERO_ERROR;
 579     length=u_strFoldCase(buffer, -1,
 580                         mixed, sizeof(mixed)/U_SIZEOF_UCHAR,
 581                         U_FOLD_CASE_DEFAULT,
 582                         &errorCode);
 583     if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
 584         buffer[0]!=0xabcd
 585     ) {
 586         log_err("error in u_strFoldCase(default destCapacity=-1)=%ld error=%s buffer[0]==0x%lx\n",
 587             length,
 588             u_errorName(errorCode),
 589             buffer[0]);
 590     }
 591
 592     buffer[0]=0xabcd;
 593     errorCode=U_ZERO_ERROR;
 594     length=u_strFoldCase(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
 595                         NULL, sizeof(mixed)/U_SIZEOF_UCHAR,
 596                         U_FOLD_CASE_EXCLUDE_SPECIAL_I,
 597                         &errorCode);
 598     if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
 599         buffer[0]!=0xabcd
 600     ) {
 601         log_err("error in u_strFoldCase(exclude special i src=NULL)=%ld error=%s buffer[0]==0x%lx\n",
 602             length,
 603             u_errorName(errorCode),
 604             buffer[0]);
 605     }
 606
 607     buffer[0]=0xabcd;
 608     errorCode=U_ZERO_ERROR;
 609     length=u_strFoldCase(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
 610                         mixed, -2,
 611                         U_FOLD_CASE_EXCLUDE_SPECIAL_I,
 612                         &errorCode);
 613     if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
 614         buffer[0]!=0xabcd
 615     ) {
 616         log_err("error in u_strFoldCase(exclude special i srcLength=-2)=%ld error=%s buffer[0]==0x%lx\n",
 617             length,
 618             u_errorName(errorCode),
 619             buffer[0]);
 620     }
 621 }
 622
 623 static void
 624 TestCaseCompare(void) {
 625     static const UChar
 626
 627     mixed[]=               { 0x61, 0x42, 0x131, 0x3a3, 0xdf,       0xfb03,           0xd93f, 0xdfff, 0 },
 628     otherDefault[]=        { 0x41, 0x62, 0x131, 0x3c3, 0x73, 0x53, 0x46, 0x66, 0x49, 0xd93f, 0xdfff, 0 },
 629     otherExcludeSpecialI[]={ 0x41, 0x62, 0x131, 0x3c3, 0x53, 0x73, 0x66, 0x46, 0x69, 0xd93f, 0xdfff, 0 },
 630     different[]=           { 0x41, 0x62, 0x131, 0x3c3, 0x73, 0x53, 0x46, 0x66, 0x49, 0xd93f, 0xdffd, 0 };
 631
 632     UVersionInfo unicodeVersion={ 0, 0, 17, 89 }, unicode_3_1={ 3, 1, 0, 0 };
 633
 634     int32_t result, lenMixed, lenOtherDefault, lenOtherExcludeSpecialI, lenDifferent;
 635     UErrorCode errorCode;
 636     UBool isUnicode_3_1;
 637
 638     errorCode=U_ZERO_ERROR;
 639
 640     lenMixed=u_strlen(mixed);
 641     lenOtherDefault=u_strlen(otherDefault);
 642     lenOtherExcludeSpecialI=u_strlen(otherExcludeSpecialI);
 643     lenDifferent=u_strlen(different);
 644
 645     /* if unicodeVersion()>=3.1 then test exclude-special-i cases as well */
 646     u_getUnicodeVersion(unicodeVersion);
 647     isUnicode_3_1= uprv_memcmp(unicodeVersion, unicode_3_1, 4)>=0;
 648
 649     /* test u_strcasecmp() */
 650     result=u_strcasecmp(mixed, otherDefault, U_FOLD_CASE_DEFAULT);
 651     if(result!=0) {
 652         log_err("error: u_strcasecmp(mixed, other, default)=%ld instead of 0\n", result);
 653     }
 654     result=u_strCaseCompare(mixed, -1, otherDefault, -1, U_FOLD_CASE_DEFAULT, &errorCode);
 655     if(result!=0) {
 656         log_err("error: u_strCaseCompare(mixed, other, default)=%ld instead of 0\n", result);
 657     }
 658
 659     /* test u_strcasecmp() - exclude special i */
 660     result=u_strcasecmp(mixed, otherExcludeSpecialI, U_FOLD_CASE_EXCLUDE_SPECIAL_I);
 661     if(result!=0) {
 662         log_err("error: u_strcasecmp(mixed, other, exclude special i)=%ld instead of 0\n", result);
 663     }
 664     result=u_strCaseCompare(mixed, lenMixed, otherExcludeSpecialI, lenOtherExcludeSpecialI, U_FOLD_CASE_EXCLUDE_SPECIAL_I, &errorCode);
 665     if(result!=0) {
 666         log_err("error: u_strCaseCompare(mixed, other, exclude special i)=%ld instead of 0\n", result);
 667     }
 668
 669     /* test u_strcasecmp() */
 670     result=u_strcasecmp(mixed, different, U_FOLD_CASE_DEFAULT);
 671     if(result<=0) {
 672         log_err("error: u_strcasecmp(mixed, different, default)=%ld instead of positive\n", result);
 673     }
 674     result=u_strCaseCompare(mixed, -1, different, lenDifferent, U_FOLD_CASE_DEFAULT, &errorCode);
 675     if(result<=0) {
 676         log_err("error: u_strCaseCompare(mixed, different, default)=%ld instead of positive\n", result);
 677     }
 678
 679     /* test u_strncasecmp() - stop before the sharp s (U+00df) */
 680     result=u_strncasecmp(mixed, different, 4, U_FOLD_CASE_DEFAULT);
 681     if(result!=0) {
 682         log_err("error: u_strncasecmp(mixed, different, 4, default)=%ld instead of 0\n", result);
 683     }
 684     result=u_strCaseCompare(mixed, 4, different, 4, U_FOLD_CASE_DEFAULT, &errorCode);
 685     if(result!=0) {
 686         log_err("error: u_strCaseCompare(mixed, 4, different, 4, default)=%ld instead of 0\n", result);
 687     }
 688
 689     /* test u_strncasecmp() - stop in the middle of the sharp s (U+00df) */
 690     result=u_strncasecmp(mixed, different, 5, U_FOLD_CASE_DEFAULT);
 691     if(result<=0) {
 692         log_err("error: u_strncasecmp(mixed, different, 5, default)=%ld instead of positive\n", result);
 693     }
 694     result=u_strCaseCompare(mixed, 5, different, 5, U_FOLD_CASE_DEFAULT, &errorCode);
 695     if(result<=0) {
 696         log_err("error: u_strCaseCompare(mixed, 5, different, 5, default)=%ld instead of positive\n", result);
 697     }
 698
 699     /* test u_memcasecmp() - stop before the sharp s (U+00df) */
 700     result=u_memcasecmp(mixed, different, 4, U_FOLD_CASE_DEFAULT);
 701     if(result!=0) {
 702         log_err("error: u_memcasecmp(mixed, different, 4, default)=%ld instead of 0\n", result);
 703     }
 704
 705     /* test u_memcasecmp() - stop in the middle of the sharp s (U+00df) */
 706     result=u_memcasecmp(mixed, different, 5, U_FOLD_CASE_DEFAULT);
 707     if(result<=0) {
 708         log_err("error: u_memcasecmp(mixed, different, 5, default)=%ld instead of positive\n", result);
 709     }
 710 }
 711
 712 /* test UCaseMap ------------------------------------------------------------ */
 713
 714 /*
 715  * API test for UCaseMap;
 716  * test cases for actual case mappings using UCaseMap see
 717  * intltest utility/UnicodeStringTest/StringCaseTest/TestCasing
 718  */
 719 static void
 720 TestUCaseMap(void) {
 721     static const char
 722         aBc[] ={ 0x61, 0x42, 0x63, 0 },
 723         abc[] ={ 0x61, 0x62, 0x63, 0 },
 724         ABCg[]={ 0x41, 0x42, 0x43, 0x67, 0 },
 725         defg[]={ 0x64, 0x65, 0x66, 0x67, 0 };
 726     char utf8Out[8];
 727
 728     UCaseMap *csm;
 729     const char *locale;
 730     uint32_t options;
 731     int32_t length;
 732     UErrorCode errorCode;
 733
 734     errorCode=U_ZERO_ERROR;
 735     csm=ucasemap_open("tur", 0xa5, &errorCode);
 736     if(U_FAILURE(errorCode)) {
 737         log_err("ucasemap_open(\"tur\") failed - %s\n", u_errorName(errorCode));
 738         return;
 739     }
 740     locale=ucasemap_getLocale(csm);
 741     if(0!=strcmp(locale, "tr")) {
 742         log_err("ucasemap_getLocale(ucasemap_open(\"tur\"))==%s!=\"tr\"\n", locale);
 743     }
 744     /* overly long locale IDs get truncated to their language code to avoid unnecessary allocation */
 745     ucasemap_setLocale(csm, "I-kLInGOn-the-quick-brown-fox-jumps-over-the-lazy-dog", &errorCode);
 746     locale=ucasemap_getLocale(csm);
 747     if(0!=strcmp(locale, "i-klingon")) {
 748         log_err("ucasemap_getLocale(ucasemap_setLocale(\"I-kLInGOn-the-quick-br...\"))==%s!=\"i-klingon\"\n", locale);
 749     }
 750
 751     errorCode=U_ZERO_ERROR;
 752     options=ucasemap_getOptions(csm);
 753     if(options!=0xa5) {
 754         log_err("ucasemap_getOptions(ucasemap_open(0xa5))==0x%lx!=0xa5\n", (long)options);
 755     }
 756     ucasemap_setOptions(csm, 0x333333, &errorCode);
 757     options=ucasemap_getOptions(csm);
 758     if(options!=0x333333) {
 759         log_err("ucasemap_getOptions(ucasemap_setOptions(0x333333))==0x%lx!=0x333333\n", (long)options);
 760     }
 761
 762     /* test case mapping API; not all permutations necessary due to shared implementation code */
 763
 764     /* NUL terminated source */
 765     errorCode=U_ZERO_ERROR;
 766     length=ucasemap_utf8ToLower(csm, utf8Out, (int32_t)sizeof(utf8Out), aBc, -1, &errorCode);
 767     if(U_FAILURE(errorCode) || length!=3 || 0!=strcmp(abc, utf8Out)) {
 768         log_err("ucasemap_utf8ToLower(aBc\\0) failed\n");
 769     }
 770
 771     /* incoming failure code */
 772     errorCode=U_PARSE_ERROR;
 773     strcpy(utf8Out, defg);
 774     length=ucasemap_utf8ToLower(csm, utf8Out, (int32_t)sizeof(utf8Out), aBc, -1, &errorCode);
 775     if(errorCode!=U_PARSE_ERROR || 0!=strcmp(defg, utf8Out)) {
 776         log_err("ucasemap_utf8ToLower(failure) failed\n");
 777     }
 778
 779     /* overlapping input & output */
 780     errorCode=U_ZERO_ERROR;
 781     strcpy(utf8Out, aBc);
 782     length=ucasemap_utf8ToUpper(csm, utf8Out, 2, utf8Out+1, 2, &errorCode);
 783     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR || 0!=strcmp(aBc, utf8Out)) {
 784         log_err("ucasemap_utf8ToUpper(overlap 1) failed\n");
 785     }
 786
 787     /* overlap in the other direction */
 788     errorCode=U_ZERO_ERROR;
 789     strcpy(utf8Out, aBc);
 790     length=ucasemap_utf8ToUpper(csm, utf8Out+1, 2, utf8Out, 2, &errorCode);
 791     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR || 0!=strcmp(aBc, utf8Out)) {
 792         log_err("ucasemap_utf8ToUpper(overlap 2) failed\n");
 793     }
 794
 795     /* NULL destination */
 796     errorCode=U_ZERO_ERROR;
 797     strcpy(utf8Out, defg);
 798     length=ucasemap_utf8ToLower(csm, NULL, (int32_t)sizeof(utf8Out), aBc, -1, &errorCode);
 799     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR || 0!=strcmp(defg, utf8Out)) {
 800         log_err("ucasemap_utf8ToLower(dest=NULL) failed\n");
 801     }
 802
 803     /* destCapacity<0 */
 804     errorCode=U_ZERO_ERROR;
 805     strcpy(utf8Out, defg);
 806     length=ucasemap_utf8ToLower(csm, utf8Out, -2, aBc, -1, &errorCode);
 807     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR || 0!=strcmp(defg, utf8Out)) {
 808         log_err("ucasemap_utf8ToLower(destCapacity<0) failed\n");
 809     }
 810
 811     /* NULL source */
 812     errorCode=U_ZERO_ERROR;
 813     strcpy(utf8Out, defg);
 814     length=ucasemap_utf8ToLower(csm, utf8Out, (int32_t)sizeof(utf8Out), NULL, -1, &errorCode);
 815     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR || 0!=strcmp(defg, utf8Out)) {
 816         log_err("ucasemap_utf8ToLower(src=NULL) failed\n");
 817     }
 818
 819     /* srcLength<-1 */
 820     errorCode=U_ZERO_ERROR;
 821     strcpy(utf8Out, defg);
 822     length=ucasemap_utf8ToLower(csm, utf8Out, (int32_t)sizeof(utf8Out), aBc, -2, &errorCode);
 823     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR || 0!=strcmp(defg, utf8Out)) {
 824         log_err("ucasemap_utf8ToLower(srcLength<-1) failed\n");
 825     }
 826
 827     /* buffer overflow */
 828     errorCode=U_ZERO_ERROR;
 829     strcpy(utf8Out, defg);
 830     length=ucasemap_utf8ToUpper(csm, utf8Out, 2, aBc, 3, &errorCode);
 831     if(errorCode!=U_BUFFER_OVERFLOW_ERROR || length!=3 || 0!=strcmp(defg+2, utf8Out+2)) {
 832         log_err("ucasemap_utf8ToUpper(overflow) failed\n");
 833     }
 834
 835     /* dest not terminated (leaves g from defg alone) */
 836     errorCode=U_ZERO_ERROR;
 837     strcpy(utf8Out, defg);
 838     length=ucasemap_utf8ToUpper(csm, utf8Out, 3, aBc, 3, &errorCode);
 839     if(errorCode!=U_STRING_NOT_TERMINATED_WARNING || length!=3 || 0!=strcmp(ABCg, utf8Out)) {
 840         log_err("ucasemap_utf8ToUpper(overflow) failed\n");
 841     }
 842
 843     /* C API coverage for case folding. More thorough test via C++ intltest's StringCaseTest::TestCasing(). */
 844     errorCode=U_ZERO_ERROR;
 845     utf8Out[0]=0;
 846     length=ucasemap_utf8FoldCase(csm, utf8Out, (int32_t)sizeof(utf8Out), aBc, 3, &errorCode);
 847     if(U_FAILURE(errorCode) || length!=3 || 0!=strcmp(abc, utf8Out)) {
 848         log_err("ucasemap_utf8FoldCase(aBc) failed\n");
 849     }
 850
 851     ucasemap_close(csm);
 852 }
 853
 854 #if !UCONFIG_NO_BREAK_ITERATION
 855
 856 /* Try titlecasing with options. */
 857 static void
 858 TestUCaseMapToTitle(void) {
 859     /* "a 'CaT. A 'dOg! 'eTc." where '=U+02BB */
 860     /*
 861      * Note: The sentence BreakIterator does not recognize a '.'
 862      * as a sentence terminator if it is followed by lowercase.
 863      * That is why the example has the '!'.
 864      */
 865     static const UChar
 866
 867     beforeTitle[]=      { 0x61, 0x20, 0x2bb, 0x43, 0x61, 0x54, 0x2e, 0x20, 0x41, 0x20, 0x2bb, 0x64, 0x4f, 0x67, 0x21, 0x20, 0x2bb, 0x65, 0x54, 0x63, 0x2e },
 868     titleWord[]=        { 0x41, 0x20, 0x2bb, 0x43, 0x61, 0x74, 0x2e, 0x20, 0x41, 0x20, 0x2bb, 0x44, 0x6f, 0x67, 0x21, 0x20, 0x2bb, 0x45, 0x74, 0x63, 0x2e },
 869     titleWordNoAdjust[]={ 0x41, 0x20, 0x2bb, 0x63, 0x61, 0x74, 0x2e, 0x20, 0x41, 0x20, 0x2bb, 0x64, 0x6f, 0x67, 0x21, 0x20, 0x2bb, 0x65, 0x74, 0x63, 0x2e },
 870     titleSentNoLower[]= { 0x41, 0x20, 0x2bb, 0x43, 0x61, 0x54, 0x2e, 0x20, 0x41, 0x20, 0x2bb, 0x64, 0x4f, 0x67, 0x21, 0x20, 0x2bb, 0x45, 0x54, 0x63, 0x2e };
 871
 872     UChar buffer[32];
 873     UCaseMap *csm;
 874     UBreakIterator *sentenceIter;
 875     const UBreakIterator *iter;
 876     int32_t length;
 877     UErrorCode errorCode;
 878
 879     errorCode=U_ZERO_ERROR;
 880     csm=ucasemap_open("", 0, &errorCode);
 881     if(U_FAILURE(errorCode)) {
 882         log_err("ucasemap_open(\"\") failed - %s\n", u_errorName(errorCode));
 883         return;
 884     }
 885
 886     iter=ucasemap_getBreakIterator(csm);
 887     if(iter!=NULL) {
 888         log_err("ucasemap_getBreakIterator() returns %p!=NULL before setting any iterator or titlecasing\n", iter);
 889     }
 890
 891     /* Use default UBreakIterator: Word breaks. */
 892     length=ucasemap_toTitle(csm, buffer, LENGTHOF(buffer), beforeTitle, LENGTHOF(beforeTitle), &errorCode);
 893     if( U_FAILURE(errorCode) ||
 894         length!=LENGTHOF(titleWord) ||
 895         0!=u_memcmp(buffer, titleWord, length) ||
 896         buffer[length]!=0
 897     ) {
 898         log_err_status(errorCode, "ucasemap_toTitle(default iterator)=%ld failed - %s\n", (long)length, u_errorName(errorCode));
 899     }
 900     if (U_SUCCESS(errorCode)) {
 901         iter=ucasemap_getBreakIterator(csm);
 902         if(iter==NULL) {
 903             log_err("ucasemap_getBreakIterator() returns NULL after titlecasing\n");
 904         }
 905     }
 906
 907     /* Try U_TITLECASE_NO_BREAK_ADJUSTMENT. */
 908     ucasemap_setOptions(csm, U_TITLECASE_NO_BREAK_ADJUSTMENT, &errorCode);
 909     if(U_FAILURE(errorCode)) {
 910         log_err_status(errorCode, "error: ucasemap_setOptions(U_TITLECASE_NO_BREAK_ADJUSTMENT) failed - %s\n", u_errorName(errorCode));
 911         return;
 912     }
 913
 914     length=ucasemap_toTitle(csm, buffer, LENGTHOF(buffer), beforeTitle, LENGTHOF(beforeTitle), &errorCode);
 915     if( U_FAILURE(errorCode) ||
 916         length!=LENGTHOF(titleWordNoAdjust) ||
 917         0!=u_memcmp(buffer, titleWordNoAdjust, length) ||
 918         buffer[length]!=0
 919     ) {
 920         log_err("ucasemap_toTitle(default iterator, no break adjustment)=%ld failed - %s\n", (long)length, u_errorName(errorCode));
 921     }
 922
 923     /* Set a sentence break iterator. */
 924     errorCode=U_ZERO_ERROR;
 925     sentenceIter=ubrk_open(UBRK_SENTENCE, "", NULL, 0, &errorCode);
 926     if(U_FAILURE(errorCode)) {
 927         log_err("error: ubrk_open(UBRK_SENTENCE) failed - %s\n", u_errorName(errorCode));
 928         ucasemap_close(csm);
 929         return;
 930     }
 931     ucasemap_setBreakIterator(csm, sentenceIter, &errorCode);
 932     if(U_FAILURE(errorCode)) {
 933         log_err("error: ucasemap_setBreakIterator(sentence iterator) failed - %s\n", u_errorName(errorCode));
 934         ubrk_close(sentenceIter);
 935         ucasemap_close(csm);
 936         return;
 937     }
 938     iter=ucasemap_getBreakIterator(csm);
 939     if(iter!=sentenceIter) {
 940         log_err("ucasemap_getBreakIterator() returns %p!=%p after setting the iterator\n", iter, sentenceIter);
 941     }
 942
 943     ucasemap_setOptions(csm, U_TITLECASE_NO_LOWERCASE, &errorCode);
 944     if(U_FAILURE(errorCode)) {
 945         log_err("error: ucasemap_setOptions(U_TITLECASE_NO_LOWERCASE) failed - %s\n", u_errorName(errorCode));
 946         return;
 947     }
 948
 949     /* Use the sentence break iterator with the option. Preflight first. */
 950     length=ucasemap_toTitle(csm, NULL, 0, beforeTitle, LENGTHOF(beforeTitle), &errorCode);
 951     if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
 952         length!=LENGTHOF(titleSentNoLower)
 953     ) {
 954         log_err("ucasemap_toTitle(preflight sentence break iterator, no lowercasing)=%ld failed - %s\n", (long)length, u_errorName(errorCode));
 955     }
 956
 957     errorCode=U_ZERO_ERROR;
 958     buffer[0]=0;
 959     length=ucasemap_toTitle(csm, buffer, LENGTHOF(buffer), beforeTitle, LENGTHOF(beforeTitle), &errorCode);
 960     if( U_FAILURE(errorCode) ||
 961         length!=LENGTHOF(titleSentNoLower) ||
 962         0!=u_memcmp(buffer, titleSentNoLower, length) ||
 963         buffer[length]!=0
 964     ) {
 965         log_err("ucasemap_toTitle(sentence break iterator, no lowercasing)=%ld failed - %s\n", (long)length, u_errorName(errorCode));
 966     }
 967
 968     /* UTF-8 C API coverage. More thorough test via C++ intltest's StringCaseTest::TestCasing(). */
 969     {
 970         char utf8BeforeTitle[64], utf8TitleSentNoLower[64], utf8[64];
 971         int32_t utf8BeforeTitleLength, utf8TitleSentNoLowerLength;
 972
 973         errorCode=U_ZERO_ERROR;
 974         u_strToUTF8(utf8BeforeTitle, (int32_t)sizeof(utf8BeforeTitle), &utf8BeforeTitleLength, beforeTitle, LENGTHOF(beforeTitle), &errorCode);
 975         u_strToUTF8(utf8TitleSentNoLower, (int32_t)sizeof(utf8TitleSentNoLower), &utf8TitleSentNoLowerLength, titleSentNoLower, LENGTHOF(titleSentNoLower), &errorCode);
 976
 977         length=ucasemap_utf8ToTitle(csm, utf8, (int32_t)sizeof(utf8), utf8BeforeTitle, utf8BeforeTitleLength, &errorCode);
 978         if( U_FAILURE(errorCode) ||
 979             length!=utf8TitleSentNoLowerLength ||
 980             0!=uprv_memcmp(utf8, utf8TitleSentNoLower, length) ||
 981             utf8[length]!=0
 982         ) {
 983             log_err("ucasemap_utf8ToTitle(sentence break iterator, no lowercasing)=%ld failed - %s\n", (long)length, u_errorName(errorCode));
 984         }
 985     }
 986
 987     ucasemap_close(csm);
 988 }
 989
 990 #endif
 991
 992 void addCaseTest(TestNode** root);
 993
 994 void addCaseTest(TestNode** root) {
 995     /* cstrcase.c functions, declared in cucdtst.h */
 996     addTest(root, &TestCaseLower, "tsutil/cstrcase/TestCaseLower");
 997     addTest(root, &TestCaseUpper, "tsutil/cstrcase/TestCaseUpper");
 998 #if !UCONFIG_NO_BREAK_ITERATION && !UCONFIG_NO_FILE_IO
 999     addTest(root, &TestCaseTitle, "tsutil/cstrcase/TestCaseTitle");
1000     addTest(root, &TestCaseDutchTitle, "tsutil/cstrcase/TestCaseDutchTitle");
1001 #endif
1002     addTest(root, &TestCaseFolding, "tsutil/cstrcase/TestCaseFolding");
1003     addTest(root, &TestCaseCompare, "tsutil/cstrcase/TestCaseCompare");
1004     addTest(root, &TestUCaseMap, "tsutil/cstrcase/TestUCaseMap");
1005 #if !UCONFIG_NO_BREAK_ITERATION && !UCONFIG_NO_FILE_IO
1006     addTest(root, &TestUCaseMapToTitle, "tsutil/cstrcase/TestUCaseMapToTitle");
1007 #endif
1008 }