source/test/cintltst/cucdtst.c

   1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /********************************************************************
   4  * COPYRIGHT:
   5  * Copyright (c) 1997-2016, International Business Machines Corporation and
   6  * others. All Rights Reserved.
   7  ********************************************************************/
   8 /*******************************************************************************
   9 *
  10 * File CUCDTST.C
  11 *
  12 * Modification History:
  13 *        Name                     Description
  14 *     Madhu Katragadda            Ported for C API, added tests for string functions
  15 ********************************************************************************
  16 */
  17
  18 #include <string.h>
  19 #include <math.h>
  20 #include <stdlib.h>
  21
  22 #include "unicode/utypes.h"
  23 #include "unicode/uchar.h"
  24 #include "unicode/putil.h"
  25 #include "unicode/ustring.h"
  26 #include "unicode/uloc.h"
  27 #include "unicode/unorm2.h"
  28
  29 #include "cintltst.h"
  30 #include "putilimp.h"
  31 #include "uparse.h"
  32 #include "ucase.h"
  33 #include "ubidi_props.h"
  34 #include "uprops.h"
  35 #include "uset_imp.h"
  36 #include "usc_impl.h"
  37 #include "udatamem.h" /* for testing ucase_openBinary() */
  38 #include "cucdapi.h"
  39 #include "cmemory.h"
  40
  41 /* prototypes --------------------------------------------------------------- */
  42
  43 static void TestUpperLower(void);
  44 static void TestLetterNumber(void);
  45 static void TestMisc(void);
  46 static void TestPOSIX(void);
  47 static void TestControlPrint(void);
  48 static void TestIdentifier(void);
  49 static void TestUnicodeData(void);
  50 static void TestCodeUnit(void);
  51 static void TestCodePoint(void);
  52 static void TestCharLength(void);
  53 static void TestCharNames(void);
  54 static void TestUCharFromNameUnderflow(void);
  55 static void TestMirroring(void);
  56 static void TestUScriptRunAPI(void);
  57 static void TestAdditionalProperties(void);
  58 static void TestNumericProperties(void);
  59 static void TestPropertyNames(void);
  60 static void TestPropertyValues(void);
  61 static void TestConsistency(void);
  62 static void TestUCase(void);
  63 static void TestUBiDiProps(void);
  64 static void TestCaseFolding(void);
  65
  66 /* internal methods used */
  67 static int32_t MakeProp(char* str);
  68 static int32_t MakeDir(char* str);
  69
  70 /* helpers ------------------------------------------------------------------ */
  71
  72 static void
  73 parseUCDFile(const char *filename,
  74              char *fields[][2], int32_t fieldCount,
  75              UParseLineFn *lineFn, void *context,
  76              UErrorCode *pErrorCode) {
  77     char path[256];
  78     char backupPath[256];
  79
  80     if(U_FAILURE(*pErrorCode)) {
  81         return;
  82     }
  83
  84     /* Look inside ICU_DATA first */
  85     strcpy(path, u_getDataDirectory());
  86     strcat(path, ".." U_FILE_SEP_STRING "unidata" U_FILE_SEP_STRING);
  87     strcat(path, filename);
  88
  89     /* As a fallback, try to guess where the source data was located
  90      *    at the time ICU was built, and look there.
  91      */
  92     strcpy(backupPath, ctest_dataSrcDir());
  93     strcat(backupPath, U_FILE_SEP_STRING);
  94     strcat(backupPath, "unidata" U_FILE_SEP_STRING);
  95     strcat(backupPath, filename);
  96
  97     u_parseDelimitedFile(path, ';', fields, fieldCount, lineFn, context, pErrorCode);
  98     if(*pErrorCode==U_FILE_ACCESS_ERROR) {
  99         *pErrorCode=U_ZERO_ERROR;
 100         u_parseDelimitedFile(backupPath, ';', fields, fieldCount, lineFn, context, pErrorCode);
 101     }
 102     if(U_FAILURE(*pErrorCode)) {
 103         log_err_status(*pErrorCode, "error parsing %s: %s\n", filename, u_errorName(*pErrorCode));
 104     }
 105 }
 106
 107 /* test data ---------------------------------------------------------------- */
 108
 109 static const char tagStrings[] = "MnMcMeNdNlNoZsZlZpCcCfCsCoCnLuLlLtLmLoPcPdPsPePoSmScSkSoPiPf";
 110 static const int32_t tagValues[] =
 111     {
 112     /* Mn */ U_NON_SPACING_MARK,
 113     /* Mc */ U_COMBINING_SPACING_MARK,
 114     /* Me */ U_ENCLOSING_MARK,
 115     /* Nd */ U_DECIMAL_DIGIT_NUMBER,
 116     /* Nl */ U_LETTER_NUMBER,
 117     /* No */ U_OTHER_NUMBER,
 118     /* Zs */ U_SPACE_SEPARATOR,
 119     /* Zl */ U_LINE_SEPARATOR,
 120     /* Zp */ U_PARAGRAPH_SEPARATOR,
 121     /* Cc */ U_CONTROL_CHAR,
 122     /* Cf */ U_FORMAT_CHAR,
 123     /* Cs */ U_SURROGATE,
 124     /* Co */ U_PRIVATE_USE_CHAR,
 125     /* Cn */ U_UNASSIGNED,
 126     /* Lu */ U_UPPERCASE_LETTER,
 127     /* Ll */ U_LOWERCASE_LETTER,
 128     /* Lt */ U_TITLECASE_LETTER,
 129     /* Lm */ U_MODIFIER_LETTER,
 130     /* Lo */ U_OTHER_LETTER,
 131     /* Pc */ U_CONNECTOR_PUNCTUATION,
 132     /* Pd */ U_DASH_PUNCTUATION,
 133     /* Ps */ U_START_PUNCTUATION,
 134     /* Pe */ U_END_PUNCTUATION,
 135     /* Po */ U_OTHER_PUNCTUATION,
 136     /* Sm */ U_MATH_SYMBOL,
 137     /* Sc */ U_CURRENCY_SYMBOL,
 138     /* Sk */ U_MODIFIER_SYMBOL,
 139     /* So */ U_OTHER_SYMBOL,
 140     /* Pi */ U_INITIAL_PUNCTUATION,
 141     /* Pf */ U_FINAL_PUNCTUATION
 142     };
 143
 144 static const char dirStrings[][5] = {
 145     "L",
 146     "R",
 147     "EN",
 148     "ES",
 149     "ET",
 150     "AN",
 151     "CS",
 152     "B",
 153     "S",
 154     "WS",
 155     "ON",
 156     "LRE",
 157     "LRO",
 158     "AL",
 159     "RLE",
 160     "RLO",
 161     "PDF",
 162     "NSM",
 163     "BN",
 164     /* new in Unicode 6.3/ICU 52 */
 165     "FSI",
 166     "LRI",
 167     "RLI",
 168     "PDI"
 169 };
 170
 171 void addUnicodeTest(TestNode** root);
 172
 173 void addUnicodeTest(TestNode** root)
 174 {
 175     addTest(root, &TestCodeUnit, "tsutil/cucdtst/TestCodeUnit");
 176     addTest(root, &TestCodePoint, "tsutil/cucdtst/TestCodePoint");
 177     addTest(root, &TestCharLength, "tsutil/cucdtst/TestCharLength");
 178     addTest(root, &TestBinaryValues, "tsutil/cucdtst/TestBinaryValues");
 179     addTest(root, &TestUnicodeData, "tsutil/cucdtst/TestUnicodeData");
 180     addTest(root, &TestAdditionalProperties, "tsutil/cucdtst/TestAdditionalProperties");
 181     addTest(root, &TestNumericProperties, "tsutil/cucdtst/TestNumericProperties");
 182     addTest(root, &TestUpperLower, "tsutil/cucdtst/TestUpperLower");
 183     addTest(root, &TestLetterNumber, "tsutil/cucdtst/TestLetterNumber");
 184     addTest(root, &TestMisc, "tsutil/cucdtst/TestMisc");
 185     addTest(root, &TestPOSIX, "tsutil/cucdtst/TestPOSIX");
 186     addTest(root, &TestControlPrint, "tsutil/cucdtst/TestControlPrint");
 187     addTest(root, &TestIdentifier, "tsutil/cucdtst/TestIdentifier");
 188     addTest(root, &TestCharNames, "tsutil/cucdtst/TestCharNames");
 189     addTest(root, &TestUCharFromNameUnderflow, "tsutil/cucdtst/TestUCharFromNameUnderflow");
 190     addTest(root, &TestMirroring, "tsutil/cucdtst/TestMirroring");
 191     addTest(root, &TestUScriptCodeAPI, "tsutil/cucdtst/TestUScriptCodeAPI");
 192     addTest(root, &TestHasScript, "tsutil/cucdtst/TestHasScript");
 193     addTest(root, &TestGetScriptExtensions, "tsutil/cucdtst/TestGetScriptExtensions");
 194     addTest(root, &TestScriptMetadataAPI, "tsutil/cucdtst/TestScriptMetadataAPI");
 195     addTest(root, &TestUScriptRunAPI, "tsutil/cucdtst/TestUScriptRunAPI");
 196     addTest(root, &TestPropertyNames, "tsutil/cucdtst/TestPropertyNames");
 197     addTest(root, &TestPropertyValues, "tsutil/cucdtst/TestPropertyValues");
 198     addTest(root, &TestConsistency, "tsutil/cucdtst/TestConsistency");
 199     addTest(root, &TestUCase, "tsutil/cucdtst/TestUCase");
 200     addTest(root, &TestUBiDiProps, "tsutil/cucdtst/TestUBiDiProps");
 201     addTest(root, &TestCaseFolding, "tsutil/cucdtst/TestCaseFolding");
 202 }
 203
 204 /*==================================================== */
 205 /* test u_toupper() and u_tolower()                    */
 206 /*==================================================== */
 207 static void TestUpperLower()
 208 {
 209     const UChar upper[] = {0x41, 0x42, 0x00b2, 0x01c4, 0x01c6, 0x01c9, 0x01c8, 0x01c9, 0x000c, 0x0000};
 210     const UChar lower[] = {0x61, 0x62, 0x00b2, 0x01c6, 0x01c6, 0x01c9, 0x01c9, 0x01c9, 0x000c, 0x0000};
 211     U_STRING_DECL(upperTest, "abcdefg123hij.?:klmno", 21);
 212     U_STRING_DECL(lowerTest, "ABCDEFG123HIJ.?:KLMNO", 21);
 213     int32_t i;
 214
 215     U_STRING_INIT(upperTest, "abcdefg123hij.?:klmno", 21);
 216     U_STRING_INIT(lowerTest, "ABCDEFG123HIJ.?:KLMNO", 21);
 217
 218 /*
 219 Checks LetterLike Symbols which were previously a source of confusion
 220 [Bertrand A. D. 02/04/98]
 221 */
 222     for (i=0x2100;i<0x2138;i++)
 223     {
 224         /* Unicode 5.0 adds lowercase U+214E (TURNED SMALL F) to U+2132 (TURNED CAPITAL F) */
 225         if(i!=0x2126 && i!=0x212a && i!=0x212b && i!=0x2132)
 226         {
 227             if (i != (int)u_tolower(i)) /* itself */
 228                 log_err("Failed case conversion with itself: U+%04x\n", i);
 229             if (i != (int)u_toupper(i))
 230                 log_err("Failed case conversion with itself: U+%04x\n", i);
 231         }
 232     }
 233
 234     for(i=0; i < u_strlen(upper); i++){
 235         if(u_tolower(upper[i]) != lower[i]){
 236             log_err("FAILED u_tolower() for %lx Expected %lx Got %lx\n", upper[i], lower[i], u_tolower(upper[i]));
 237         }
 238     }
 239
 240     log_verbose("testing upper lower\n");
 241     for (i = 0; i < 21; i++) {
 242
 243         if (u_isalpha(upperTest[i]) && !u_islower(upperTest[i]))
 244         {
 245             log_err("Failed isLowerCase test at  %c\n", upperTest[i]);
 246         }
 247         else if (u_isalpha(lowerTest[i]) && !u_isupper(lowerTest[i]))
 248          {
 249             log_err("Failed isUpperCase test at %c\n", lowerTest[i]);
 250         }
 251         else if (upperTest[i] != u_tolower(lowerTest[i]))
 252         {
 253             log_err("Failed case conversion from %c  To %c :\n", lowerTest[i], upperTest[i]);
 254         }
 255         else if (lowerTest[i] != u_toupper(upperTest[i]))
 256          {
 257             log_err("Failed case conversion : %c To %c \n", upperTest[i], lowerTest[i]);
 258         }
 259         else if (upperTest[i] != u_tolower(upperTest[i]))
 260         {
 261             log_err("Failed case conversion with itself: %c\n", upperTest[i]);
 262         }
 263         else if (lowerTest[i] != u_toupper(lowerTest[i]))
 264         {
 265             log_err("Failed case conversion with itself: %c\n", lowerTest[i]);
 266         }
 267     }
 268     log_verbose("done testing upper lower\n");
 269
 270     log_verbose("testing u_istitle\n");
 271     {
 272         static const UChar expected[] = {
 273             0x1F88,
 274             0x1F89,
 275             0x1F8A,
 276             0x1F8B,
 277             0x1F8C,
 278             0x1F8D,
 279             0x1F8E,
 280             0x1F8F,
 281             0x1F88,
 282             0x1F89,
 283             0x1F8A,
 284             0x1F8B,
 285             0x1F8C,
 286             0x1F8D,
 287             0x1F8E,
 288             0x1F8F,
 289             0x1F98,
 290             0x1F99,
 291             0x1F9A,
 292             0x1F9B,
 293             0x1F9C,
 294             0x1F9D,
 295             0x1F9E,
 296             0x1F9F,
 297             0x1F98,
 298             0x1F99,
 299             0x1F9A,
 300             0x1F9B,
 301             0x1F9C,
 302             0x1F9D,
 303             0x1F9E,
 304             0x1F9F,
 305             0x1FA8,
 306             0x1FA9,
 307             0x1FAA,
 308             0x1FAB,
 309             0x1FAC,
 310             0x1FAD,
 311             0x1FAE,
 312             0x1FAF,
 313             0x1FA8,
 314             0x1FA9,
 315             0x1FAA,
 316             0x1FAB,
 317             0x1FAC,
 318             0x1FAD,
 319             0x1FAE,
 320             0x1FAF,
 321             0x1FBC,
 322             0x1FBC,
 323             0x1FCC,
 324             0x1FCC,
 325             0x1FFC,
 326             0x1FFC,
 327         };
 328         int32_t num = UPRV_LENGTHOF(expected);
 329         for(i=0; i<num; i++){
 330             if(!u_istitle(expected[i])){
 331                 log_err("u_istitle failed for 0x%4X. Expected TRUE, got FALSE\n",expected[i]);
 332             }
 333         }
 334
 335     }
 336 }
 337
 338 /* compare two sets and verify that their difference or intersection is empty */
 339 static UBool
 340 showADiffB(const USet *a, const USet *b,
 341            const char *a_name, const char *b_name,
 342            UBool expect, UBool diffIsError) {
 343     USet *aa;
 344     int32_t i, start, end, length;
 345     UErrorCode errorCode;
 346
 347     /*
 348      * expect:
 349      * TRUE  -> a-b should be empty, that is, b should contain all of a
 350      * FALSE -> a&b should be empty, that is, a should contain none of b (and vice versa)
 351      */
 352     if(expect ? uset_containsAll(b, a) : uset_containsNone(a, b)) {
 353         return TRUE;
 354     }
 355
 356     /* clone a to aa because a is const */
 357     aa=uset_open(1, 0);
 358     if(aa==NULL) {
 359         /* unusual problem - out of memory? */
 360         return FALSE;
 361     }
 362     uset_addAll(aa, a);
 363
 364     /* compute the set in question */
 365     if(expect) {
 366         /* a-b */
 367         uset_removeAll(aa, b);
 368     } else {
 369         /* a&b */
 370         uset_retainAll(aa, b);
 371     }
 372
 373     /* aa is not empty because of the initial tests above; show its contents */
 374     errorCode=U_ZERO_ERROR;
 375     i=0;
 376     for(;;) {
 377         length=uset_getItem(aa, i, &start, &end, NULL, 0, &errorCode);
 378         if(errorCode==U_INDEX_OUTOFBOUNDS_ERROR) {
 379             break; /* done */
 380         }
 381         if(U_FAILURE(errorCode)) {
 382             log_err("error comparing %s with %s at difference item %d: %s\n",
 383                 a_name, b_name, i, u_errorName(errorCode));
 384             break;
 385         }
 386         if(length!=0) {
 387             break; /* done with code points, got a string or -1 */
 388         }
 389
 390         if(diffIsError) {
 391             if(expect) {
 392                 log_err("error: %s contains U+%04x..U+%04x but %s does not\n", a_name, start, end, b_name);
 393             } else {
 394                 log_err("error: %s and %s both contain U+%04x..U+%04x but should not intersect\n", a_name, b_name, start, end);
 395             }
 396         } else {
 397             if(expect) {
 398                 log_verbose("info: %s contains U+%04x..U+%04x but %s does not\n", a_name, start, end, b_name);
 399             } else {
 400                 log_verbose("info: %s and %s both contain U+%04x..U+%04x but should not intersect\n", a_name, b_name, start, end);
 401             }
 402         }
 403
 404         ++i;
 405     }
 406
 407     uset_close(aa);
 408     return FALSE;
 409 }
 410
 411 static UBool
 412 showAMinusB(const USet *a, const USet *b,
 413             const char *a_name, const char *b_name,
 414             UBool diffIsError) {
 415     return showADiffB(a, b, a_name, b_name, TRUE, diffIsError);
 416 }
 417
 418 static UBool
 419 showAIntersectB(const USet *a, const USet *b,
 420                 const char *a_name, const char *b_name,
 421                 UBool diffIsError) {
 422     return showADiffB(a, b, a_name, b_name, FALSE, diffIsError);
 423 }
 424
 425 static UBool
 426 compareUSets(const USet *a, const USet *b,
 427              const char *a_name, const char *b_name,
 428              UBool diffIsError) {
 429     /*
 430      * Use an arithmetic & not a logical && so that both branches
 431      * are always taken and all differences are shown.
 432      */
 433     return
 434         showAMinusB(a, b, a_name, b_name, diffIsError) &
 435         showAMinusB(b, a, b_name, a_name, diffIsError);
 436 }
 437
 438 /* test isLetter(u_isapha()) and isDigit(u_isdigit()) */
 439 static void TestLetterNumber()
 440 {
 441     UChar i = 0x0000;
 442
 443     log_verbose("Testing for isalpha\n");
 444     for (i = 0x0041; i < 0x005B; i++) {
 445         if (!u_isalpha(i))
 446         {
 447             log_err("Failed isLetter test at  %.4X\n", i);
 448         }
 449     }
 450     for (i = 0x0660; i < 0x066A; i++) {
 451         if (u_isalpha(i))
 452         {
 453             log_err("Failed isLetter test with numbers at %.4X\n", i);
 454         }
 455     }
 456
 457     log_verbose("Testing for isdigit\n");
 458     for (i = 0x0660; i < 0x066A; i++) {
 459         if (!u_isdigit(i))
 460         {
 461             log_verbose("Failed isNumber test at %.4X\n", i);
 462         }
 463     }
 464
 465     log_verbose("Testing for isalnum\n");
 466     for (i = 0x0041; i < 0x005B; i++) {
 467         if (!u_isalnum(i))
 468         {
 469             log_err("Failed isAlNum test at  %.4X\n", i);
 470         }
 471     }
 472     for (i = 0x0660; i < 0x066A; i++) {
 473         if (!u_isalnum(i))
 474         {
 475             log_err("Failed isAlNum test at  %.4X\n", i);
 476         }
 477     }
 478
 479     {
 480         /*
 481          * The following checks work only starting from Unicode 4.0.
 482          * Check the version number here.
 483          */
 484         static UVersionInfo u401={ 4, 0, 1, 0 };
 485         UVersionInfo version;
 486         u_getUnicodeVersion(version);
 487         if(version[0]<4 || 0==memcmp(version, u401, 4)) {
 488             return;
 489         }
 490     }
 491
 492     {
 493         /*
 494          * Sanity check:
 495          * Verify that exactly the digit characters have decimal digit values.
 496          * This assumption is used in the implementation of u_digit()
 497          * (which checks nt=de)
 498          * compared with the parallel java.lang.Character.digit()
 499          * (which checks Nd).
 500          *
 501          * This was not true in Unicode 3.2 and earlier.
 502          * Unicode 4.0 fixed discrepancies.
 503          * Unicode 4.0.1 re-introduced problems in this area due to an
 504          * unintentionally incomplete last-minute change.
 505          */
 506         U_STRING_DECL(digitsPattern, "[:Nd:]", 6);
 507         U_STRING_DECL(decimalValuesPattern, "[:Numeric_Type=Decimal:]", 24);
 508
 509         USet *digits, *decimalValues;
 510         UErrorCode errorCode;
 511
 512         U_STRING_INIT(digitsPattern, "[:Nd:]", 6);
 513         U_STRING_INIT(decimalValuesPattern, "[:Numeric_Type=Decimal:]", 24);
 514         errorCode=U_ZERO_ERROR;
 515         digits=uset_openPattern(digitsPattern, 6, &errorCode);
 516         decimalValues=uset_openPattern(decimalValuesPattern, 24, &errorCode);
 517
 518         if(U_SUCCESS(errorCode)) {
 519             compareUSets(digits, decimalValues, "[:Nd:]", "[:Numeric_Type=Decimal:]", TRUE);
 520         }
 521
 522         uset_close(digits);
 523         uset_close(decimalValues);
 524     }
 525 }
 526
 527 static void testSampleCharProps(UBool propFn(UChar32), const char *propName,
 528                                 const UChar32 *sampleChars, int32_t sampleCharsLength,
 529                                 UBool expected) {
 530     int32_t i;
 531     for (i = 0; i < sampleCharsLength; ++i) {
 532         UBool result = propFn(sampleChars[i]);
 533         if (result != expected) {
 534             log_err("error: character property function %s(U+%04x)=%d is wrong\n",
 535                     propName, sampleChars[i], result);
 536         }
 537     }
 538 }
 539
 540 /* Tests for isDefined(u_isdefined)(, isBaseForm(u_isbase()), isSpaceChar(u_isspace()), isWhiteSpace(), u_CharDigitValue() */
 541 static void TestMisc()
 542 {
 543     static const UChar32 sampleSpaces[] = {0x0020, 0x00a0, 0x2000, 0x2001, 0x2005};
 544     static const UChar32 sampleNonSpaces[] = {0x61, 0x62, 0x63, 0x64, 0x74};
 545     static const UChar32 sampleUndefined[] = {0xfff1, 0xfff7, 0xfa6e};
 546     static const UChar32 sampleDefined[] = {0x523E, 0x4f88, 0xfffd};
 547     static const UChar32 sampleBase[] = {0x0061, 0x0031, 0x03d2};
 548     static const UChar32 sampleNonBase[] = {0x002B, 0x0020, 0x203B};
 549 /*    static const UChar sampleChars[] = {0x000a, 0x0045, 0x4e00, 0xDC00, 0xFFE8, 0xFFF0};*/
 550     static const UChar32 sampleDigits[]= {0x0030, 0x0662, 0x0F23, 0x0ED5};
 551     static const UChar32 sampleNonDigits[] = {0x0010, 0x0041, 0x0122, 0x68FE};
 552     static const UChar32 sampleWhiteSpaces[] = {0x2008, 0x2009, 0x200a, 0x001c, 0x000c};
 553     static const UChar32 sampleNonWhiteSpaces[] = {0x61, 0x62, 0x3c, 0x28, 0x3f, 0x85, 0x2007, 0xffef};
 554
 555     static const int32_t sampleDigitValues[] = {0, 2, 3, 5};
 556
 557     uint32_t mask;
 558
 559     int32_t i;
 560     char icuVersion[U_MAX_VERSION_STRING_LENGTH];
 561     UVersionInfo realVersion;
 562
 563     memset(icuVersion, 0, U_MAX_VERSION_STRING_LENGTH);
 564
 565     testSampleCharProps(u_isspace, "u_isspace", sampleSpaces, UPRV_LENGTHOF(sampleSpaces), TRUE);
 566     testSampleCharProps(u_isspace, "u_isspace", sampleNonSpaces, UPRV_LENGTHOF(sampleNonSpaces), FALSE);
 567
 568     testSampleCharProps(u_isJavaSpaceChar, "u_isJavaSpaceChar",
 569                         sampleSpaces, UPRV_LENGTHOF(sampleSpaces), TRUE);
 570     testSampleCharProps(u_isJavaSpaceChar, "u_isJavaSpaceChar",
 571                         sampleNonSpaces, UPRV_LENGTHOF(sampleNonSpaces), FALSE);
 572
 573     testSampleCharProps(u_isWhitespace, "u_isWhitespace",
 574                         sampleWhiteSpaces, UPRV_LENGTHOF(sampleWhiteSpaces), TRUE);
 575     testSampleCharProps(u_isWhitespace, "u_isWhitespace",
 576                         sampleNonWhiteSpaces, UPRV_LENGTHOF(sampleNonWhiteSpaces), FALSE);
 577
 578     testSampleCharProps(u_isdefined, "u_isdefined",
 579                         sampleDefined, UPRV_LENGTHOF(sampleDefined), TRUE);
 580     testSampleCharProps(u_isdefined, "u_isdefined",
 581                         sampleUndefined, UPRV_LENGTHOF(sampleUndefined), FALSE);
 582
 583     testSampleCharProps(u_isbase, "u_isbase", sampleBase, UPRV_LENGTHOF(sampleBase), TRUE);
 584     testSampleCharProps(u_isbase, "u_isbase", sampleNonBase, UPRV_LENGTHOF(sampleNonBase), FALSE);
 585
 586     testSampleCharProps(u_isdigit, "u_isdigit", sampleDigits, UPRV_LENGTHOF(sampleDigits), TRUE);
 587     testSampleCharProps(u_isdigit, "u_isdigit", sampleNonDigits, UPRV_LENGTHOF(sampleNonDigits), FALSE);
 588
 589     for (i = 0; i < UPRV_LENGTHOF(sampleDigits); i++) {
 590         if (u_charDigitValue(sampleDigits[i]) != sampleDigitValues[i]) {
 591             log_err("error: u_charDigitValue(U+04x)=%d != %d\n",
 592                     sampleDigits[i], u_charDigitValue(sampleDigits[i]), sampleDigitValues[i]);
 593         }
 594     }
 595
 596     /* Tests the ICU version #*/
 597     u_getVersion(realVersion);
 598     u_versionToString(realVersion, icuVersion);
 599     if (strncmp(icuVersion, U_ICU_VERSION, uprv_min((int32_t)strlen(icuVersion), (int32_t)strlen(U_ICU_VERSION))) != 0)
 600     {
 601         log_err("ICU version test failed. Header says=%s, got=%s \n", U_ICU_VERSION, icuVersion);
 602     }
 603 #if defined(ICU_VERSION)
 604     /* test only happens where we have configure.in with VERSION - sanity check. */
 605     if(strcmp(U_ICU_VERSION, ICU_VERSION))
 606     {
 607         log_err("ICU version mismatch: Header says %s, build environment says %s.\n",  U_ICU_VERSION, ICU_VERSION);
 608     }
 609 #endif
 610
 611     /* test U_GC_... */
 612     if(
 613         U_GET_GC_MASK(0x41)!=U_GC_LU_MASK ||
 614         U_GET_GC_MASK(0x662)!=U_GC_ND_MASK ||
 615         U_GET_GC_MASK(0xa0)!=U_GC_ZS_MASK ||
 616         U_GET_GC_MASK(0x28)!=U_GC_PS_MASK ||
 617         U_GET_GC_MASK(0x2044)!=U_GC_SM_MASK ||
 618         U_GET_GC_MASK(0xe0063)!=U_GC_CF_MASK
 619     ) {
 620         log_err("error: U_GET_GC_MASK does not work properly\n");
 621     }
 622
 623     mask=0;
 624     mask=(mask&~U_GC_CN_MASK)|U_GC_CN_MASK;
 625
 626     mask=(mask&~U_GC_LU_MASK)|U_GC_LU_MASK;
 627     mask=(mask&~U_GC_LL_MASK)|U_GC_LL_MASK;
 628     mask=(mask&~U_GC_LT_MASK)|U_GC_LT_MASK;
 629     mask=(mask&~U_GC_LM_MASK)|U_GC_LM_MASK;
 630     mask=(mask&~U_GC_LO_MASK)|U_GC_LO_MASK;
 631
 632     mask=(mask&~U_GC_MN_MASK)|U_GC_MN_MASK;
 633     mask=(mask&~U_GC_ME_MASK)|U_GC_ME_MASK;
 634     mask=(mask&~U_GC_MC_MASK)|U_GC_MC_MASK;
 635
 636     mask=(mask&~U_GC_ND_MASK)|U_GC_ND_MASK;
 637     mask=(mask&~U_GC_NL_MASK)|U_GC_NL_MASK;
 638     mask=(mask&~U_GC_NO_MASK)|U_GC_NO_MASK;
 639
 640     mask=(mask&~U_GC_ZS_MASK)|U_GC_ZS_MASK;
 641     mask=(mask&~U_GC_ZL_MASK)|U_GC_ZL_MASK;
 642     mask=(mask&~U_GC_ZP_MASK)|U_GC_ZP_MASK;
 643
 644     mask=(mask&~U_GC_CC_MASK)|U_GC_CC_MASK;
 645     mask=(mask&~U_GC_CF_MASK)|U_GC_CF_MASK;
 646     mask=(mask&~U_GC_CO_MASK)|U_GC_CO_MASK;
 647     mask=(mask&~U_GC_CS_MASK)|U_GC_CS_MASK;
 648
 649     mask=(mask&~U_GC_PD_MASK)|U_GC_PD_MASK;
 650     mask=(mask&~U_GC_PS_MASK)|U_GC_PS_MASK;
 651     mask=(mask&~U_GC_PE_MASK)|U_GC_PE_MASK;
 652     mask=(mask&~U_GC_PC_MASK)|U_GC_PC_MASK;
 653     mask=(mask&~U_GC_PO_MASK)|U_GC_PO_MASK;
 654
 655     mask=(mask&~U_GC_SM_MASK)|U_GC_SM_MASK;
 656     mask=(mask&~U_GC_SC_MASK)|U_GC_SC_MASK;
 657     mask=(mask&~U_GC_SK_MASK)|U_GC_SK_MASK;
 658     mask=(mask&~U_GC_SO_MASK)|U_GC_SO_MASK;
 659
 660     mask=(mask&~U_GC_PI_MASK)|U_GC_PI_MASK;
 661     mask=(mask&~U_GC_PF_MASK)|U_GC_PF_MASK;
 662
 663     if(mask!=(U_CHAR_CATEGORY_COUNT<32 ? U_MASK(U_CHAR_CATEGORY_COUNT)-1: 0xffffffff)) {
 664         log_err("error: problems with U_GC_XX_MASK constants\n");
 665     }
 666
 667     mask=0;
 668     mask=(mask&~U_GC_C_MASK)|U_GC_C_MASK;
 669     mask=(mask&~U_GC_L_MASK)|U_GC_L_MASK;
 670     mask=(mask&~U_GC_M_MASK)|U_GC_M_MASK;
 671     mask=(mask&~U_GC_N_MASK)|U_GC_N_MASK;
 672     mask=(mask&~U_GC_Z_MASK)|U_GC_Z_MASK;
 673     mask=(mask&~U_GC_P_MASK)|U_GC_P_MASK;
 674     mask=(mask&~U_GC_S_MASK)|U_GC_S_MASK;
 675
 676     if(mask!=(U_CHAR_CATEGORY_COUNT<32 ? U_MASK(U_CHAR_CATEGORY_COUNT)-1: 0xffffffff)) {
 677         log_err("error: problems with U_GC_Y_MASK constants\n");
 678     }
 679     {
 680         static const UChar32 digit[10]={ 0x0030,0x0031,0x0032,0x0033,0x0034,0x0035,0x0036,0x0037,0x0038,0x0039 };
 681         for(i=0; i<10; i++){
 682             if(digit[i]!=u_forDigit(i,10)){
 683                 log_err("u_forDigit failed for %i. Expected: 0x%4X Got: 0x%4X\n",i,digit[i],u_forDigit(i,10));
 684             }
 685         }
 686     }
 687
 688     /* test u_digit() */
 689     {
 690         static const struct {
 691             UChar32 c;
 692             int8_t radix, value;
 693         } data[]={
 694             /* base 16 */
 695             { 0x0031, 16, 1 },
 696             { 0x0038, 16, 8 },
 697             { 0x0043, 16, 12 },
 698             { 0x0066, 16, 15 },
 699             { 0x00e4, 16, -1 },
 700             { 0x0662, 16, 2 },
 701             { 0x06f5, 16, 5 },
 702             { 0xff13, 16, 3 },
 703             { 0xff41, 16, 10 },
 704
 705             /* base 8 */
 706             { 0x0031, 8, 1 },
 707             { 0x0038, 8, -1 },
 708             { 0x0043, 8, -1 },
 709             { 0x0066, 8, -1 },
 710             { 0x00e4, 8, -1 },
 711             { 0x0662, 8, 2 },
 712             { 0x06f5, 8, 5 },
 713             { 0xff13, 8, 3 },
 714             { 0xff41, 8, -1 },
 715
 716             /* base 36 */
 717             { 0x5a, 36, 35 },
 718             { 0x7a, 36, 35 },
 719             { 0xff3a, 36, 35 },
 720             { 0xff5a, 36, 35 },
 721
 722             /* wrong radix values */
 723             { 0x0031, 1, -1 },
 724             { 0xff3a, 37, -1 }
 725         };
 726
 727         for(i=0; i<UPRV_LENGTHOF(data); ++i) {
 728             if(u_digit(data[i].c, data[i].radix)!=data[i].value) {
 729                 log_err("u_digit(U+%04x, %d)=%d expected %d\n",
 730                         data[i].c,
 731                         data[i].radix,
 732                         u_digit(data[i].c, data[i].radix),
 733                         data[i].value);
 734             }
 735         }
 736     }
 737 }
 738
 739 /* test C/POSIX-style functions --------------------------------------------- */
 740
 741 /* bit flags */
 742 #define ISAL     1
 743 #define ISLO     2
 744 #define ISUP     4
 745
 746 #define ISDI     8
 747 #define ISXD  0x10
 748
 749 #define ISAN  0x20
 750
 751 #define ISPU  0x40
 752 #define ISGR  0x80
 753 #define ISPR 0x100
 754
 755 #define ISSP 0x200
 756 #define ISBL 0x400
 757 #define ISCN 0x800
 758
 759 /* C/POSIX-style functions, in the same order as the bit flags */
 760 typedef UBool U_EXPORT2 IsPOSIXClass(UChar32 c);
 761
 762 static const struct {
 763     IsPOSIXClass *fn;
 764     const char *name;
 765 } posixClasses[]={
 766     { u_isalpha, "isalpha" },
 767     { u_islower, "islower" },
 768     { u_isupper, "isupper" },
 769     { u_isdigit, "isdigit" },
 770     { u_isxdigit, "isxdigit" },
 771     { u_isalnum, "isalnum" },
 772     { u_ispunct, "ispunct" },
 773     { u_isgraph, "isgraph" },
 774     { u_isprint, "isprint" },
 775     { u_isspace, "isspace" },
 776     { u_isblank, "isblank" },
 777     { u_iscntrl, "iscntrl" }
 778 };
 779
 780 static const struct {
 781     UChar32 c;
 782     uint32_t posixResults;
 783 } posixData[]={
 784     { 0x0008,                                                        ISCN },    /* backspace */
 785     { 0x0009,                                              ISSP|ISBL|ISCN },    /* TAB */
 786     { 0x000a,                                              ISSP|     ISCN },    /* LF */
 787     { 0x000c,                                              ISSP|     ISCN },    /* FF */
 788     { 0x000d,                                              ISSP|     ISCN },    /* CR */
 789     { 0x0020,                                         ISPR|ISSP|ISBL      },    /* space */
 790     { 0x0021,                               ISPU|ISGR|ISPR                },    /* ! */
 791     { 0x0033,                ISDI|ISXD|ISAN|     ISGR|ISPR                },    /* 3 */
 792     { 0x0040,                               ISPU|ISGR|ISPR                },    /* @ */
 793     { 0x0041, ISAL|     ISUP|     ISXD|ISAN|     ISGR|ISPR                },    /* A */
 794     { 0x007a, ISAL|ISLO|               ISAN|     ISGR|ISPR                },    /* z */
 795     { 0x007b,                               ISPU|ISGR|ISPR                },    /* { */
 796     { 0x0085,                                              ISSP|     ISCN },    /* NEL */
 797     { 0x00a0,                                         ISPR|ISSP|ISBL      },    /* NBSP */
 798     { 0x00a4,                                    ISGR|ISPR                },    /* currency sign */
 799     { 0x00e4, ISAL|ISLO|               ISAN|     ISGR|ISPR                },    /* a-umlaut */
 800     { 0x0300,                                    ISGR|ISPR                },    /* combining grave */
 801     { 0x0600,                                                        ISCN },    /* arabic number sign */
 802     { 0x0627, ISAL|                    ISAN|     ISGR|ISPR                },    /* alef */
 803     { 0x0663,                ISDI|ISXD|ISAN|     ISGR|ISPR                },    /* arabic 3 */
 804     { 0x2002,                                         ISPR|ISSP|ISBL      },    /* en space */
 805     { 0x2007,                                         ISPR|ISSP|ISBL      },    /* figure space */
 806     { 0x2009,                                         ISPR|ISSP|ISBL      },    /* thin space */
 807     { 0x200b,                                                        ISCN },    /* ZWSP */
 808   /*{ 0x200b,                                         ISPR|ISSP           },*/    /* ZWSP */ /* ZWSP became a control char in 4.0.1*/
 809     { 0x200e,                                                        ISCN },    /* LRM */
 810     { 0x2028,                                         ISPR|ISSP|     ISCN },    /* LS */
 811     { 0x2029,                                         ISPR|ISSP|     ISCN },    /* PS */
 812     { 0x20ac,                                    ISGR|ISPR                },    /* Euro */
 813     { 0xff15,                ISDI|ISXD|ISAN|     ISGR|ISPR                },    /* fullwidth 5 */
 814     { 0xff25, ISAL|     ISUP|     ISXD|ISAN|     ISGR|ISPR                },    /* fullwidth E */
 815     { 0xff35, ISAL|     ISUP|          ISAN|     ISGR|ISPR                },    /* fullwidth U */
 816     { 0xff45, ISAL|ISLO|          ISXD|ISAN|     ISGR|ISPR                },    /* fullwidth e */
 817     { 0xff55, ISAL|ISLO|               ISAN|     ISGR|ISPR                }     /* fullwidth u */
 818 };
 819
 820 static void
 821 TestPOSIX() {
 822     uint32_t mask;
 823     int32_t cl, i;
 824     UBool expect;
 825
 826     mask=1;
 827     for(cl=0; cl<12; ++cl) {
 828         for(i=0; i<UPRV_LENGTHOF(posixData); ++i) {
 829             expect=(UBool)((posixData[i].posixResults&mask)!=0);
 830             if(posixClasses[cl].fn(posixData[i].c)!=expect) {
 831                 log_err("u_%s(U+%04x)=%s is wrong\n",
 832                     posixClasses[cl].name, posixData[i].c, expect ? "FALSE" : "TRUE");
 833             }
 834         }
 835         mask<<=1;
 836     }
 837 }
 838
 839 /* Tests for isControl(u_iscntrl()) and isPrintable(u_isprint()) */
 840 static void TestControlPrint()
 841 {
 842     const UChar32 sampleControl[] = {0x1b, 0x97, 0x82, 0x2028, 0x2029, 0x200c, 0x202b};
 843     const UChar32 sampleNonControl[] = {0x61, 0x0031, 0x00e2};
 844     const UChar32 samplePrintable[] = {0x0042, 0x005f, 0x2014};
 845     const UChar32 sampleNonPrintable[] = {0x200c, 0x009f, 0x001b};
 846     UChar32 c;
 847
 848     testSampleCharProps(u_iscntrl, "u_iscntrl", sampleControl, UPRV_LENGTHOF(sampleControl), TRUE);
 849     testSampleCharProps(u_iscntrl, "u_iscntrl", sampleNonControl, UPRV_LENGTHOF(sampleNonControl), FALSE);
 850
 851     testSampleCharProps(u_isprint, "u_isprint",
 852                         samplePrintable, UPRV_LENGTHOF(samplePrintable), TRUE);
 853     testSampleCharProps(u_isprint, "u_isprint",
 854                         sampleNonPrintable, UPRV_LENGTHOF(sampleNonPrintable), FALSE);
 855
 856     /* test all ISO 8 controls */
 857     for(c=0; c<=0x9f; ++c) {
 858         if(c==0x20) {
 859             /* skip ASCII graphic characters and continue with DEL */
 860             c=0x7f;
 861         }
 862         if(!u_iscntrl(c)) {
 863             log_err("error: u_iscntrl(ISO 8 control U+%04x)=FALSE\n", c);
 864         }
 865         if(!u_isISOControl(c)) {
 866             log_err("error: u_isISOControl(ISO 8 control U+%04x)=FALSE\n", c);
 867         }
 868         if(u_isprint(c)) {
 869             log_err("error: u_isprint(ISO 8 control U+%04x)=TRUE\n", c);
 870         }
 871     }
 872
 873     /* test all Latin-1 graphic characters */
 874     for(c=0x20; c<=0xff; ++c) {
 875         if(c==0x7f) {
 876             c=0xa0;
 877         } else if(c==0xad) {
 878             /* Unicode 4 changes 00AD Soft Hyphen to Cf (and it is in fact not printable) */
 879             ++c;
 880         }
 881         if(!u_isprint(c)) {
 882             log_err("error: u_isprint(Latin-1 graphic character U+%04x)=FALSE\n", c);
 883         }
 884     }
 885 }
 886
 887 /* u_isJavaIDStart, u_isJavaIDPart, u_isIDStart(), u_isIDPart(), u_isIDIgnorable()*/
 888 static void TestIdentifier()
 889 {
 890     const UChar32 sampleJavaIDStart[] = {0x0071, 0x00e4, 0x005f};
 891     const UChar32 sampleNonJavaIDStart[] = {0x0020, 0x2030, 0x0082};
 892     const UChar32 sampleJavaIDPart[] = {0x005f, 0x0032, 0x0045};
 893     const UChar32 sampleNonJavaIDPart[] = {0x2030, 0x2020, 0x0020};
 894     const UChar32 sampleUnicodeIDStart[] = {0x0250, 0x00e2, 0x0061};
 895     const UChar32 sampleNonUnicodeIDStart[] = {0x2000, 0x000a, 0x2019};
 896     const UChar32 sampleUnicodeIDPart[] = {0x005f, 0x0032, 0x0045};
 897     const UChar32 sampleNonUnicodeIDPart[] = {0x2030, 0x00a3, 0x0020};
 898     const UChar32 sampleIDIgnore[] = {0x0006, 0x0010, 0x206b, 0x85};
 899     const UChar32 sampleNonIDIgnore[] = {0x0075, 0x00a3, 0x0061};
 900
 901     testSampleCharProps(u_isJavaIDStart, "u_isJavaIDStart",
 902                         sampleJavaIDStart, UPRV_LENGTHOF(sampleJavaIDStart), TRUE);
 903     testSampleCharProps(u_isJavaIDStart, "u_isJavaIDStart",
 904                         sampleNonJavaIDStart, UPRV_LENGTHOF(sampleNonJavaIDStart), FALSE);
 905
 906     testSampleCharProps(u_isJavaIDPart, "u_isJavaIDPart",
 907                         sampleJavaIDPart, UPRV_LENGTHOF(sampleJavaIDPart), TRUE);
 908     testSampleCharProps(u_isJavaIDPart, "u_isJavaIDPart",
 909                         sampleNonJavaIDPart, UPRV_LENGTHOF(sampleNonJavaIDPart), FALSE);
 910
 911     /* IDPart should imply IDStart */
 912     testSampleCharProps(u_isJavaIDPart, "u_isJavaIDPart",
 913                         sampleJavaIDStart, UPRV_LENGTHOF(sampleJavaIDStart), TRUE);
 914
 915     testSampleCharProps(u_isIDStart, "u_isIDStart",
 916                         sampleUnicodeIDStart, UPRV_LENGTHOF(sampleUnicodeIDStart), TRUE);
 917     testSampleCharProps(u_isIDStart, "u_isIDStart",
 918                         sampleNonUnicodeIDStart, UPRV_LENGTHOF(sampleNonUnicodeIDStart), FALSE);
 919
 920     testSampleCharProps(u_isIDPart, "u_isIDPart",
 921                         sampleUnicodeIDPart, UPRV_LENGTHOF(sampleUnicodeIDPart), TRUE);
 922     testSampleCharProps(u_isIDPart, "u_isIDPart",
 923                         sampleNonUnicodeIDPart, UPRV_LENGTHOF(sampleNonUnicodeIDPart), FALSE);
 924
 925     /* IDPart should imply IDStart */
 926     testSampleCharProps(u_isIDPart, "u_isIDPart",
 927                         sampleUnicodeIDStart, UPRV_LENGTHOF(sampleUnicodeIDStart), TRUE);
 928
 929     testSampleCharProps(u_isIDIgnorable, "u_isIDIgnorable",
 930                         sampleIDIgnore, UPRV_LENGTHOF(sampleIDIgnore), TRUE);
 931     testSampleCharProps(u_isIDIgnorable, "u_isIDIgnorable",
 932                         sampleNonIDIgnore, UPRV_LENGTHOF(sampleNonIDIgnore), FALSE);
 933 }
 934
 935 /* for each line of UnicodeData.txt, check some of the properties */
 936 typedef struct UnicodeDataContext {
 937 #if UCONFIG_NO_NORMALIZATION
 938     const void *dummy;
 939 #else
 940     const UNormalizer2 *nfc;
 941     const UNormalizer2 *nfkc;
 942 #endif
 943 } UnicodeDataContext;
 944
 945 /*
 946  * ### TODO
 947  * This test fails incorrectly if the First or Last code point of a repetitive area
 948  * is overridden, which is allowed and is encouraged for the PUAs.
 949  * Currently, this means that both area First/Last and override lines are
 950  * tested against the properties from the API,
 951  * and the area boundary will not match and cause an error.
 952  *
 953  * This function should detect area boundaries and skip them for the test of individual
 954  * code points' properties.
 955  * Then it should check that the areas contain all the same properties except where overridden.
 956  * For this, it would have had to set a flag for which code points were listed explicitly.
 957  */
 958 static void U_CALLCONV
 959 unicodeDataLineFn(void *context,
 960                   char *fields[][2], int32_t fieldCount,
 961                   UErrorCode *pErrorCode)
 962 {
 963     char buffer[100];
 964     const char *d;
 965     char *end;
 966     uint32_t value;
 967     UChar32 c;
 968     int32_t i;
 969     int8_t type;
 970     int32_t dt;
 971     UChar dm[32], s[32];
 972     int32_t dmLength, length;
 973
 974 #if !UCONFIG_NO_NORMALIZATION
 975     const UNormalizer2 *nfc, *nfkc;
 976 #endif
 977
 978     /* get the character code, field 0 */
 979     c=strtoul(fields[0][0], &end, 16);
 980     if(end<=fields[0][0] || end!=fields[0][1]) {
 981         log_err("error: syntax error in field 0 at %s\n", fields[0][0]);
 982         return;
 983     }
 984     if((uint32_t)c>=UCHAR_MAX_VALUE + 1) {
 985         log_err("error in UnicodeData.txt: code point %lu out of range\n", c);
 986         return;
 987     }
 988
 989     /* get general category, field 2 */
 990     *fields[2][1]=0;
 991     type = (int8_t)tagValues[MakeProp(fields[2][0])];
 992     if(u_charType(c)!=type) {
 993         log_err("error: u_charType(U+%04lx)==%u instead of %u\n", c, u_charType(c), type);
 994     }
 995     if((uint32_t)u_getIntPropertyValue(c, UCHAR_GENERAL_CATEGORY_MASK)!=U_MASK(type)) {
 996         log_err("error: (uint32_t)u_getIntPropertyValue(U+%04lx, UCHAR_GENERAL_CATEGORY_MASK)!=U_MASK(u_charType())\n", c);
 997     }
 998
 999     /* get canonical combining class, field 3 */
1000     value=strtoul(fields[3][0], &end, 10);
1001     if(end<=fields[3][0] || end!=fields[3][1]) {
1002         log_err("error: syntax error in field 3 at code 0x%lx\n", c);
1003         return;
1004     }
1005     if(value>255) {
1006         log_err("error in UnicodeData.txt: combining class %lu out of range\n", value);
1007         return;
1008     }
1009 #if !UCONFIG_NO_NORMALIZATION
1010     if(value!=u_getCombiningClass(c) || value!=(uint32_t)u_getIntPropertyValue(c, UCHAR_CANONICAL_COMBINING_CLASS)) {
1011         log_err("error: u_getCombiningClass(U+%04lx)==%hu instead of %lu\n", c, u_getCombiningClass(c), value);
1012     }
1013     nfkc=((UnicodeDataContext *)context)->nfkc;
1014     if(value!=unorm2_getCombiningClass(nfkc, c)) {
1015         log_err("error: unorm2_getCombiningClass(nfkc, U+%04lx)==%hu instead of %lu\n", c, unorm2_getCombiningClass(nfkc, c), value);
1016     }
1017 #endif
1018
1019     /* get BiDi category, field 4 */
1020     *fields[4][1]=0;
1021     i=MakeDir(fields[4][0]);
1022     if(i!=u_charDirection(c) || i!=u_getIntPropertyValue(c, UCHAR_BIDI_CLASS)) {
1023         log_err("error: u_charDirection(U+%04lx)==%u instead of %u (%s)\n", c, u_charDirection(c), MakeDir(fields[4][0]), fields[4][0]);
1024     }
1025
1026     /* get Decomposition_Type & Decomposition_Mapping, field 5 */
1027     d=NULL;
1028     if(fields[5][0]==fields[5][1]) {
1029         /* no decomposition, except UnicodeData.txt omits Hangul syllable decompositions */
1030         if(c==0xac00 || c==0xd7a3) {
1031             dt=U_DT_CANONICAL;
1032         } else {
1033             dt=U_DT_NONE;
1034         }
1035     } else {
1036         d=fields[5][0];
1037         *fields[5][1]=0;
1038         dt=UCHAR_INVALID_CODE;
1039         if(*d=='<') {
1040             end=strchr(++d, '>');
1041             if(end!=NULL) {
1042                 *end=0;
1043                 dt=u_getPropertyValueEnum(UCHAR_DECOMPOSITION_TYPE, d);
1044                 d=u_skipWhitespace(end+1);
1045             }
1046         } else {
1047             dt=U_DT_CANONICAL;
1048         }
1049     }
1050     if(dt>U_DT_NONE) {
1051         if(c==0xac00) {
1052             dm[0]=0x1100;
1053             dm[1]=0x1161;
1054             dm[2]=0;
1055             dmLength=2;
1056         } else if(c==0xd7a3) {
1057             dm[0]=0xd788;
1058             dm[1]=0x11c2;
1059             dm[2]=0;
1060             dmLength=2;
1061         } else {
1062             dmLength=u_parseString(d, dm, 32, NULL, pErrorCode);
1063         }
1064     } else {
1065         dmLength=-1;
1066     }
1067     if(dt<0 || U_FAILURE(*pErrorCode)) {
1068         log_err("error in UnicodeData.txt: syntax error in U+%04lX decomposition field\n", (long)c);
1069         return;
1070     }
1071 #if !UCONFIG_NO_NORMALIZATION
1072     i=u_getIntPropertyValue(c, UCHAR_DECOMPOSITION_TYPE);
1073     if(i!=dt) {
1074         log_err("error: u_getIntPropertyValue(U+%04lx, UCHAR_DECOMPOSITION_TYPE)==%d instead of %d\n", c, i, dt);
1075     }
1076     /* Expect Decomposition_Mapping=nfkc.getRawDecomposition(c). */
1077     length=unorm2_getRawDecomposition(nfkc, c, s, 32, pErrorCode);
1078     if(U_FAILURE(*pErrorCode) || length!=dmLength || (length>0 && 0!=u_strcmp(s, dm))) {
1079         log_err("error: unorm2_getRawDecomposition(nfkc, U+%04lx)==%d instead of %d "
1080                 "or the Decomposition_Mapping is different (%s)\n",
1081                 c, length, dmLength, u_errorName(*pErrorCode));
1082         return;
1083     }
1084     /* For canonical decompositions only, expect Decomposition_Mapping=nfc.getRawDecomposition(c). */
1085     if(dt!=U_DT_CANONICAL) {
1086         dmLength=-1;
1087     }
1088     nfc=((UnicodeDataContext *)context)->nfc;
1089     length=unorm2_getRawDecomposition(nfc, c, s, 32, pErrorCode);
1090     if(U_FAILURE(*pErrorCode) || length!=dmLength || (length>0 && 0!=u_strcmp(s, dm))) {
1091         log_err("error: unorm2_getRawDecomposition(nfc, U+%04lx)==%d instead of %d "
1092                 "or the Decomposition_Mapping is different (%s)\n",
1093                 c, length, dmLength, u_errorName(*pErrorCode));
1094         return;
1095     }
1096     /* recompose */
1097     if(dt==U_DT_CANONICAL && !u_hasBinaryProperty(c, UCHAR_FULL_COMPOSITION_EXCLUSION)) {
1098         UChar32 a, b, composite;
1099         i=0;
1100         U16_NEXT(dm, i, dmLength, a);
1101         U16_NEXT(dm, i, dmLength, b);
1102         /* i==dmLength */
1103         composite=unorm2_composePair(nfc, a, b);
1104         if(composite!=c) {
1105             log_err("error: nfc U+%04lX decomposes to U+%04lX+U+%04lX but does not compose back (instead U+%04lX)\n",
1106                     (long)c, (long)a, (long)b, (long)composite);
1107         }
1108         /*
1109          * Note: NFKC has fewer round-trip mappings than NFC,
1110          * so we can't just test unorm2_composePair(nfkc, a, b) here without further data.
1111          */
1112     }
1113 #endif
1114
1115     /* get ISO Comment, field 11 */
1116     *fields[11][1]=0;
1117     i=u_getISOComment(c, buffer, sizeof(buffer), pErrorCode);
1118     if(U_FAILURE(*pErrorCode) || 0!=strcmp(fields[11][0], buffer)) {
1119         log_err_status(*pErrorCode, "error: u_getISOComment(U+%04lx) wrong (%s): \"%s\" should be \"%s\"\n",
1120             c, u_errorName(*pErrorCode),
1121             U_FAILURE(*pErrorCode) ? buffer : "[error]",
1122             fields[11][0]);
1123     }
1124
1125     /* get uppercase mapping, field 12 */
1126     if(fields[12][0]!=fields[12][1]) {
1127         value=strtoul(fields[12][0], &end, 16);
1128         if(end!=fields[12][1]) {
1129             log_err("error: syntax error in field 12 at code 0x%lx\n", c);
1130             return;
1131         }
1132         if((UChar32)value!=u_toupper(c)) {
1133             log_err("error: u_toupper(U+%04lx)==U+%04lx instead of U+%04lx\n", c, u_toupper(c), value);
1134         }
1135     } else {
1136         /* no case mapping: the API must map the code point to itself */
1137         if(c!=u_toupper(c)) {
1138             log_err("error: U+%04lx does not have an uppercase mapping but u_toupper()==U+%04lx\n", c, u_toupper(c));
1139         }
1140     }
1141
1142     /* get lowercase mapping, field 13 */
1143     if(fields[13][0]!=fields[13][1]) {
1144         value=strtoul(fields[13][0], &end, 16);
1145         if(end!=fields[13][1]) {
1146             log_err("error: syntax error in field 13 at code 0x%lx\n", c);
1147             return;
1148         }
1149         if((UChar32)value!=u_tolower(c)) {
1150             log_err("error: u_tolower(U+%04lx)==U+%04lx instead of U+%04lx\n", c, u_tolower(c), value);
1151         }
1152     } else {
1153         /* no case mapping: the API must map the code point to itself */
1154         if(c!=u_tolower(c)) {
1155             log_err("error: U+%04lx does not have a lowercase mapping but u_tolower()==U+%04lx\n", c, u_tolower(c));
1156         }
1157     }
1158
1159     /* get titlecase mapping, field 14 */
1160     if(fields[14][0]!=fields[14][1]) {
1161         value=strtoul(fields[14][0], &end, 16);
1162         if(end!=fields[14][1]) {
1163             log_err("error: syntax error in field 14 at code 0x%lx\n", c);
1164             return;
1165         }
1166         if((UChar32)value!=u_totitle(c)) {
1167             log_err("error: u_totitle(U+%04lx)==U+%04lx instead of U+%04lx\n", c, u_totitle(c), value);
1168         }
1169     } else {
1170         /* no case mapping: the API must map the code point to itself */
1171         if(c!=u_totitle(c)) {
1172             log_err("error: U+%04lx does not have a titlecase mapping but u_totitle()==U+%04lx\n", c, u_totitle(c));
1173         }
1174     }
1175 }
1176
1177 static UBool U_CALLCONV
1178 enumTypeRange(const void *context, UChar32 start, UChar32 limit, UCharCategory type) {
1179     static const UChar32 test[][2]={
1180         {0x41, U_UPPERCASE_LETTER},
1181         {0x308, U_NON_SPACING_MARK},
1182         {0xfffe, U_GENERAL_OTHER_TYPES},
1183         {0xe0041, U_FORMAT_CHAR},
1184         {0xeffff, U_UNASSIGNED}
1185     };
1186
1187     int32_t i, count;
1188
1189     if(0!=strcmp((const char *)context, "a1")) {
1190         log_err("error: u_enumCharTypes() passes on an incorrect context pointer\n");
1191         return FALSE;
1192     }
1193
1194     count=UPRV_LENGTHOF(test);
1195     for(i=0; i<count; ++i) {
1196         if(start<=test[i][0] && test[i][0]<limit) {
1197             if(type!=(UCharCategory)test[i][1]) {
1198                 log_err("error: u_enumCharTypes() has range [U+%04lx, U+%04lx[ with %ld instead of U+%04lx with %ld\n",
1199                         start, limit, (long)type, test[i][0], test[i][1]);
1200             }
1201             /* stop at the range that includes the last test code point (increases code coverage for enumeration) */
1202             return i==(count-1) ? FALSE : TRUE;
1203         }
1204     }
1205
1206     if(start>test[count-1][0]) {
1207         log_err("error: u_enumCharTypes() has range [U+%04lx, U+%04lx[ with %ld after it should have stopped\n",
1208                 start, limit, (long)type);
1209         return FALSE;
1210     }
1211
1212     return TRUE;
1213 }
1214
1215 static UBool U_CALLCONV
1216 enumDefaultsRange(const void *context, UChar32 start, UChar32 limit, UCharCategory type) {
1217     /* default Bidi classes for unassigned code points, from the DerivedBidiClass.txt header */
1218     static const int32_t defaultBidi[][2]={ /* { limit, class } */
1219         { 0x0590, U_LEFT_TO_RIGHT },
1220         { 0x0600, U_RIGHT_TO_LEFT },
1221         { 0x07C0, U_RIGHT_TO_LEFT_ARABIC },
1222         { 0x08A0, U_RIGHT_TO_LEFT },
1223         { 0x0900, U_RIGHT_TO_LEFT_ARABIC },  /* Unicode 6.1 changes U+08A0..U+08FF from R to AL */
1224         { 0x20A0, U_LEFT_TO_RIGHT },
1225         { 0x20D0, U_EUROPEAN_NUMBER_TERMINATOR },  /* Unicode 6.3 changes the currency symbols block U+20A0..U+20CF to default to ET not L */
1226         { 0xFB1D, U_LEFT_TO_RIGHT },
1227         { 0xFB50, U_RIGHT_TO_LEFT },
1228         { 0xFE00, U_RIGHT_TO_LEFT_ARABIC },
1229         { 0xFE70, U_LEFT_TO_RIGHT },
1230         { 0xFF00, U_RIGHT_TO_LEFT_ARABIC },
1231         { 0x10800, U_LEFT_TO_RIGHT },
1232         { 0x11000, U_RIGHT_TO_LEFT },
1233         { 0x1E800, U_LEFT_TO_RIGHT },  /* new default-R range in Unicode 5.2: U+1E800 - U+1EFFF */
1234         { 0x1EE00, U_RIGHT_TO_LEFT },
1235         { 0x1EF00, U_RIGHT_TO_LEFT_ARABIC },  /* Unicode 6.1 changes U+1EE00..U+1EEFF from R to AL */
1236         { 0x1F000, U_RIGHT_TO_LEFT },
1237         { 0x110000, U_LEFT_TO_RIGHT }
1238     };
1239
1240     UChar32 c;
1241     int32_t i;
1242     UCharDirection shouldBeDir;
1243
1244     /*
1245      * LineBreak.txt specifies:
1246      *   #  - Assigned characters that are not listed explicitly are given the value
1247      *   #    "AL".
1248      *   #  - Unassigned characters are given the value "XX".
1249      *
1250      * PUA characters are listed explicitly with "XX".
1251      * Verify that no assigned character has "XX".
1252      */
1253     if(type!=U_UNASSIGNED && type!=U_PRIVATE_USE_CHAR) {
1254         c=start;
1255         while(c<limit) {
1256             if(0==u_getIntPropertyValue(c, UCHAR_LINE_BREAK)) {
1257                 log_err("error UCHAR_LINE_BREAK(assigned U+%04lx)=XX\n", c);
1258             }
1259             ++c;
1260         }
1261     }
1262
1263     /*
1264      * Verify default Bidi classes.
1265      * For recent Unicode versions, see UCD.html.
1266      *
1267      * For older Unicode versions:
1268      * See table 3-7 "Bidirectional Character Types" in UAX #9.
1269      * http://www.unicode.org/reports/tr9/
1270      *
1271      * See also DerivedBidiClass.txt for Cn code points!
1272      *
1273      * Unicode 4.0.1/Public Review Issue #28 (http://www.unicode.org/review/resolved-pri.html)
1274      * changed some default values.
1275      * In particular, non-characters and unassigned Default Ignorable Code Points
1276      * change from L to BN.
1277      *
1278      * UCD.html version 4.0.1 does not yet reflect these changes.
1279      */
1280     if(type==U_UNASSIGNED || type==U_PRIVATE_USE_CHAR) {
1281         /* enumerate the intersections of defaultBidi ranges with [start..limit[ */
1282         c=start;
1283         for(i=0; i<UPRV_LENGTHOF(defaultBidi) && c<limit; ++i) {
1284             if((int32_t)c<defaultBidi[i][0]) {
1285                 while(c<limit && (int32_t)c<defaultBidi[i][0]) {
1286                     if(U_IS_UNICODE_NONCHAR(c) || u_hasBinaryProperty(c, UCHAR_DEFAULT_IGNORABLE_CODE_POINT)) {
1287                         shouldBeDir=U_BOUNDARY_NEUTRAL;
1288                     } else {
1289                         shouldBeDir=(UCharDirection)defaultBidi[i][1];
1290                     }
1291
1292                     if( u_charDirection(c)!=shouldBeDir ||
1293                         u_getIntPropertyValue(c, UCHAR_BIDI_CLASS)!=shouldBeDir
1294                     ) {
1295                         log_err("error: u_charDirection(unassigned/PUA U+%04lx)=%s should be %s\n",
1296                             c, dirStrings[u_charDirection(c)], dirStrings[shouldBeDir]);
1297                     }
1298                     ++c;
1299                 }
1300             }
1301         }
1302     }
1303
1304     return TRUE;
1305 }
1306
1307 /* tests for several properties */
1308 static void TestUnicodeData()
1309 {
1310     UVersionInfo expectVersionArray;
1311     UVersionInfo versionArray;
1312     char *fields[15][2];
1313     UErrorCode errorCode;
1314     UChar32 c;
1315     int8_t type;
1316
1317     UnicodeDataContext context;
1318
1319     u_versionFromString(expectVersionArray, U_UNICODE_VERSION);
1320     u_getUnicodeVersion(versionArray);
1321     if(memcmp(versionArray, expectVersionArray, U_MAX_VERSION_LENGTH) != 0)
1322     {
1323         log_err("Testing u_getUnicodeVersion() - expected " U_UNICODE_VERSION " got %d.%d.%d.%d\n",
1324         versionArray[0], versionArray[1], versionArray[2], versionArray[3]);
1325     }
1326
1327 #if defined(ICU_UNICODE_VERSION)
1328     /* test only happens where we have configure.in with UNICODE_VERSION - sanity check. */
1329     if(strcmp(U_UNICODE_VERSION, ICU_UNICODE_VERSION))
1330     {
1331          log_err("Testing configure.in's ICU_UNICODE_VERSION - expected " U_UNICODE_VERSION " got " ICU_UNICODE_VERSION "\n");
1332     }
1333 #endif
1334
1335     if (ublock_getCode((UChar)0x0041) != UBLOCK_BASIC_LATIN || u_getIntPropertyValue(0x41, UCHAR_BLOCK)!=(int32_t)UBLOCK_BASIC_LATIN) {
1336         log_err("ublock_getCode(U+0041) property failed! Expected : %i Got: %i \n", UBLOCK_BASIC_LATIN,ublock_getCode((UChar)0x0041));
1337     }
1338
1339     errorCode=U_ZERO_ERROR;
1340 #if !UCONFIG_NO_NORMALIZATION
1341     context.nfc=unorm2_getNFCInstance(&errorCode);
1342     context.nfkc=unorm2_getNFKCInstance(&errorCode);
1343     if(U_FAILURE(errorCode)) {
1344         log_data_err("error: unable to open an NFC or NFKC UNormalizer2 - %s\n", u_errorName(errorCode));
1345         return;
1346     }
1347 #endif
1348     parseUCDFile("UnicodeData.txt", fields, 15, unicodeDataLineFn, &context, &errorCode);
1349     if(U_FAILURE(errorCode)) {
1350         return; /* if we couldn't parse UnicodeData.txt, we should return */
1351     }
1352
1353     /* sanity check on repeated properties */
1354     for(c=0xfffe; c<=0x10ffff;) {
1355         type=u_charType(c);
1356         if((uint32_t)u_getIntPropertyValue(c, UCHAR_GENERAL_CATEGORY_MASK)!=U_MASK(type)) {
1357             log_err("error: (uint32_t)u_getIntPropertyValue(U+%04lx, UCHAR_GENERAL_CATEGORY_MASK)!=U_MASK(u_charType())\n", c);
1358         }
1359         if(type!=U_UNASSIGNED) {
1360             log_err("error: u_charType(U+%04lx)!=U_UNASSIGNED (returns %d)\n", c, u_charType(c));
1361         }
1362         if((c&0xffff)==0xfffe) {
1363             ++c;
1364         } else {
1365             c+=0xffff;
1366         }
1367     }
1368
1369     /* test that PUA is not "unassigned" */
1370     for(c=0xe000; c<=0x10fffd;) {
1371         type=u_charType(c);
1372         if((uint32_t)u_getIntPropertyValue(c, UCHAR_GENERAL_CATEGORY_MASK)!=U_MASK(type)) {
1373             log_err("error: (uint32_t)u_getIntPropertyValue(U+%04lx, UCHAR_GENERAL_CATEGORY_MASK)!=U_MASK(u_charType())\n", c);
1374         }
1375         if(type==U_UNASSIGNED) {
1376             log_err("error: u_charType(U+%04lx)==U_UNASSIGNED\n", c);
1377         } else if(type!=U_PRIVATE_USE_CHAR) {
1378             log_verbose("PUA override: u_charType(U+%04lx)=%d\n", c, type);
1379         }
1380         if(c==0xf8ff) {
1381             c=0xf0000;
1382         } else if(c==0xffffd) {
1383             c=0x100000;
1384         } else {
1385             ++c;
1386         }
1387     }
1388
1389     /* test u_enumCharTypes() */
1390     u_enumCharTypes(enumTypeRange, "a1");
1391
1392     /* check default properties */
1393     u_enumCharTypes(enumDefaultsRange, NULL);
1394 }
1395
1396 static void TestCodeUnit(){
1397     const UChar codeunit[]={0x0000,0xe065,0x20ac,0xd7ff,0xd800,0xd841,0xd905,0xdbff,0xdc00,0xdc02,0xddee,0xdfff,0};
1398
1399     int32_t i;
1400
1401     for(i=0; i<UPRV_LENGTHOF(codeunit); i++){
1402         UChar c=codeunit[i];
1403         if(i<4){
1404             if(!(UTF_IS_SINGLE(c)) || (UTF_IS_LEAD(c)) || (UTF_IS_TRAIL(c)) ||(UTF_IS_SURROGATE(c))){
1405                 log_err("ERROR: U+%04x is a single", c);
1406             }
1407
1408         }
1409         if(i >= 4 && i< 8){
1410             if(!(UTF_IS_LEAD(c)) || UTF_IS_SINGLE(c) || UTF_IS_TRAIL(c) || !(UTF_IS_SURROGATE(c))){
1411                 log_err("ERROR: U+%04x is a first surrogate", c);
1412             }
1413         }
1414         if(i >= 8 && i< 12){
1415             if(!(UTF_IS_TRAIL(c)) || UTF_IS_SINGLE(c) || UTF_IS_LEAD(c) || !(UTF_IS_SURROGATE(c))){
1416                 log_err("ERROR: U+%04x is a second surrogate", c);
1417             }
1418         }
1419     }
1420
1421 }
1422
1423 static void TestCodePoint(){
1424     const UChar32 codePoint[]={
1425         /*surrogate, notvalid(codepoint), not a UnicodeChar, not Error */
1426         0xd800,
1427         0xdbff,
1428         0xdc00,
1429         0xdfff,
1430         0xdc04,
1431         0xd821,
1432         /*not a surrogate, valid, isUnicodeChar , not Error*/
1433         0x20ac,
1434         0xd7ff,
1435         0xe000,
1436         0xe123,
1437         0x0061,
1438         0xe065,
1439         0x20402,
1440         0x24506,
1441         0x23456,
1442         0x20402,
1443         0x10402,
1444         0x23456,
1445         /*not a surrogate, not valid, isUnicodeChar, isError */
1446         0x0015,
1447         0x009f,
1448         /*not a surrogate, not valid, not isUnicodeChar, isError */
1449         0xffff,
1450         0xfffe,
1451     };
1452     int32_t i;
1453     for(i=0; i<UPRV_LENGTHOF(codePoint); i++){
1454         UChar32 c=codePoint[i];
1455         if(i<6){
1456             if(!UTF_IS_SURROGATE(c) || !U_IS_SURROGATE(c) || !U16_IS_SURROGATE(c)){
1457                 log_err("ERROR: isSurrogate() failed for U+%04x\n", c);
1458             }
1459             if(UTF_IS_VALID(c)){
1460                 log_err("ERROR: isValid() failed for U+%04x\n", c);
1461             }
1462             if(UTF_IS_UNICODE_CHAR(c) || U_IS_UNICODE_CHAR(c)){
1463                 log_err("ERROR: isUnicodeChar() failed for U+%04x\n", c);
1464             }
1465             if(UTF_IS_ERROR(c)){
1466                 log_err("ERROR: isError() failed for U+%04x\n", c);
1467             }
1468         }else if(i >=6 && i<18){
1469             if(UTF_IS_SURROGATE(c) || U_IS_SURROGATE(c) || U16_IS_SURROGATE(c)){
1470                 log_err("ERROR: isSurrogate() failed for U+%04x\n", c);
1471             }
1472             if(!UTF_IS_VALID(c)){
1473                 log_err("ERROR: isValid() failed for U+%04x\n", c);
1474             }
1475             if(!UTF_IS_UNICODE_CHAR(c) || !U_IS_UNICODE_CHAR(c)){
1476                 log_err("ERROR: isUnicodeChar() failed for U+%04x\n", c);
1477             }
1478             if(UTF_IS_ERROR(c)){
1479                 log_err("ERROR: isError() failed for U+%04x\n", c);
1480             }
1481         }else if(i >=18 && i<20){
1482             if(UTF_IS_SURROGATE(c) || U_IS_SURROGATE(c) || U16_IS_SURROGATE(c)){
1483                 log_err("ERROR: isSurrogate() failed for U+%04x\n", c);
1484             }
1485             if(UTF_IS_VALID(c)){
1486                 log_err("ERROR: isValid() failed for U+%04x\n", c);
1487             }
1488             if(!UTF_IS_UNICODE_CHAR(c) || !U_IS_UNICODE_CHAR(c)){
1489                 log_err("ERROR: isUnicodeChar() failed for U+%04x\n", c);
1490             }
1491             if(!UTF_IS_ERROR(c)){
1492                 log_err("ERROR: isError() failed for U+%04x\n", c);
1493             }
1494         }
1495         else if(i >=18 && i<UPRV_LENGTHOF(codePoint)){
1496             if(UTF_IS_SURROGATE(c) || U_IS_SURROGATE(c) || U16_IS_SURROGATE(c)){
1497                 log_err("ERROR: isSurrogate() failed for U+%04x\n", c);
1498             }
1499             if(UTF_IS_VALID(c)){
1500                 log_err("ERROR: isValid() failed for U+%04x\n", c);
1501             }
1502             if(UTF_IS_UNICODE_CHAR(c) || U_IS_UNICODE_CHAR(c)){
1503                 log_err("ERROR: isUnicodeChar() failed for U+%04x\n", c);
1504             }
1505             if(!UTF_IS_ERROR(c)){
1506                 log_err("ERROR: isError() failed for U+%04x\n", c);
1507             }
1508         }
1509     }
1510
1511     if(
1512         !U_IS_BMP(0) || !U_IS_BMP(0x61) || !U_IS_BMP(0x20ac) ||
1513         !U_IS_BMP(0xd9da) || !U_IS_BMP(0xdfed) || !U_IS_BMP(0xffff) ||
1514         U_IS_BMP(U_SENTINEL) || U_IS_BMP(0x10000) || U_IS_BMP(0x50005) ||
1515         U_IS_BMP(0x10ffff) || U_IS_BMP(0x110000) || U_IS_BMP(0x7fffffff)
1516     ) {
1517         log_err("error with U_IS_BMP()\n");
1518     }
1519
1520     if(
1521         U_IS_SUPPLEMENTARY(0) || U_IS_SUPPLEMENTARY(0x61) || U_IS_SUPPLEMENTARY(0x20ac) ||
1522         U_IS_SUPPLEMENTARY(0xd9da) || U_IS_SUPPLEMENTARY(0xdfed) || U_IS_SUPPLEMENTARY(0xffff) ||
1523         U_IS_SUPPLEMENTARY(U_SENTINEL) || !U_IS_SUPPLEMENTARY(0x10000) || !U_IS_SUPPLEMENTARY(0x50005) ||
1524         !U_IS_SUPPLEMENTARY(0x10ffff) || U_IS_SUPPLEMENTARY(0x110000) || U_IS_SUPPLEMENTARY(0x7fffffff)
1525     ) {
1526         log_err("error with U_IS_SUPPLEMENTARY()\n");
1527     }
1528 }
1529
1530 static void TestCharLength()
1531 {
1532     const int32_t codepoint[]={
1533         1, 0x0061,
1534         1, 0xe065,
1535         1, 0x20ac,
1536         2, 0x20402,
1537         2, 0x23456,
1538         2, 0x24506,
1539         2, 0x20402,
1540         2, 0x10402,
1541         1, 0xd7ff,
1542         1, 0xe000
1543     };
1544
1545     int32_t i;
1546     UBool multiple;
1547     for(i=0; i<UPRV_LENGTHOF(codepoint); i=(int16_t)(i+2)){
1548         UChar32 c=codepoint[i+1];
1549         if(UTF_CHAR_LENGTH(c) != codepoint[i] || U16_LENGTH(c) != codepoint[i]){
1550             log_err("The no: of code units for U+%04x:- Expected: %d Got: %d\n", c, codepoint[i], U16_LENGTH(c));
1551         }
1552         multiple=(UBool)(codepoint[i] == 1 ? FALSE : TRUE);
1553         if(UTF_NEED_MULTIPLE_UCHAR(c) != multiple){
1554             log_err("ERROR: Unicode::needMultipleUChar() failed for U+%04x\n", c);
1555         }
1556     }
1557 }
1558
1559 /*internal functions ----*/
1560 static int32_t MakeProp(char* str)
1561 {
1562     int32_t result = 0;
1563     char* matchPosition =0;
1564
1565     matchPosition = strstr(tagStrings, str);
1566     if (matchPosition == 0)
1567     {
1568         log_err("unrecognized type letter ");
1569         log_err(str);
1570     }
1571     else
1572         result = (int32_t)((matchPosition - tagStrings) / 2);
1573     return result;
1574 }
1575
1576 static int32_t MakeDir(char* str)
1577 {
1578     int32_t pos = 0;
1579     for (pos = 0; pos < U_CHAR_DIRECTION_COUNT; pos++) {
1580         if (strcmp(str, dirStrings[pos]) == 0) {
1581             return pos;
1582         }
1583     }
1584     return -1;
1585 }
1586
1587 /* test u_charName() -------------------------------------------------------- */
1588
1589 static const struct {
1590     uint32_t code;
1591     const char *name, *oldName, *extName, *alias;
1592 } names[]={
1593     {0x0061, "LATIN SMALL LETTER A", "", "LATIN SMALL LETTER A"},
1594     {0x01a2, "LATIN CAPITAL LETTER OI", "",
1595              "LATIN CAPITAL LETTER OI",
1596              "LATIN CAPITAL LETTER GHA"},
1597     {0x0284, "LATIN SMALL LETTER DOTLESS J WITH STROKE AND HOOK", "",
1598              "LATIN SMALL LETTER DOTLESS J WITH STROKE AND HOOK" },
1599     {0x0fd0, "TIBETAN MARK BSKA- SHOG GI MGO RGYAN", "",
1600              "TIBETAN MARK BSKA- SHOG GI MGO RGYAN",
1601              "TIBETAN MARK BKA- SHOG GI MGO RGYAN"},
1602     {0x3401, "CJK UNIFIED IDEOGRAPH-3401", "", "CJK UNIFIED IDEOGRAPH-3401" },
1603     {0x7fed, "CJK UNIFIED IDEOGRAPH-7FED", "", "CJK UNIFIED IDEOGRAPH-7FED" },
1604     {0xac00, "HANGUL SYLLABLE GA", "", "HANGUL SYLLABLE GA" },
1605     {0xd7a3, "HANGUL SYLLABLE HIH", "", "HANGUL SYLLABLE HIH" },
1606     {0xd800, "", "", "<lead surrogate-D800>" },
1607     {0xdc00, "", "", "<trail surrogate-DC00>" },
1608     {0xff08, "FULLWIDTH LEFT PARENTHESIS", "", "FULLWIDTH LEFT PARENTHESIS" },
1609     {0xffe5, "FULLWIDTH YEN SIGN", "", "FULLWIDTH YEN SIGN" },
1610     {0xffff, "", "", "<noncharacter-FFFF>" },
1611     {0x1d0c5, "BYZANTINE MUSICAL SYMBOL FHTORA SKLIRON CHROMA VASIS", "",
1612               "BYZANTINE MUSICAL SYMBOL FHTORA SKLIRON CHROMA VASIS",
1613               "BYZANTINE MUSICAL SYMBOL FTHORA SKLIRON CHROMA VASIS"},
1614     {0x23456, "CJK UNIFIED IDEOGRAPH-23456", "", "CJK UNIFIED IDEOGRAPH-23456" }
1615 };
1616
1617 static UBool
1618 enumCharNamesFn(void *context,
1619                 UChar32 code, UCharNameChoice nameChoice,
1620                 const char *name, int32_t length) {
1621     int32_t *pCount=(int32_t *)context;
1622     const char *expected;
1623     int i;
1624
1625     if(length<=0 || length!=(int32_t)strlen(name)) {
1626         /* should not be called with an empty string or invalid length */
1627         log_err("u_enumCharName(0x%lx)=%s but length=%ld\n", name, length);
1628         return TRUE;
1629     }
1630
1631     ++*pCount;
1632     for(i=0; i<UPRV_LENGTHOF(names); ++i) {
1633         if(code==(UChar32)names[i].code) {
1634             switch (nameChoice) {
1635                 case U_EXTENDED_CHAR_NAME:
1636                     if(0!=strcmp(name, names[i].extName)) {
1637                         log_err("u_enumCharName(0x%lx - Extended)=%s instead of %s\n", code, name, names[i].extName);
1638                     }
1639                     break;
1640                 case U_UNICODE_CHAR_NAME:
1641                     if(0!=strcmp(name, names[i].name)) {
1642                         log_err("u_enumCharName(0x%lx)=%s instead of %s\n", code, name, names[i].name);
1643                     }
1644                     break;
1645                 case U_UNICODE_10_CHAR_NAME:
1646                     expected=names[i].oldName;
1647                     if(expected[0]==0 || 0!=strcmp(name, expected)) {
1648                         log_err("u_enumCharName(0x%lx - 1.0)=%s instead of %s\n", code, name, expected);
1649                     }
1650                     break;
1651                 case U_CHAR_NAME_ALIAS:
1652                     expected=names[i].alias;
1653                     if(expected==NULL || expected[0]==0 || 0!=strcmp(name, expected)) {
1654                         log_err("u_enumCharName(0x%lx - alias)=%s instead of %s\n", code, name, expected);
1655                     }
1656                     break;
1657                 case U_CHAR_NAME_CHOICE_COUNT:
1658                     break;
1659             }
1660             break;
1661         }
1662     }
1663     return TRUE;
1664 }
1665
1666 struct enumExtCharNamesContext {
1667     uint32_t length;
1668     int32_t last;
1669 };
1670
1671 static UBool
1672 enumExtCharNamesFn(void *context,
1673                 UChar32 code, UCharNameChoice nameChoice,
1674                 const char *name, int32_t length) {
1675     struct enumExtCharNamesContext *ecncp = (struct enumExtCharNamesContext *) context;
1676
1677     if (ecncp->last != (int32_t) code - 1) {
1678         if (ecncp->last < 0) {
1679             log_err("u_enumCharName(0x%lx - Ext) after u_enumCharName(0x%lx - Ext) instead of u_enumCharName(0x%lx - Ext)\n", code, ecncp->last, ecncp->last + 1);
1680         } else {
1681             log_err("u_enumCharName(0x%lx - Ext) instead of u_enumCharName(0x0 - Ext)\n", code);
1682         }
1683     }
1684     ecncp->last = (int32_t) code;
1685
1686     if (!*name) {
1687         log_err("u_enumCharName(0x%lx - Ext) should not be an empty string\n", code);
1688     }
1689
1690     return enumCharNamesFn(&ecncp->length, code, nameChoice, name, length);
1691 }
1692
1693 /**
1694  * This can be made more efficient by moving it into putil.c and having
1695  * it directly access the ebcdic translation tables.
1696  * TODO: If we get this method in putil.c, then delete it from here.
1697  */
1698 static UChar
1699 u_charToUChar(char c) {
1700     UChar uc;
1701     u_charsToUChars(&c, &uc, 1);
1702     return uc;
1703 }
1704
1705 static void
1706 TestCharNames() {
1707     static char name[80];
1708     UErrorCode errorCode=U_ZERO_ERROR;
1709     struct enumExtCharNamesContext extContext;
1710     const char *expected;
1711     int32_t length;
1712     UChar32 c;
1713     int32_t i;
1714
1715     log_verbose("Testing uprv_getMaxCharNameLength()\n");
1716     length=uprv_getMaxCharNameLength();
1717     if(length==0) {
1718         /* no names data available */
1719         return;
1720     }
1721     if(length<83) { /* Unicode 3.2 max char name length */
1722         log_err("uprv_getMaxCharNameLength()=%d is too short");
1723     }
1724     /* ### TODO same tests for max ISO comment length as for max name length */
1725
1726     log_verbose("Testing u_charName()\n");
1727     for(i=0; i<UPRV_LENGTHOF(names); ++i) {
1728         /* modern Unicode character name */
1729         length=u_charName(names[i].code, U_UNICODE_CHAR_NAME, name, sizeof(name), &errorCode);
1730         if(U_FAILURE(errorCode)) {
1731             log_err("u_charName(0x%lx) error %s\n", names[i].code, u_errorName(errorCode));
1732             return;
1733         }
1734         if(length<0 || 0!=strcmp(name, names[i].name) || length!=(uint16_t)strlen(name)) {
1735             log_err("u_charName(0x%lx) gets: %s (length %ld) instead of: %s\n", names[i].code, name, length, names[i].name);
1736         }
1737
1738         /* find the modern name */
1739         if (*names[i].name) {
1740             c=u_charFromName(U_UNICODE_CHAR_NAME, names[i].name, &errorCode);
1741             if(U_FAILURE(errorCode)) {
1742                 log_err("u_charFromName(%s) error %s\n", names[i].name, u_errorName(errorCode));
1743                 return;
1744             }
1745             if(c!=(UChar32)names[i].code) {
1746                 log_err("u_charFromName(%s) gets 0x%lx instead of 0x%lx\n", names[i].name, c, names[i].code);
1747             }
1748         }
1749
1750         /* Unicode 1.0 character name */
1751         length=u_charName(names[i].code, U_UNICODE_10_CHAR_NAME, name, sizeof(name), &errorCode);
1752         if(U_FAILURE(errorCode)) {
1753             log_err("u_charName(0x%lx - 1.0) error %s\n", names[i].code, u_errorName(errorCode));
1754             return;
1755         }
1756         if(length<0 || (length>0 && 0!=strcmp(name, names[i].oldName)) || length!=(uint16_t)strlen(name)) {
1757             log_err("u_charName(0x%lx - 1.0) gets %s length %ld instead of nothing or %s\n", names[i].code, name, length, names[i].oldName);
1758         }
1759
1760         /* find the Unicode 1.0 name if it is stored (length>0 means that we could read it) */
1761         if(names[i].oldName[0]!=0 /* && length>0 */) {
1762             c=u_charFromName(U_UNICODE_10_CHAR_NAME, names[i].oldName, &errorCode);
1763             if(U_FAILURE(errorCode)) {
1764                 log_err("u_charFromName(%s - 1.0) error %s\n", names[i].oldName, u_errorName(errorCode));
1765                 return;
1766             }
1767             if(c!=(UChar32)names[i].code) {
1768                 log_err("u_charFromName(%s - 1.0) gets 0x%lx instead of 0x%lx\n", names[i].oldName, c, names[i].code);
1769             }
1770         }
1771
1772         /* Unicode character name alias */
1773         length=u_charName(names[i].code, U_CHAR_NAME_ALIAS, name, sizeof(name), &errorCode);
1774         if(U_FAILURE(errorCode)) {
1775             log_err("u_charName(0x%lx - alias) error %s\n", names[i].code, u_errorName(errorCode));
1776             return;
1777         }
1778         expected=names[i].alias;
1779         if(expected==NULL) {
1780             expected="";
1781         }
1782         if(length<0 || (length>0 && 0!=strcmp(name, expected)) || length!=(uint16_t)strlen(name)) {
1783             log_err("u_charName(0x%lx - alias) gets %s length %ld instead of nothing or %s\n",
1784                     names[i].code, name, length, expected);
1785         }
1786
1787         /* find the Unicode character name alias if it is stored (length>0 means that we could read it) */
1788         if(expected[0]!=0 /* && length>0 */) {
1789             c=u_charFromName(U_CHAR_NAME_ALIAS, expected, &errorCode);
1790             if(U_FAILURE(errorCode)) {
1791                 log_err("u_charFromName(%s - alias) error %s\n",
1792                         expected, u_errorName(errorCode));
1793                 return;
1794             }
1795             if(c!=(UChar32)names[i].code) {
1796                 log_err("u_charFromName(%s - alias) gets 0x%lx instead of 0x%lx\n",
1797                         expected, c, names[i].code);
1798             }
1799         }
1800     }
1801
1802     /* test u_enumCharNames() */
1803     length=0;
1804     errorCode=U_ZERO_ERROR;
1805     u_enumCharNames(UCHAR_MIN_VALUE, UCHAR_MAX_VALUE + 1, enumCharNamesFn, &length, U_UNICODE_CHAR_NAME, &errorCode);
1806     if(U_FAILURE(errorCode) || length<94140) {
1807         log_err("u_enumCharNames(%ld..%lx) error %s names count=%ld\n", UCHAR_MIN_VALUE, UCHAR_MAX_VALUE, u_errorName(errorCode), length);
1808     }
1809
1810     extContext.length = 0;
1811     extContext.last = -1;
1812     errorCode=U_ZERO_ERROR;
1813     u_enumCharNames(UCHAR_MIN_VALUE, UCHAR_MAX_VALUE + 1, enumExtCharNamesFn, &extContext, U_EXTENDED_CHAR_NAME, &errorCode);
1814     if(U_FAILURE(errorCode) || extContext.length<UCHAR_MAX_VALUE + 1) {
1815         log_err("u_enumCharNames(%ld..0x%lx - Extended) error %s names count=%ld\n", UCHAR_MIN_VALUE, UCHAR_MAX_VALUE + 1, u_errorName(errorCode), extContext.length);
1816     }
1817
1818     /* test that u_charFromName() uppercases the input name, i.e., works with mixed-case names (new in 2.0) */
1819     if(0x61!=u_charFromName(U_UNICODE_CHAR_NAME, "LATin smALl letTER A", &errorCode)) {
1820         log_err("u_charFromName(U_UNICODE_CHAR_NAME, \"LATin smALl letTER A\") did not find U+0061 (%s)\n", u_errorName(errorCode));
1821     }
1822
1823     /* Test getCharNameCharacters */
1824     if(!getTestOption(QUICK_OPTION)) {
1825         enum { BUFSIZE = 256 };
1826         UErrorCode ec = U_ZERO_ERROR;
1827         char buf[BUFSIZE];
1828         int32_t maxLength;
1829         UChar32 cp;
1830         UChar pat[BUFSIZE], dumbPat[BUFSIZE];
1831         int32_t l1, l2;
1832         UBool map[256];
1833         UBool ok;
1834
1835         USet* set = uset_open(1, 0); /* empty set */
1836         USet* dumb = uset_open(1, 0); /* empty set */
1837
1838         /*
1839          * uprv_getCharNameCharacters() will likely return more lowercase
1840          * letters than actual character names contain because
1841          * it includes all the characters in lowercased names of
1842          * general categories, for the full possible set of extended names.
1843          */
1844         {
1845             USetAdder sa={
1846                 NULL,
1847                 uset_add,
1848                 uset_addRange,
1849                 uset_addString,
1850                 NULL /* don't need remove() */
1851             };
1852             sa.set=set;
1853             uprv_getCharNameCharacters(&sa);
1854         }
1855
1856         /* build set the dumb (but sure-fire) way */
1857         for (i=0; i<256; ++i) {
1858             map[i] = FALSE;
1859         }
1860
1861         maxLength=0;
1862         for (cp=0; cp<0x110000; ++cp) {
1863             int32_t len = u_charName(cp, U_EXTENDED_CHAR_NAME,
1864                                      buf, BUFSIZE, &ec);
1865             if (U_FAILURE(ec)) {
1866                 log_err("FAIL: u_charName failed when it shouldn't\n");
1867                 uset_close(set);
1868                 uset_close(dumb);
1869                 return;
1870             }
1871             if(len>maxLength) {
1872                 maxLength=len;
1873             }
1874
1875             for (i=0; i<len; ++i) {
1876                 if (!map[(uint8_t) buf[i]]) {
1877                     uset_add(dumb, (UChar32)u_charToUChar(buf[i]));
1878                     map[(uint8_t) buf[i]] = TRUE;
1879                 }
1880             }
1881
1882             /* test for leading/trailing whitespace */
1883             if(buf[0]==' ' || buf[0]=='\t' || buf[len-1]==' ' || buf[len-1]=='\t') {
1884                 log_err("u_charName(U+%04x) returns a name with leading or trailing whitespace\n", cp);
1885             }
1886         }
1887
1888         if(map[(uint8_t)'\t']) {
1889             log_err("u_charName() returned a name with a TAB for some code point\n", cp);
1890         }
1891
1892         length=uprv_getMaxCharNameLength();
1893         if(length!=maxLength) {
1894             log_err("uprv_getMaxCharNameLength()=%d differs from the maximum length %d of all extended names\n",
1895                     length, maxLength);
1896         }
1897
1898         /* compare the sets.  Where is my uset_equals?!! */
1899         ok=TRUE;
1900         for(i=0; i<256; ++i) {
1901             if(uset_contains(set, i)!=uset_contains(dumb, i)) {
1902                 if(0x61<=i && i<=0x7a /* a-z */ && uset_contains(set, i) && !uset_contains(dumb, i)) {
1903                     /* ignore lowercase a-z that are in set but not in dumb */
1904                     ok=TRUE;
1905                 } else {
1906                     ok=FALSE;
1907                     break;
1908                 }
1909             }
1910         }
1911
1912         l1 = uset_toPattern(set, pat, BUFSIZE, TRUE, &ec);
1913         l2 = uset_toPattern(dumb, dumbPat, BUFSIZE, TRUE, &ec);
1914         if (U_FAILURE(ec)) {
1915             log_err("FAIL: uset_toPattern failed when it shouldn't\n");
1916             uset_close(set);
1917             uset_close(dumb);
1918             return;
1919         }
1920
1921         if (l1 >= BUFSIZE) {
1922             l1 = BUFSIZE-1;
1923             pat[l1] = 0;
1924         }
1925         if (l2 >= BUFSIZE) {
1926             l2 = BUFSIZE-1;
1927             dumbPat[l2] = 0;
1928         }
1929
1930         if (!ok) {
1931             log_err("FAIL: uprv_getCharNameCharacters() returned %s, expected %s (too many lowercase a-z are ok)\n",
1932                     aescstrdup(pat, l1), aescstrdup(dumbPat, l2));
1933         } else if(getTestOption(VERBOSITY_OPTION)) {
1934             log_verbose("Ok: uprv_getCharNameCharacters() returned %s\n", aescstrdup(pat, l1));
1935         }
1936
1937         uset_close(set);
1938         uset_close(dumb);
1939     }
1940
1941     /* ### TODO: test error cases and other interesting things */
1942 }
1943
1944 static void
1945 TestUCharFromNameUnderflow() {
1946     // Ticket #10889: Underflow crash when there is no dash.
1947     UErrorCode errorCode=U_ZERO_ERROR;
1948     UChar32 c=u_charFromName(U_EXTENDED_CHAR_NAME, "<NO BREAK SPACE>", &errorCode);
1949     if(U_SUCCESS(errorCode)) {
1950         log_err("u_charFromName(<NO BREAK SPACE>) = U+%04x but should fail - %s\n", c, u_errorName(errorCode));
1951     }
1952
1953     // Test related edge cases.
1954     errorCode=U_ZERO_ERROR;
1955     c=u_charFromName(U_EXTENDED_CHAR_NAME, "<-00a0>", &errorCode);
1956     if(U_SUCCESS(errorCode)) {
1957         log_err("u_charFromName(<-00a0>) = U+%04x but should fail - %s\n", c, u_errorName(errorCode));
1958     }
1959
1960     errorCode=U_ZERO_ERROR;
1961     c=u_charFromName(U_EXTENDED_CHAR_NAME, "<control->", &errorCode);
1962     if(U_SUCCESS(errorCode)) {
1963         log_err("u_charFromName(<control->) = U+%04x but should fail - %s\n", c, u_errorName(errorCode));
1964     }
1965
1966     errorCode=U_ZERO_ERROR;
1967     c=u_charFromName(U_EXTENDED_CHAR_NAME, "<control-111111>", &errorCode);
1968     if(U_SUCCESS(errorCode)) {
1969         log_err("u_charFromName(<control-111111>) = U+%04x but should fail - %s\n", c, u_errorName(errorCode));
1970     }
1971 }
1972
1973 /* test u_isMirrored() and u_charMirror() ----------------------------------- */
1974
1975 static void
1976 TestMirroring() {
1977     USet *set;
1978     UErrorCode errorCode;
1979
1980     UChar32 start, end, c2, c3;
1981     int32_t i;
1982
1983     U_STRING_DECL(mirroredPattern, "[:Bidi_Mirrored:]", 17);
1984
1985     U_STRING_INIT(mirroredPattern, "[:Bidi_Mirrored:]", 17);
1986
1987     log_verbose("Testing u_isMirrored()\n");
1988     if(!(u_isMirrored(0x28) && u_isMirrored(0xbb) && u_isMirrored(0x2045) && u_isMirrored(0x232a) &&
1989          !u_isMirrored(0x27) && !u_isMirrored(0x61) && !u_isMirrored(0x284) && !u_isMirrored(0x3400)
1990         )
1991     ) {
1992         log_err("u_isMirrored() does not work correctly\n");
1993     }
1994
1995     log_verbose("Testing u_charMirror()\n");
1996     if(!(u_charMirror(0x3c)==0x3e && u_charMirror(0x5d)==0x5b && u_charMirror(0x208d)==0x208e && u_charMirror(0x3017)==0x3016 &&
1997          u_charMirror(0xbb)==0xab && u_charMirror(0x2215)==0x29F5 && u_charMirror(0x29F5)==0x2215 && /* large delta between the code points */
1998          u_charMirror(0x2e)==0x2e && u_charMirror(0x6f3)==0x6f3 && u_charMirror(0x301c)==0x301c && u_charMirror(0xa4ab)==0xa4ab &&
1999          /* see Unicode Corrigendum #6 at http://www.unicode.org/versions/corrigendum6.html */
2000          u_charMirror(0x2018)==0x2018 && u_charMirror(0x201b)==0x201b && u_charMirror(0x301d)==0x301d
2001          )
2002     ) {
2003         log_err("u_charMirror() does not work correctly\n");
2004     }
2005
2006     /* verify that Bidi_Mirroring_Glyph roundtrips */
2007     errorCode=U_ZERO_ERROR;
2008     set=uset_openPattern(mirroredPattern, 17, &errorCode);
2009
2010     if (U_FAILURE(errorCode)) {
2011         log_data_err("uset_openPattern(mirroredPattern, 17, &errorCode) failed!\n");
2012     } else {
2013         for(i=0; 0==uset_getItem(set, i, &start, &end, NULL, 0, &errorCode); ++i) {
2014             do {
2015                 c2=u_charMirror(start);
2016                 c3=u_charMirror(c2);
2017                 if(c3!=start) {
2018                     log_err("u_charMirror() does not roundtrip: U+%04lx->U+%04lx->U+%04lx\n", (long)start, (long)c2, (long)c3);
2019                 }
2020                 c3=u_getBidiPairedBracket(start);
2021                 if(u_getIntPropertyValue(start, UCHAR_BIDI_PAIRED_BRACKET_TYPE)==U_BPT_NONE) {
2022                     if(c3!=start) {
2023                         log_err("u_getBidiPairedBracket(U+%04lx) != self for bpt(c)==None\n",
2024                                 (long)start);
2025                     }
2026                 } else {
2027                     if(c3!=c2) {
2028                         log_err("u_getBidiPairedBracket(U+%04lx) != U+%04lx = bmg(c)'\n",
2029                                 (long)start, (long)c2);
2030                     }
2031                 }
2032             } while(++start<=end);
2033         }
2034     }
2035
2036     uset_close(set);
2037 }
2038
2039
2040 struct RunTestData
2041 {
2042     const char *runText;
2043     UScriptCode runCode;
2044 };
2045
2046 typedef struct RunTestData RunTestData;
2047
2048 static void
2049 CheckScriptRuns(UScriptRun *scriptRun, int32_t *runStarts, const RunTestData *testData, int32_t nRuns,
2050                 const char *prefix)
2051 {
2052     int32_t run, runStart, runLimit;
2053     UScriptCode runCode;
2054
2055     /* iterate over all the runs */
2056     run = 0;
2057     while (uscript_nextRun(scriptRun, &runStart, &runLimit, &runCode)) {
2058         if (runStart != runStarts[run]) {
2059             log_err("%s: incorrect start offset for run %d: expected %d, got %d\n",
2060                 prefix, run, runStarts[run], runStart);
2061         }
2062
2063         if (runLimit != runStarts[run + 1]) {
2064             log_err("%s: incorrect limit offset for run %d: expected %d, got %d\n",
2065                 prefix, run, runStarts[run + 1], runLimit);
2066         }
2067
2068         if (runCode != testData[run].runCode) {
2069             log_err("%s: incorrect script for run %d: expected \"%s\", got \"%s\"\n",
2070                 prefix, run, uscript_getName(testData[run].runCode), uscript_getName(runCode));
2071         }
2072
2073         run += 1;
2074
2075         /* stop when we've seen all the runs we expect to see */
2076         if (run >= nRuns) {
2077             break;
2078         }
2079     }
2080
2081     /* Complain if we didn't see then number of runs we expected */
2082     if (run != nRuns) {
2083         log_err("%s: incorrect number of runs: expected %d, got %d\n", prefix, run, nRuns);
2084     }
2085 }
2086
2087 static void
2088 TestUScriptRunAPI()
2089 {
2090     static const RunTestData testData1[] = {
2091         {"\\u0020\\u0946\\u0939\\u093F\\u0928\\u094D\\u0926\\u0940\\u0020", USCRIPT_DEVANAGARI},
2092         {"\\u0627\\u0644\\u0639\\u0631\\u0628\\u064A\\u0629\\u0020", USCRIPT_ARABIC},
2093         {"\\u0420\\u0443\\u0441\\u0441\\u043A\\u0438\\u0439\\u0020", USCRIPT_CYRILLIC},
2094         {"English (", USCRIPT_LATIN},
2095         {"\\u0E44\\u0E17\\u0E22", USCRIPT_THAI},
2096         {") ", USCRIPT_LATIN},
2097         {"\\u6F22\\u5B75", USCRIPT_HAN},
2098         {"\\u3068\\u3072\\u3089\\u304C\\u306A\\u3068", USCRIPT_HIRAGANA},
2099         {"\\u30AB\\u30BF\\u30AB\\u30CA", USCRIPT_KATAKANA},
2100         {"\\U00010400\\U00010401\\U00010402\\U00010403", USCRIPT_DESERET}
2101     };
2102
2103     static const RunTestData testData2[] = {
2104        {"((((((((((abc))))))))))", USCRIPT_LATIN}
2105     };
2106
2107     static const struct {
2108       const RunTestData *testData;
2109       int32_t nRuns;
2110     } testDataEntries[] = {
2111         {testData1, UPRV_LENGTHOF(testData1)},
2112         {testData2, UPRV_LENGTHOF(testData2)}
2113     };
2114
2115     static const int32_t nTestEntries = UPRV_LENGTHOF(testDataEntries);
2116     int32_t testEntry;
2117
2118     for (testEntry = 0; testEntry < nTestEntries; testEntry += 1) {
2119         UChar testString[1024];
2120         int32_t runStarts[256];
2121         int32_t nTestRuns = testDataEntries[testEntry].nRuns;
2122         const RunTestData *testData = testDataEntries[testEntry].testData;
2123
2124         int32_t run, stringLimit;
2125         UScriptRun *scriptRun = NULL;
2126         UErrorCode err;
2127
2128         /*
2129          * Fill in the test string and the runStarts array.
2130          */
2131         stringLimit = 0;
2132         for (run = 0; run < nTestRuns; run += 1) {
2133             runStarts[run] = stringLimit;
2134             stringLimit += u_unescape(testData[run].runText, &testString[stringLimit], 1024 - stringLimit);
2135             /*stringLimit -= 1;*/
2136         }
2137
2138         /* The limit of the last run */
2139         runStarts[nTestRuns] = stringLimit;
2140
2141         /*
2142          * Make sure that calling uscript_OpenRun with a NULL text pointer
2143          * and a non-zero text length returns the correct error.
2144          */
2145         err = U_ZERO_ERROR;
2146         scriptRun = uscript_openRun(NULL, stringLimit, &err);
2147
2148         if (err != U_ILLEGAL_ARGUMENT_ERROR) {
2149             log_err("uscript_openRun(NULL, stringLimit, &err) returned %s instead of U_ILLEGAL_ARGUMENT_ERROR.\n", u_errorName(err));
2150         }
2151
2152         if (scriptRun != NULL) {
2153             log_err("uscript_openRun(NULL, stringLimit, &err) returned a non-NULL result.\n");
2154             uscript_closeRun(scriptRun);
2155         }
2156
2157         /*
2158          * Make sure that calling uscript_OpenRun with a non-NULL text pointer
2159          * and a zero text length returns the correct error.
2160          */
2161         err = U_ZERO_ERROR;
2162         scriptRun = uscript_openRun(testString, 0, &err);
2163
2164         if (err != U_ILLEGAL_ARGUMENT_ERROR) {
2165             log_err("uscript_openRun(testString, 0, &err) returned %s instead of U_ILLEGAL_ARGUMENT_ERROR.\n", u_errorName(err));
2166         }
2167
2168         if (scriptRun != NULL) {
2169             log_err("uscript_openRun(testString, 0, &err) returned a non-NULL result.\n");
2170             uscript_closeRun(scriptRun);
2171         }
2172
2173         /*
2174          * Make sure that calling uscript_openRun with a NULL text pointer
2175          * and a zero text length doesn't return an error.
2176          */
2177         err = U_ZERO_ERROR;
2178         scriptRun = uscript_openRun(NULL, 0, &err);
2179
2180         if (U_FAILURE(err)) {
2181             log_err("Got error %s from uscript_openRun(NULL, 0, &err)\n", u_errorName(err));
2182         }
2183
2184         /* Make sure that the empty iterator doesn't find any runs */
2185         if (uscript_nextRun(scriptRun, NULL, NULL, NULL)) {
2186             log_err("uscript_nextRun(...) returned TRUE for an empty iterator.\n");
2187         }
2188
2189         /*
2190          * Make sure that calling uscript_setRunText with a NULL text pointer
2191          * and a non-zero text length returns the correct error.
2192          */
2193         err = U_ZERO_ERROR;
2194         uscript_setRunText(scriptRun, NULL, stringLimit, &err);
2195
2196         if (err != U_ILLEGAL_ARGUMENT_ERROR) {
2197             log_err("uscript_setRunText(scriptRun, NULL, stringLimit, &err) returned %s instead of U_ILLEGAL_ARGUMENT_ERROR.\n", u_errorName(err));
2198         }
2199
2200         /*
2201          * Make sure that calling uscript_OpenRun with a non-NULL text pointer
2202          * and a zero text length returns the correct error.
2203          */
2204         err = U_ZERO_ERROR;
2205         uscript_setRunText(scriptRun, testString, 0, &err);
2206
2207         if (err != U_ILLEGAL_ARGUMENT_ERROR) {
2208             log_err("uscript_setRunText(scriptRun, testString, 0, &err) returned %s instead of U_ILLEGAL_ARGUMENT_ERROR.\n", u_errorName(err));
2209         }
2210
2211         /*
2212          * Now call uscript_setRunText on the empty iterator
2213          * and make sure that it works.
2214          */
2215         err = U_ZERO_ERROR;
2216         uscript_setRunText(scriptRun, testString, stringLimit, &err);
2217
2218         if (U_FAILURE(err)) {
2219             log_err("Got error %s from uscript_setRunText(...)\n", u_errorName(err));
2220         } else {
2221             CheckScriptRuns(scriptRun, runStarts, testData, nTestRuns, "uscript_setRunText");
2222         }
2223
2224         uscript_closeRun(scriptRun);
2225
2226         /*
2227          * Now open an interator over the testString
2228          * using uscript_openRun and make sure that it works
2229          */
2230         scriptRun = uscript_openRun(testString, stringLimit, &err);
2231
2232         if (U_FAILURE(err)) {
2233             log_err("Got error %s from uscript_openRun(...)\n", u_errorName(err));
2234         } else {
2235             CheckScriptRuns(scriptRun, runStarts, testData, nTestRuns, "uscript_openRun");
2236         }
2237
2238         /* Now reset the iterator, and make sure
2239          * that it still works.
2240          */
2241         uscript_resetRun(scriptRun);
2242
2243         CheckScriptRuns(scriptRun, runStarts, testData, nTestRuns, "uscript_resetRun");
2244
2245         /* Close the iterator */
2246         uscript_closeRun(scriptRun);
2247     }
2248 }
2249
2250 /* test additional, non-core properties */
2251 static void
2252 TestAdditionalProperties() {
2253     /* test data for u_charAge() */
2254     static const struct {
2255         UChar32 c;
2256         UVersionInfo version;
2257     } charAges[]={
2258         {0x41,    { 1, 1, 0, 0 }},
2259         {0xffff,  { 1, 1, 0, 0 }},
2260         {0x20ab,  { 2, 0, 0, 0 }},
2261         {0x2fffe, { 2, 0, 0, 0 }},
2262         {0x20ac,  { 2, 1, 0, 0 }},
2263         {0xfb1d,  { 3, 0, 0, 0 }},
2264         {0x3f4,   { 3, 1, 0, 0 }},
2265         {0x10300, { 3, 1, 0, 0 }},
2266         {0x220,   { 3, 2, 0, 0 }},
2267         {0xff60,  { 3, 2, 0, 0 }}
2268     };
2269
2270     /* test data for u_hasBinaryProperty() */
2271     static const int32_t
2272     props[][3]={ /* code point, property, value */
2273         { 0x0627, UCHAR_ALPHABETIC, TRUE },
2274         { 0x1034a, UCHAR_ALPHABETIC, TRUE },
2275         { 0x2028, UCHAR_ALPHABETIC, FALSE },
2276
2277         { 0x0066, UCHAR_ASCII_HEX_DIGIT, TRUE },
2278         { 0x0067, UCHAR_ASCII_HEX_DIGIT, FALSE },
2279
2280         { 0x202c, UCHAR_BIDI_CONTROL, TRUE },
2281         { 0x202f, UCHAR_BIDI_CONTROL, FALSE },
2282
2283         { 0x003c, UCHAR_BIDI_MIRRORED, TRUE },
2284         { 0x003d, UCHAR_BIDI_MIRRORED, FALSE },
2285
2286         /* see Unicode Corrigendum #6 at http://www.unicode.org/versions/corrigendum6.html */
2287         { 0x2018, UCHAR_BIDI_MIRRORED, FALSE },
2288         { 0x201d, UCHAR_BIDI_MIRRORED, FALSE },
2289         { 0x201f, UCHAR_BIDI_MIRRORED, FALSE },
2290         { 0x301e, UCHAR_BIDI_MIRRORED, FALSE },
2291
2292         { 0x058a, UCHAR_DASH, TRUE },
2293         { 0x007e, UCHAR_DASH, FALSE },
2294
2295         { 0x0c4d, UCHAR_DIACRITIC, TRUE },
2296         { 0x3000, UCHAR_DIACRITIC, FALSE },
2297
2298         { 0x0e46, UCHAR_EXTENDER, TRUE },
2299         { 0x0020, UCHAR_EXTENDER, FALSE },
2300
2301 #if !UCONFIG_NO_NORMALIZATION
2302         { 0xfb1d, UCHAR_FULL_COMPOSITION_EXCLUSION, TRUE },
2303         { 0x1d15f, UCHAR_FULL_COMPOSITION_EXCLUSION, TRUE },
2304         { 0xfb1e, UCHAR_FULL_COMPOSITION_EXCLUSION, FALSE },
2305
2306         { 0x110a, UCHAR_NFD_INERT, TRUE },      /* Jamo L */
2307         { 0x0308, UCHAR_NFD_INERT, FALSE },
2308
2309         { 0x1164, UCHAR_NFKD_INERT, TRUE },     /* Jamo V */
2310         { 0x1d79d, UCHAR_NFKD_INERT, FALSE },   /* math compat version of xi */
2311
2312         { 0x0021, UCHAR_NFC_INERT, TRUE },      /* ! */
2313         { 0x0061, UCHAR_NFC_INERT, FALSE },     /* a */
2314         { 0x00e4, UCHAR_NFC_INERT, FALSE },     /* a-umlaut */
2315         { 0x0102, UCHAR_NFC_INERT, FALSE },     /* a-breve */
2316         { 0xac1c, UCHAR_NFC_INERT, FALSE },     /* Hangul LV */
2317         { 0xac1d, UCHAR_NFC_INERT, TRUE },      /* Hangul LVT */
2318
2319         { 0x1d79d, UCHAR_NFKC_INERT, FALSE },   /* math compat version of xi */
2320         { 0x2a6d6, UCHAR_NFKC_INERT, TRUE },    /* Han, last of CJK ext. B */
2321
2322         { 0x00e4, UCHAR_SEGMENT_STARTER, TRUE },
2323         { 0x0308, UCHAR_SEGMENT_STARTER, FALSE },
2324         { 0x110a, UCHAR_SEGMENT_STARTER, TRUE }, /* Jamo L */
2325         { 0x1164, UCHAR_SEGMENT_STARTER, FALSE },/* Jamo V */
2326         { 0xac1c, UCHAR_SEGMENT_STARTER, TRUE }, /* Hangul LV */
2327         { 0xac1d, UCHAR_SEGMENT_STARTER, TRUE }, /* Hangul LVT */
2328 #endif
2329
2330         { 0x0044, UCHAR_HEX_DIGIT, TRUE },
2331         { 0xff46, UCHAR_HEX_DIGIT, TRUE },
2332         { 0x0047, UCHAR_HEX_DIGIT, FALSE },
2333
2334         { 0x30fb, UCHAR_HYPHEN, TRUE },
2335         { 0xfe58, UCHAR_HYPHEN, FALSE },
2336
2337         { 0x2172, UCHAR_ID_CONTINUE, TRUE },
2338         { 0x0307, UCHAR_ID_CONTINUE, TRUE },
2339         { 0x005c, UCHAR_ID_CONTINUE, FALSE },
2340
2341         { 0x2172, UCHAR_ID_START, TRUE },
2342         { 0x007a, UCHAR_ID_START, TRUE },
2343         { 0x0039, UCHAR_ID_START, FALSE },
2344
2345         { 0x4db5, UCHAR_IDEOGRAPHIC, TRUE },
2346         { 0x2f999, UCHAR_IDEOGRAPHIC, TRUE },
2347         { 0x2f99, UCHAR_IDEOGRAPHIC, FALSE },
2348
2349         { 0x200c, UCHAR_JOIN_CONTROL, TRUE },
2350         { 0x2029, UCHAR_JOIN_CONTROL, FALSE },
2351
2352         { 0x1d7bc, UCHAR_LOWERCASE, TRUE },
2353         { 0x0345, UCHAR_LOWERCASE, TRUE },
2354         { 0x0030, UCHAR_LOWERCASE, FALSE },
2355
2356         { 0x1d7a9, UCHAR_MATH, TRUE },
2357         { 0x2135, UCHAR_MATH, TRUE },
2358         { 0x0062, UCHAR_MATH, FALSE },
2359
2360         { 0xfde1, UCHAR_NONCHARACTER_CODE_POINT, TRUE },
2361         { 0x10ffff, UCHAR_NONCHARACTER_CODE_POINT, TRUE },
2362         { 0x10fffd, UCHAR_NONCHARACTER_CODE_POINT, FALSE },
2363
2364         { 0x0022, UCHAR_QUOTATION_MARK, TRUE },
2365         { 0xff62, UCHAR_QUOTATION_MARK, TRUE },
2366         { 0xd840, UCHAR_QUOTATION_MARK, FALSE },
2367
2368         { 0x061f, UCHAR_TERMINAL_PUNCTUATION, TRUE },
2369         { 0xe003f, UCHAR_TERMINAL_PUNCTUATION, FALSE },
2370
2371         { 0x1d44a, UCHAR_UPPERCASE, TRUE },
2372         { 0x2162, UCHAR_UPPERCASE, TRUE },
2373         { 0x0345, UCHAR_UPPERCASE, FALSE },
2374
2375         { 0x0020, UCHAR_WHITE_SPACE, TRUE },
2376         { 0x202f, UCHAR_WHITE_SPACE, TRUE },
2377         { 0x3001, UCHAR_WHITE_SPACE, FALSE },
2378
2379         { 0x0711, UCHAR_XID_CONTINUE, TRUE },
2380         { 0x1d1aa, UCHAR_XID_CONTINUE, TRUE },
2381         { 0x007c, UCHAR_XID_CONTINUE, FALSE },
2382
2383         { 0x16ee, UCHAR_XID_START, TRUE },
2384         { 0x23456, UCHAR_XID_START, TRUE },
2385         { 0x1d1aa, UCHAR_XID_START, FALSE },
2386
2387         /*
2388          * Version break:
2389          * The following properties are only supported starting with the
2390          * Unicode version indicated in the second field.
2391          */
2392         { -1, 0x320, 0 },
2393
2394         { 0x180c, UCHAR_DEFAULT_IGNORABLE_CODE_POINT, TRUE },
2395         { 0xfe02, UCHAR_DEFAULT_IGNORABLE_CODE_POINT, TRUE },
2396         { 0x1801, UCHAR_DEFAULT_IGNORABLE_CODE_POINT, FALSE },
2397
2398         { 0x0149, UCHAR_DEPRECATED, TRUE },         /* changed in Unicode 5.2 */
2399         { 0x0341, UCHAR_DEPRECATED, FALSE },        /* changed in Unicode 5.2 */
2400         { 0xe0001, UCHAR_DEPRECATED, TRUE },        /* changed from Unicode 5 to 5.1 */
2401         { 0xe0100, UCHAR_DEPRECATED, FALSE },
2402
2403         { 0x00a0, UCHAR_GRAPHEME_BASE, TRUE },
2404         { 0x0a4d, UCHAR_GRAPHEME_BASE, FALSE },
2405         { 0xff9d, UCHAR_GRAPHEME_BASE, TRUE },
2406         { 0xff9f, UCHAR_GRAPHEME_BASE, FALSE },     /* changed from Unicode 3.2 to 4 and again from 5 to 5.1 */
2407
2408         { 0x0300, UCHAR_GRAPHEME_EXTEND, TRUE },
2409         { 0xff9d, UCHAR_GRAPHEME_EXTEND, FALSE },
2410         { 0xff9f, UCHAR_GRAPHEME_EXTEND, TRUE },    /* changed from Unicode 3.2 to 4 and again from 5 to 5.1 */
2411         { 0x0603, UCHAR_GRAPHEME_EXTEND, FALSE },
2412
2413         { 0x0a4d, UCHAR_GRAPHEME_LINK, TRUE },
2414         { 0xff9f, UCHAR_GRAPHEME_LINK, FALSE },
2415
2416         { 0x2ff7, UCHAR_IDS_BINARY_OPERATOR, TRUE },
2417         { 0x2ff3, UCHAR_IDS_BINARY_OPERATOR, FALSE },
2418
2419         { 0x2ff3, UCHAR_IDS_TRINARY_OPERATOR, TRUE },
2420         { 0x2f03, UCHAR_IDS_TRINARY_OPERATOR, FALSE },
2421
2422         { 0x0ec1, UCHAR_LOGICAL_ORDER_EXCEPTION, TRUE },
2423         { 0xdcba, UCHAR_LOGICAL_ORDER_EXCEPTION, FALSE },
2424
2425         { 0x2e9b, UCHAR_RADICAL, TRUE },
2426         { 0x4e00, UCHAR_RADICAL, FALSE },
2427
2428         { 0x012f, UCHAR_SOFT_DOTTED, TRUE },
2429         { 0x0049, UCHAR_SOFT_DOTTED, FALSE },
2430
2431         { 0xfa11, UCHAR_UNIFIED_IDEOGRAPH, TRUE },
2432         { 0xfa12, UCHAR_UNIFIED_IDEOGRAPH, FALSE },
2433
2434         { -1, 0x401, 0 }, /* version break for Unicode 4.0.1 */
2435
2436         { 0x002e, UCHAR_S_TERM, TRUE },
2437         { 0x0061, UCHAR_S_TERM, FALSE },
2438
2439         { 0x180c, UCHAR_VARIATION_SELECTOR, TRUE },
2440         { 0xfe03, UCHAR_VARIATION_SELECTOR, TRUE },
2441         { 0xe01ef, UCHAR_VARIATION_SELECTOR, TRUE },
2442         { 0xe0200, UCHAR_VARIATION_SELECTOR, FALSE },
2443
2444         /* enum/integer type properties */
2445
2446         /* UCHAR_BIDI_CLASS tested for assigned characters in TestUnicodeData() */
2447         /* test default Bidi classes for unassigned code points */
2448         { 0x0590, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT },
2449         { 0x05cf, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT },
2450         { 0x05ed, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT },
2451         { 0x07f2, UCHAR_BIDI_CLASS, U_DIR_NON_SPACING_MARK }, /* Nko, new in Unicode 5.0 */
2452         { 0x07fe, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT }, /* unassigned R */
2453         { 0x089f, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT },
2454         { 0xfb37, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT },
2455         { 0xfb42, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT },
2456         { 0x10806, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT },
2457         { 0x10909, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT },
2458         { 0x10fe4, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT },
2459
2460         { 0x061d, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT_ARABIC },
2461         { 0x063f, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT_ARABIC },
2462         { 0x070e, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT_ARABIC },
2463         { 0x0775, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT_ARABIC },
2464         { 0xfbc2, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT_ARABIC },
2465         { 0xfd90, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT_ARABIC },
2466         { 0xfefe, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT_ARABIC },
2467
2468         { 0x02AF, UCHAR_BLOCK, UBLOCK_IPA_EXTENSIONS },
2469         { 0x0C4E, UCHAR_BLOCK, UBLOCK_TELUGU },
2470         { 0x155A, UCHAR_BLOCK, UBLOCK_UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS },
2471         { 0x1717, UCHAR_BLOCK, UBLOCK_TAGALOG },
2472         { 0x1900, UCHAR_BLOCK, UBLOCK_LIMBU },
2473         { 0x1CBF, UCHAR_BLOCK, UBLOCK_NO_BLOCK },
2474         { 0x3040, UCHAR_BLOCK, UBLOCK_HIRAGANA },
2475         { 0x1D0FF, UCHAR_BLOCK, UBLOCK_BYZANTINE_MUSICAL_SYMBOLS },
2476         { 0x50000, UCHAR_BLOCK, UBLOCK_NO_BLOCK },
2477         { 0xEFFFF, UCHAR_BLOCK, UBLOCK_NO_BLOCK },
2478         { 0x10D0FF, UCHAR_BLOCK, UBLOCK_SUPPLEMENTARY_PRIVATE_USE_AREA_B },
2479
2480         /* UCHAR_CANONICAL_COMBINING_CLASS tested for assigned characters in TestUnicodeData() */
2481         { 0xd7d7, UCHAR_CANONICAL_COMBINING_CLASS, 0 },
2482
2483         { 0x00A0, UCHAR_DECOMPOSITION_TYPE, U_DT_NOBREAK },
2484         { 0x00A8, UCHAR_DECOMPOSITION_TYPE, U_DT_COMPAT },
2485         { 0x00bf, UCHAR_DECOMPOSITION_TYPE, U_DT_NONE },
2486         { 0x00c0, UCHAR_DECOMPOSITION_TYPE, U_DT_CANONICAL },
2487         { 0x1E9B, UCHAR_DECOMPOSITION_TYPE, U_DT_CANONICAL },
2488         { 0xBCDE, UCHAR_DECOMPOSITION_TYPE, U_DT_CANONICAL },
2489         { 0xFB5D, UCHAR_DECOMPOSITION_TYPE, U_DT_MEDIAL },
2490         { 0x1D736, UCHAR_DECOMPOSITION_TYPE, U_DT_FONT },
2491         { 0xe0033, UCHAR_DECOMPOSITION_TYPE, U_DT_NONE },
2492
2493         { 0x0009, UCHAR_EAST_ASIAN_WIDTH, U_EA_NEUTRAL },
2494         { 0x0020, UCHAR_EAST_ASIAN_WIDTH, U_EA_NARROW },
2495         { 0x00B1, UCHAR_EAST_ASIAN_WIDTH, U_EA_AMBIGUOUS },
2496         { 0x20A9, UCHAR_EAST_ASIAN_WIDTH, U_EA_HALFWIDTH },
2497         { 0x2FFB, UCHAR_EAST_ASIAN_WIDTH, U_EA_WIDE },
2498         { 0x3000, UCHAR_EAST_ASIAN_WIDTH, U_EA_FULLWIDTH },
2499         { 0x35bb, UCHAR_EAST_ASIAN_WIDTH, U_EA_WIDE },
2500         { 0x58bd, UCHAR_EAST_ASIAN_WIDTH, U_EA_WIDE },
2501         { 0xD7A3, UCHAR_EAST_ASIAN_WIDTH, U_EA_WIDE },
2502         { 0xEEEE, UCHAR_EAST_ASIAN_WIDTH, U_EA_AMBIGUOUS },
2503         { 0x1D198, UCHAR_EAST_ASIAN_WIDTH, U_EA_NEUTRAL },
2504         { 0x20000, UCHAR_EAST_ASIAN_WIDTH, U_EA_WIDE },
2505         { 0x2F8C7, UCHAR_EAST_ASIAN_WIDTH, U_EA_WIDE },
2506         { 0x3a5bd, UCHAR_EAST_ASIAN_WIDTH, U_EA_WIDE }, /* plane 3 got default W values in Unicode 4 */
2507         { 0x5a5bd, UCHAR_EAST_ASIAN_WIDTH, U_EA_NEUTRAL },
2508         { 0xFEEEE, UCHAR_EAST_ASIAN_WIDTH, U_EA_AMBIGUOUS },
2509         { 0x10EEEE, UCHAR_EAST_ASIAN_WIDTH, U_EA_AMBIGUOUS },
2510
2511         /* UCHAR_GENERAL_CATEGORY tested for assigned characters in TestUnicodeData() */
2512         { 0xd7c7, UCHAR_GENERAL_CATEGORY, 0 },
2513         { 0xd7d7, UCHAR_GENERAL_CATEGORY, U_OTHER_LETTER },     /* changed in Unicode 5.2 */
2514
2515         { 0x0444, UCHAR_JOINING_GROUP, U_JG_NO_JOINING_GROUP },
2516         { 0x0639, UCHAR_JOINING_GROUP, U_JG_AIN },
2517         { 0x072A, UCHAR_JOINING_GROUP, U_JG_DALATH_RISH },
2518         { 0x0647, UCHAR_JOINING_GROUP, U_JG_HEH },
2519         { 0x06C1, UCHAR_JOINING_GROUP, U_JG_HEH_GOAL },
2520
2521         { 0x200C, UCHAR_JOINING_TYPE, U_JT_NON_JOINING },
2522         { 0x200D, UCHAR_JOINING_TYPE, U_JT_JOIN_CAUSING },
2523         { 0x0639, UCHAR_JOINING_TYPE, U_JT_DUAL_JOINING },
2524         { 0x0640, UCHAR_JOINING_TYPE, U_JT_JOIN_CAUSING },
2525         { 0x06C3, UCHAR_JOINING_TYPE, U_JT_RIGHT_JOINING },
2526         { 0x0300, UCHAR_JOINING_TYPE, U_JT_TRANSPARENT },
2527         { 0x070F, UCHAR_JOINING_TYPE, U_JT_TRANSPARENT },
2528         { 0xe0033, UCHAR_JOINING_TYPE, U_JT_TRANSPARENT },
2529
2530         /* TestUnicodeData() verifies that no assigned character has "XX" (unknown) */
2531         { 0xe7e7, UCHAR_LINE_BREAK, U_LB_UNKNOWN },
2532         { 0x10fffd, UCHAR_LINE_BREAK, U_LB_UNKNOWN },
2533         { 0x0028, UCHAR_LINE_BREAK, U_LB_OPEN_PUNCTUATION },
2534         { 0x232A, UCHAR_LINE_BREAK, U_LB_CLOSE_PUNCTUATION },
2535         { 0x3401, UCHAR_LINE_BREAK, U_LB_IDEOGRAPHIC },
2536         { 0x4e02, UCHAR_LINE_BREAK, U_LB_IDEOGRAPHIC },
2537         { 0x20004, UCHAR_LINE_BREAK, U_LB_IDEOGRAPHIC },
2538         { 0xf905, UCHAR_LINE_BREAK, U_LB_IDEOGRAPHIC },
2539         { 0xdb7e, UCHAR_LINE_BREAK, U_LB_SURROGATE },
2540         { 0xdbfd, UCHAR_LINE_BREAK, U_LB_SURROGATE },
2541         { 0xdffc, UCHAR_LINE_BREAK, U_LB_SURROGATE },
2542         { 0x2762, UCHAR_LINE_BREAK, U_LB_EXCLAMATION },
2543         { 0x002F, UCHAR_LINE_BREAK, U_LB_BREAK_SYMBOLS },
2544         { 0x1D49C, UCHAR_LINE_BREAK, U_LB_ALPHABETIC },
2545         { 0x1731, UCHAR_LINE_BREAK, U_LB_ALPHABETIC },
2546
2547         /* UCHAR_NUMERIC_TYPE tested in TestNumericProperties() */
2548
2549         /* UCHAR_SCRIPT tested in TestUScriptCodeAPI() */
2550
2551         { 0x10ff, UCHAR_HANGUL_SYLLABLE_TYPE, 0 },
2552         { 0x1100, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LEADING_JAMO },
2553         { 0x1111, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LEADING_JAMO },
2554         { 0x1159, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LEADING_JAMO },
2555         { 0x115a, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LEADING_JAMO },     /* changed in Unicode 5.2 */
2556         { 0x115e, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LEADING_JAMO },     /* changed in Unicode 5.2 */
2557         { 0x115f, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LEADING_JAMO },
2558
2559         { 0xa95f, UCHAR_HANGUL_SYLLABLE_TYPE, 0 },
2560         { 0xa960, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LEADING_JAMO },     /* changed in Unicode 5.2 */
2561         { 0xa97c, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LEADING_JAMO },     /* changed in Unicode 5.2 */
2562         { 0xa97d, UCHAR_HANGUL_SYLLABLE_TYPE, 0 },
2563
2564         { 0x1160, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_VOWEL_JAMO },
2565         { 0x1161, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_VOWEL_JAMO },
2566         { 0x1172, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_VOWEL_JAMO },
2567         { 0x11a2, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_VOWEL_JAMO },
2568         { 0x11a3, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_VOWEL_JAMO },       /* changed in Unicode 5.2 */
2569         { 0x11a7, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_VOWEL_JAMO },       /* changed in Unicode 5.2 */
2570
2571         { 0xd7af, UCHAR_HANGUL_SYLLABLE_TYPE, 0 },
2572         { 0xd7b0, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_VOWEL_JAMO },       /* changed in Unicode 5.2 */
2573         { 0xd7c6, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_VOWEL_JAMO },       /* changed in Unicode 5.2 */
2574         { 0xd7c7, UCHAR_HANGUL_SYLLABLE_TYPE, 0 },
2575
2576         { 0x11a8, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_TRAILING_JAMO },
2577         { 0x11b8, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_TRAILING_JAMO },
2578         { 0x11c8, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_TRAILING_JAMO },
2579         { 0x11f9, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_TRAILING_JAMO },
2580         { 0x11fa, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_TRAILING_JAMO },    /* changed in Unicode 5.2 */
2581         { 0x11ff, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_TRAILING_JAMO },    /* changed in Unicode 5.2 */
2582         { 0x1200, UCHAR_HANGUL_SYLLABLE_TYPE, 0 },
2583
2584         { 0xd7ca, UCHAR_HANGUL_SYLLABLE_TYPE, 0 },
2585         { 0xd7cb, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_TRAILING_JAMO },    /* changed in Unicode 5.2 */
2586         { 0xd7fb, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_TRAILING_JAMO },    /* changed in Unicode 5.2 */
2587         { 0xd7fc, UCHAR_HANGUL_SYLLABLE_TYPE, 0 },
2588
2589         { 0xac00, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LV_SYLLABLE },
2590         { 0xac1c, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LV_SYLLABLE },
2591         { 0xc5ec, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LV_SYLLABLE },
2592         { 0xd788, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LV_SYLLABLE },
2593
2594         { 0xac01, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LVT_SYLLABLE },
2595         { 0xac1b, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LVT_SYLLABLE },
2596         { 0xac1d, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LVT_SYLLABLE },
2597         { 0xc5ee, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LVT_SYLLABLE },
2598         { 0xd7a3, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LVT_SYLLABLE },
2599
2600         { 0xd7a4, UCHAR_HANGUL_SYLLABLE_TYPE, 0 },
2601
2602         { -1, 0x410, 0 }, /* version break for Unicode 4.1 */
2603
2604         { 0x00d7, UCHAR_PATTERN_SYNTAX, TRUE },
2605         { 0xfe45, UCHAR_PATTERN_SYNTAX, TRUE },
2606         { 0x0061, UCHAR_PATTERN_SYNTAX, FALSE },
2607
2608         { 0x0020, UCHAR_PATTERN_WHITE_SPACE, TRUE },
2609         { 0x0085, UCHAR_PATTERN_WHITE_SPACE, TRUE },
2610         { 0x200f, UCHAR_PATTERN_WHITE_SPACE, TRUE },
2611         { 0x00a0, UCHAR_PATTERN_WHITE_SPACE, FALSE },
2612         { 0x3000, UCHAR_PATTERN_WHITE_SPACE, FALSE },
2613
2614         { 0x1d200, UCHAR_BLOCK, UBLOCK_ANCIENT_GREEK_MUSICAL_NOTATION },
2615         { 0x2c8e,  UCHAR_BLOCK, UBLOCK_COPTIC },
2616         { 0xfe17,  UCHAR_BLOCK, UBLOCK_VERTICAL_FORMS },
2617
2618         { 0x1a00,  UCHAR_SCRIPT, USCRIPT_BUGINESE },
2619         { 0x2cea,  UCHAR_SCRIPT, USCRIPT_COPTIC },
2620         { 0xa82b,  UCHAR_SCRIPT, USCRIPT_SYLOTI_NAGRI },
2621         { 0x103d0, UCHAR_SCRIPT, USCRIPT_OLD_PERSIAN },
2622
2623         { 0xcc28, UCHAR_LINE_BREAK, U_LB_H2 },
2624         { 0xcc29, UCHAR_LINE_BREAK, U_LB_H3 },
2625         { 0xac03, UCHAR_LINE_BREAK, U_LB_H3 },
2626         { 0x115f, UCHAR_LINE_BREAK, U_LB_JL },
2627         { 0x11aa, UCHAR_LINE_BREAK, U_LB_JT },
2628         { 0x11a1, UCHAR_LINE_BREAK, U_LB_JV },
2629
2630         { 0xb2c9, UCHAR_GRAPHEME_CLUSTER_BREAK, U_GCB_LVT },
2631         { 0x036f, UCHAR_GRAPHEME_CLUSTER_BREAK, U_GCB_EXTEND },
2632         { 0x0000, UCHAR_GRAPHEME_CLUSTER_BREAK, U_GCB_CONTROL },
2633         { 0x1160, UCHAR_GRAPHEME_CLUSTER_BREAK, U_GCB_V },
2634
2635         { 0x05f4, UCHAR_WORD_BREAK, U_WB_MIDLETTER },
2636         { 0x4ef0, UCHAR_WORD_BREAK, U_WB_OTHER },
2637         { 0x19d9, UCHAR_WORD_BREAK, U_WB_NUMERIC },
2638         { 0x2044, UCHAR_WORD_BREAK, U_WB_MIDNUM },
2639
2640         { 0xfffd, UCHAR_SENTENCE_BREAK, U_SB_OTHER },
2641         { 0x1ffc, UCHAR_SENTENCE_BREAK, U_SB_UPPER },
2642         { 0xff63, UCHAR_SENTENCE_BREAK, U_SB_CLOSE },
2643         { 0x2028, UCHAR_SENTENCE_BREAK, U_SB_SEP },
2644
2645         { -1, 0x520, 0 }, /* version break for Unicode 5.2 */
2646
2647         /* unassigned code points in new default Bidi R blocks */
2648         { 0x1ede4, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT },
2649         { 0x1efe4, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT },
2650
2651         /* test some script codes >127 */
2652         { 0xa6e6,  UCHAR_SCRIPT, USCRIPT_BAMUM },
2653         { 0xa4d0,  UCHAR_SCRIPT, USCRIPT_LISU },
2654         { 0x10a7f,  UCHAR_SCRIPT, USCRIPT_OLD_SOUTH_ARABIAN },
2655
2656         { -1, 0x600, 0 }, /* version break for Unicode 6.0 */
2657
2658         /* value changed in Unicode 6.0 */
2659         { 0x06C3, UCHAR_JOINING_GROUP, U_JG_TEH_MARBUTA_GOAL },
2660
2661         { -1, 0x610, 0 }, /* version break for Unicode 6.1 */
2662
2663         /* unassigned code points in new/changed default Bidi AL blocks */
2664         { 0x08ba, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT_ARABIC },
2665         { 0x1eee4, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT_ARABIC },
2666
2667         { -1, 0x630, 0 }, /* version break for Unicode 6.3 */
2668
2669         /* unassigned code points in the currency symbols block now default to ET */
2670         { 0x20C0, UCHAR_BIDI_CLASS, U_EUROPEAN_NUMBER_TERMINATOR },
2671         { 0x20CF, UCHAR_BIDI_CLASS, U_EUROPEAN_NUMBER_TERMINATOR },
2672
2673         /* new property in Unicode 6.3 */
2674         { 0x0027, UCHAR_BIDI_PAIRED_BRACKET_TYPE, U_BPT_NONE },
2675         { 0x0028, UCHAR_BIDI_PAIRED_BRACKET_TYPE, U_BPT_OPEN },
2676         { 0x0029, UCHAR_BIDI_PAIRED_BRACKET_TYPE, U_BPT_CLOSE },
2677         { 0xFF5C, UCHAR_BIDI_PAIRED_BRACKET_TYPE, U_BPT_NONE },
2678         { 0xFF5B, UCHAR_BIDI_PAIRED_BRACKET_TYPE, U_BPT_OPEN },
2679         { 0xFF5D, UCHAR_BIDI_PAIRED_BRACKET_TYPE, U_BPT_CLOSE },
2680
2681         { -1, 0x700, 0 }, /* version break for Unicode 7.0 */
2682
2683         /* new character range with Joining_Group values */
2684         { 0x10ABF, UCHAR_JOINING_GROUP, U_JG_NO_JOINING_GROUP },
2685         { 0x10AC0, UCHAR_JOINING_GROUP, U_JG_MANICHAEAN_ALEPH },
2686         { 0x10AC1, UCHAR_JOINING_GROUP, U_JG_MANICHAEAN_BETH },
2687         { 0x10AEF, UCHAR_JOINING_GROUP, U_JG_MANICHAEAN_HUNDRED },
2688         { 0x10AF0, UCHAR_JOINING_GROUP, U_JG_NO_JOINING_GROUP },
2689
2690         /* undefined UProperty values */
2691         { 0x61, 0x4a7, 0 },
2692         { 0x234bc, 0x15ed, 0 }
2693     };
2694
2695     UVersionInfo version;
2696     UChar32 c;
2697     int32_t i, result, uVersion;
2698     UProperty which;
2699
2700     /* what is our Unicode version? */
2701     u_getUnicodeVersion(version);
2702     uVersion=((int32_t)version[0]<<8)|(version[1]<<4)|version[2]; /* major/minor/update version numbers */
2703
2704     u_charAge(0x20, version);
2705     if(version[0]==0) {
2706         /* no additional properties available */
2707         log_err("TestAdditionalProperties: no additional properties available, not tested\n");
2708         return;
2709     }
2710
2711     /* test u_charAge() */
2712     for(i=0; i<UPRV_LENGTHOF(charAges); ++i) {
2713         u_charAge(charAges[i].c, version);
2714         if(0!=memcmp(version, charAges[i].version, sizeof(UVersionInfo))) {
2715             log_err("error: u_charAge(U+%04lx)={ %u, %u, %u, %u } instead of { %u, %u, %u, %u }\n",
2716                 charAges[i].c,
2717                 version[0], version[1], version[2], version[3],
2718                 charAges[i].version[0], charAges[i].version[1], charAges[i].version[2], charAges[i].version[3]);
2719         }
2720     }
2721
2722     if( u_getIntPropertyMinValue(UCHAR_DASH)!=0 ||
2723         u_getIntPropertyMinValue(UCHAR_BIDI_CLASS)!=0 ||
2724         u_getIntPropertyMinValue(UCHAR_BLOCK)!=0 ||   /* j2478 */
2725         u_getIntPropertyMinValue(UCHAR_SCRIPT)!=0 || /*JB#2410*/
2726         u_getIntPropertyMinValue(0x2345)!=0
2727     ) {
2728         log_err("error: u_getIntPropertyMinValue() wrong\n");
2729     }
2730     if( u_getIntPropertyMaxValue(UCHAR_DASH)!=1) {
2731         log_err("error: u_getIntPropertyMaxValue(UCHAR_DASH) wrong\n");
2732     }
2733     if( u_getIntPropertyMaxValue(UCHAR_ID_CONTINUE)!=1) {
2734         log_err("error: u_getIntPropertyMaxValue(UCHAR_ID_CONTINUE) wrong\n");
2735     }
2736     if( u_getIntPropertyMaxValue((UProperty)(UCHAR_BINARY_LIMIT-1))!=1) {
2737         log_err("error: u_getIntPropertyMaxValue(UCHAR_BINARY_LIMIT-1) wrong\n");
2738     }
2739     if( u_getIntPropertyMaxValue(UCHAR_BIDI_CLASS)!=(int32_t)U_CHAR_DIRECTION_COUNT-1 ) {
2740         log_err("error: u_getIntPropertyMaxValue(UCHAR_BIDI_CLASS) wrong\n");
2741     }
2742     if( u_getIntPropertyMaxValue(UCHAR_BLOCK)!=(int32_t)UBLOCK_COUNT-1 ) {
2743         log_err("error: u_getIntPropertyMaxValue(UCHAR_BLOCK) wrong\n");
2744     }
2745     if(u_getIntPropertyMaxValue(UCHAR_LINE_BREAK)!=(int32_t)U_LB_COUNT-1) {
2746         log_err("error: u_getIntPropertyMaxValue(UCHAR_LINE_BREAK) wrong\n");
2747     }
2748     if(u_getIntPropertyMaxValue(UCHAR_SCRIPT)!=(int32_t)USCRIPT_CODE_LIMIT-1) {
2749         log_err("error: u_getIntPropertyMaxValue(UCHAR_SCRIPT) wrong\n");
2750     }
2751     if(u_getIntPropertyMaxValue(UCHAR_NUMERIC_TYPE)!=(int32_t)U_NT_COUNT-1) {
2752         log_err("error: u_getIntPropertyMaxValue(UCHAR_NUMERIC_TYPE) wrong\n");
2753     }
2754     if(u_getIntPropertyMaxValue(UCHAR_GENERAL_CATEGORY)!=(int32_t)U_CHAR_CATEGORY_COUNT-1) {
2755         log_err("error: u_getIntPropertyMaxValue(UCHAR_GENERAL_CATEGORY) wrong\n");
2756     }
2757     if(u_getIntPropertyMaxValue(UCHAR_HANGUL_SYLLABLE_TYPE)!=(int32_t)U_HST_COUNT-1) {
2758         log_err("error: u_getIntPropertyMaxValue(UCHAR_HANGUL_SYLLABLE_TYPE) wrong\n");
2759     }
2760     if(u_getIntPropertyMaxValue(UCHAR_GRAPHEME_CLUSTER_BREAK)!=(int32_t)U_GCB_COUNT-1) {
2761         log_err("error: u_getIntPropertyMaxValue(UCHAR_GRAPHEME_CLUSTER_BREAK) wrong\n");
2762     }
2763     if(u_getIntPropertyMaxValue(UCHAR_SENTENCE_BREAK)!=(int32_t)U_SB_COUNT-1) {
2764         log_err("error: u_getIntPropertyMaxValue(UCHAR_SENTENCE_BREAK) wrong\n");
2765     }
2766     if(u_getIntPropertyMaxValue(UCHAR_WORD_BREAK)!=(int32_t)U_WB_COUNT-1) {
2767         log_err("error: u_getIntPropertyMaxValue(UCHAR_WORD_BREAK) wrong\n");
2768     }
2769     if(u_getIntPropertyMaxValue(UCHAR_BIDI_PAIRED_BRACKET_TYPE)!=(int32_t)U_BPT_COUNT-1) {
2770         log_err("error: u_getIntPropertyMaxValue(UCHAR_BIDI_PAIRED_BRACKET_TYPE) wrong\n");
2771     }
2772     /*JB#2410*/
2773     if( u_getIntPropertyMaxValue(0x2345)!=-1) {
2774         log_err("error: u_getIntPropertyMaxValue(0x2345) wrong\n");
2775     }
2776     if( u_getIntPropertyMaxValue(UCHAR_DECOMPOSITION_TYPE) != (int32_t) (U_DT_COUNT - 1)) {
2777         log_err("error: u_getIntPropertyMaxValue(UCHAR_DECOMPOSITION_TYPE) wrong\n");
2778     }
2779     if( u_getIntPropertyMaxValue(UCHAR_JOINING_GROUP) !=  (int32_t) (U_JG_COUNT -1)) {
2780         log_err("error: u_getIntPropertyMaxValue(UCHAR_JOINING_GROUP) wrong\n");
2781     }
2782     if( u_getIntPropertyMaxValue(UCHAR_JOINING_TYPE) != (int32_t) (U_JT_COUNT -1)) {
2783         log_err("error: u_getIntPropertyMaxValue(UCHAR_JOINING_TYPE) wrong\n");
2784     }
2785     if( u_getIntPropertyMaxValue(UCHAR_EAST_ASIAN_WIDTH) != (int32_t) (U_EA_COUNT -1)) {
2786         log_err("error: u_getIntPropertyMaxValue(UCHAR_EAST_ASIAN_WIDTH) wrong\n");
2787     }
2788
2789     /* test u_hasBinaryProperty() and u_getIntPropertyValue() */
2790     for(i=0; i<UPRV_LENGTHOF(props); ++i) {
2791         const char *whichName;
2792
2793         if(props[i][0]<0) {
2794             /* Unicode version break */
2795             if(uVersion<props[i][1]) {
2796                 break; /* do not test properties that are not yet supported */
2797             } else {
2798                 continue; /* skip this row */
2799             }
2800         }
2801
2802         c=(UChar32)props[i][0];
2803         which=(UProperty)props[i][1];
2804         whichName=u_getPropertyName(which, U_LONG_PROPERTY_NAME);
2805
2806         if(which<UCHAR_INT_START) {
2807             result=u_hasBinaryProperty(c, which);
2808             if(result!=props[i][2]) {
2809                 log_data_err("error: u_hasBinaryProperty(U+%04lx, %s)=%d is wrong (props[%d]) - (Are you missing data?)\n",
2810                         c, whichName, result, i);
2811             }
2812         }
2813
2814         result=u_getIntPropertyValue(c, which);
2815         if(result!=props[i][2]) {
2816             log_data_err("error: u_getIntPropertyValue(U+%04lx, %s)=%d is wrong, should be %d (props[%d]) - (Are you missing data?)\n",
2817                     c, whichName, result, props[i][2], i);
2818         }
2819
2820         /* test separate functions, too */
2821         switch((UProperty)props[i][1]) {
2822         case UCHAR_ALPHABETIC:
2823             if(u_isUAlphabetic((UChar32)props[i][0])!=(UBool)props[i][2]) {
2824                 log_err("error: u_isUAlphabetic(U+%04lx)=%d is wrong (props[%d])\n",
2825                         props[i][0], result, i);
2826             }
2827             break;
2828         case UCHAR_LOWERCASE:
2829             if(u_isULowercase((UChar32)props[i][0])!=(UBool)props[i][2]) {
2830                 log_err("error: u_isULowercase(U+%04lx)=%d is wrong (props[%d])\n",
2831                         props[i][0], result, i);
2832             }
2833             break;
2834         case UCHAR_UPPERCASE:
2835             if(u_isUUppercase((UChar32)props[i][0])!=(UBool)props[i][2]) {
2836                 log_err("error: u_isUUppercase(U+%04lx)=%d is wrong (props[%d])\n",
2837                         props[i][0], result, i);
2838             }
2839             break;
2840         case UCHAR_WHITE_SPACE:
2841             if(u_isUWhiteSpace((UChar32)props[i][0])!=(UBool)props[i][2]) {
2842                 log_err("error: u_isUWhiteSpace(U+%04lx)=%d is wrong (props[%d])\n",
2843                         props[i][0], result, i);
2844             }
2845             break;
2846         default:
2847             break;
2848         }
2849     }
2850 }
2851
2852 static void
2853 TestNumericProperties(void) {
2854     /* see UnicodeData.txt, DerivedNumericValues.txt */
2855     static const struct {
2856         UChar32 c;
2857         int32_t type;
2858         double numValue;
2859     } values[]={
2860         { 0x0F33, U_NT_NUMERIC, -1./2. },
2861         { 0x0C66, U_NT_DECIMAL, 0 },
2862         { 0x96f6, U_NT_NUMERIC, 0 },
2863         { 0xa833, U_NT_NUMERIC, 1./16. },
2864         { 0x2152, U_NT_NUMERIC, 1./10. },
2865         { 0x2151, U_NT_NUMERIC, 1./9. },
2866         { 0x1245f, U_NT_NUMERIC, 1./8. },
2867         { 0x2150, U_NT_NUMERIC, 1./7. },
2868         { 0x2159, U_NT_NUMERIC, 1./6. },
2869         { 0x09f6, U_NT_NUMERIC, 3./16. },
2870         { 0x2155, U_NT_NUMERIC, 1./5. },
2871         { 0x00BD, U_NT_NUMERIC, 1./2. },
2872         { 0x0031, U_NT_DECIMAL, 1. },
2873         { 0x4e00, U_NT_NUMERIC, 1. },
2874         { 0x58f1, U_NT_NUMERIC, 1. },
2875         { 0x10320, U_NT_NUMERIC, 1. },
2876         { 0x0F2B, U_NT_NUMERIC, 3./2. },
2877         { 0x00B2, U_NT_DIGIT, 2. },
2878         { 0x5f10, U_NT_NUMERIC, 2. },
2879         { 0x1813, U_NT_DECIMAL, 3. },
2880         { 0x5f0e, U_NT_NUMERIC, 3. },
2881         { 0x2173, U_NT_NUMERIC, 4. },
2882         { 0x8086, U_NT_NUMERIC, 4. },
2883         { 0x278E, U_NT_DIGIT, 5. },
2884         { 0x1D7F2, U_NT_DECIMAL, 6. },
2885         { 0x247A, U_NT_DIGIT, 7. },
2886         { 0x7396, U_NT_NUMERIC, 9. },
2887         { 0x1372, U_NT_NUMERIC, 10. },
2888         { 0x216B, U_NT_NUMERIC, 12. },
2889         { 0x16EE, U_NT_NUMERIC, 17. },
2890         { 0x249A, U_NT_NUMERIC, 19. },
2891         { 0x303A, U_NT_NUMERIC, 30. },
2892         { 0x5345, U_NT_NUMERIC, 30. },
2893         { 0x32B2, U_NT_NUMERIC, 37. },
2894         { 0x1375, U_NT_NUMERIC, 40. },
2895         { 0x10323, U_NT_NUMERIC, 50. },
2896         { 0x0BF1, U_NT_NUMERIC, 100. },
2897         { 0x964c, U_NT_NUMERIC, 100. },
2898         { 0x217E, U_NT_NUMERIC, 500. },
2899         { 0x2180, U_NT_NUMERIC, 1000. },
2900         { 0x4edf, U_NT_NUMERIC, 1000. },
2901         { 0x2181, U_NT_NUMERIC, 5000. },
2902         { 0x137C, U_NT_NUMERIC, 10000. },
2903         { 0x4e07, U_NT_NUMERIC, 10000. },
2904         { 0x12432, U_NT_NUMERIC, 216000. },
2905         { 0x12433, U_NT_NUMERIC, 432000. },
2906         { 0x4ebf, U_NT_NUMERIC, 100000000. },
2907         { 0x5146, U_NT_NUMERIC, 1000000000000. },
2908         { -1, U_NT_NONE, U_NO_NUMERIC_VALUE },
2909         { 0x61, U_NT_NONE, U_NO_NUMERIC_VALUE },
2910         { 0x3000, U_NT_NONE, U_NO_NUMERIC_VALUE },
2911         { 0xfffe, U_NT_NONE, U_NO_NUMERIC_VALUE },
2912         { 0x10301, U_NT_NONE, U_NO_NUMERIC_VALUE },
2913         { 0xe0033, U_NT_NONE, U_NO_NUMERIC_VALUE },
2914         { 0x10ffff, U_NT_NONE, U_NO_NUMERIC_VALUE },
2915         { 0x110000, U_NT_NONE, U_NO_NUMERIC_VALUE }
2916     };
2917
2918     double nv;
2919     UChar32 c;
2920     int32_t i, type;
2921
2922     for(i=0; i<UPRV_LENGTHOF(values); ++i) {
2923         c=values[i].c;
2924         type=u_getIntPropertyValue(c, UCHAR_NUMERIC_TYPE);
2925         nv=u_getNumericValue(c);
2926
2927         if(type!=values[i].type) {
2928             log_err("UCHAR_NUMERIC_TYPE(U+%04lx)=%d should be %d\n", c, type, values[i].type);
2929         }
2930         if(0.000001 <= fabs(nv - values[i].numValue)) {
2931             log_err("u_getNumericValue(U+%04lx)=%g should be %g\n", c, nv, values[i].numValue);
2932         }
2933     }
2934 }
2935
2936 /**
2937  * Test the property names and property value names API.
2938  */
2939 static void
2940 TestPropertyNames(void) {
2941     int32_t p, v, choice=0, rev;
2942     UBool atLeastSomething = FALSE;
2943
2944     for (p=0; ; ++p) {
2945         UProperty propEnum = (UProperty)p;
2946         UBool sawProp = FALSE;
2947         if(p > 10 && !atLeastSomething) {
2948           log_data_err("Never got anything after 10 tries.\nYour data is probably fried. Quitting this test\n", p, choice);
2949           return;
2950         }
2951
2952         for (choice=0; ; ++choice) {
2953             const char* name = u_getPropertyName(propEnum, (UPropertyNameChoice)choice);
2954             if (name) {
2955                 if (!sawProp)
2956                     log_verbose("prop 0x%04x+%2d:", p&~0xfff, p&0xfff);
2957                 log_verbose("%d=\"%s\"", choice, name);
2958                 sawProp = TRUE;
2959                 atLeastSomething = TRUE;
2960
2961                 /* test reverse mapping */
2962                 rev = u_getPropertyEnum(name);
2963                 if (rev != p) {
2964                     log_err("Property round-trip failure: %d -> %s -> %d\n",
2965                             p, name, rev);
2966                 }
2967             }
2968             if (!name && choice>0) break;
2969         }
2970         if (sawProp) {
2971             /* looks like a valid property; check the values */
2972             const char* pname = u_getPropertyName(propEnum, U_LONG_PROPERTY_NAME);
2973             int32_t max = 0;
2974             if (p == UCHAR_CANONICAL_COMBINING_CLASS) {
2975                 max = 255;
2976             } else if (p == UCHAR_GENERAL_CATEGORY_MASK) {
2977                 /* it's far too slow to iterate all the way up to
2978                    the real max, U_GC_P_MASK */
2979                 max = U_GC_NL_MASK;
2980             } else if (p == UCHAR_BLOCK) {
2981                 /* UBlockCodes, unlike other values, start at 1 */
2982                 max = 1;
2983             }
2984             log_verbose("\n");
2985             for (v=-1; ; ++v) {
2986                 UBool sawValue = FALSE;
2987                 for (choice=0; ; ++choice) {
2988                     const char* vname = u_getPropertyValueName(propEnum, v, (UPropertyNameChoice)choice);
2989                     if (vname) {
2990                         if (!sawValue) log_verbose(" %s, value %d:", pname, v);
2991                         log_verbose("%d=\"%s\"", choice, vname);
2992                         sawValue = TRUE;
2993
2994                         /* test reverse mapping */
2995                         rev = u_getPropertyValueEnum(propEnum, vname);
2996                         if (rev != v) {
2997                             log_err("Value round-trip failure (%s): %d -> %s -> %d\n",
2998                                     pname, v, vname, rev);
2999                         }
3000                     }
3001                     if (!vname && choice>0) break;
3002                 }
3003                 if (sawValue) {
3004                     log_verbose("\n");
3005                 }
3006                 if (!sawValue && v>=max) break;
3007             }
3008         }
3009         if (!sawProp) {
3010             if (p>=UCHAR_STRING_LIMIT) {
3011                 break;
3012             } else if (p>=UCHAR_DOUBLE_LIMIT) {
3013                 p = UCHAR_STRING_START - 1;
3014             } else if (p>=UCHAR_MASK_LIMIT) {
3015                 p = UCHAR_DOUBLE_START - 1;
3016             } else if (p>=UCHAR_INT_LIMIT) {
3017                 p = UCHAR_MASK_START - 1;
3018             } else if (p>=UCHAR_BINARY_LIMIT) {
3019                 p = UCHAR_INT_START - 1;
3020             }
3021         }
3022     }
3023 }
3024
3025 /**
3026  * Test the property values API.  See JB#2410.
3027  */
3028 static void
3029 TestPropertyValues(void) {
3030     int32_t i, p, min, max;
3031     UErrorCode ec;
3032
3033     /* Min should be 0 for everything. */
3034     /* Until JB#2478 is fixed, the one exception is UCHAR_BLOCK. */
3035     for (p=UCHAR_INT_START; p<UCHAR_INT_LIMIT; ++p) {
3036         UProperty propEnum = (UProperty)p;
3037         min = u_getIntPropertyMinValue(propEnum);
3038         if (min != 0) {
3039             if (p == UCHAR_BLOCK) {
3040                 /* This is okay...for now.  See JB#2487.
3041                    TODO Update this for JB#2487. */
3042             } else {
3043                 const char* name;
3044                 name = u_getPropertyName(propEnum, U_LONG_PROPERTY_NAME);
3045                 if (name == NULL)
3046                     name = "<ERROR>";
3047                 log_err("FAIL: u_getIntPropertyMinValue(%s) = %d, exp. 0\n",
3048                         name, min);
3049             }
3050         }
3051     }
3052
3053     if( u_getIntPropertyMinValue(UCHAR_GENERAL_CATEGORY_MASK)!=0 ||
3054         u_getIntPropertyMaxValue(UCHAR_GENERAL_CATEGORY_MASK)!=-1) {
3055         log_err("error: u_getIntPropertyMin/MaxValue(UCHAR_GENERAL_CATEGORY_MASK) is wrong\n");
3056     }
3057
3058     /* Max should be -1 for invalid properties. */
3059     max = u_getIntPropertyMaxValue(UCHAR_INVALID_CODE);
3060     if (max != -1) {
3061         log_err("FAIL: u_getIntPropertyMaxValue(-1) = %d, exp. -1\n",
3062                 max);
3063     }
3064
3065     /* Script should return USCRIPT_INVALID_CODE for an invalid code point. */
3066     for (i=0; i<2; ++i) {
3067         int32_t script;
3068         const char* desc;
3069         ec = U_ZERO_ERROR;
3070         switch (i) {
3071         case 0:
3072             script = uscript_getScript(-1, &ec);
3073             desc = "uscript_getScript(-1)";
3074             break;
3075         case 1:
3076             script = u_getIntPropertyValue(-1, UCHAR_SCRIPT);
3077             desc = "u_getIntPropertyValue(-1, UCHAR_SCRIPT)";
3078             break;
3079         default:
3080             log_err("Internal test error. Too many scripts\n");
3081             return;
3082         }
3083         /* We don't explicitly test ec.  It should be U_FAILURE but it
3084            isn't documented as such. */
3085         if (script != (int32_t)USCRIPT_INVALID_CODE) {
3086             log_err("FAIL: %s = %d, exp. 0\n",
3087                     desc, script);
3088         }
3089     }
3090 }
3091
3092 /* various tests for consistency of UCD data and API behavior */
3093 static void
3094 TestConsistency() {
3095     char buffer[300];
3096     USet *set1, *set2, *set3, *set4;
3097     UErrorCode errorCode;
3098
3099     UChar32 start, end;
3100     int32_t i, length;
3101
3102     U_STRING_DECL(hyphenPattern, "[:Hyphen:]", 10);
3103     U_STRING_DECL(dashPattern, "[:Dash:]", 8);
3104     U_STRING_DECL(lowerPattern, "[:Lowercase:]", 13);
3105     U_STRING_DECL(formatPattern, "[:Cf:]", 6);
3106     U_STRING_DECL(alphaPattern, "[:Alphabetic:]", 14);
3107
3108     U_STRING_DECL(mathBlocksPattern,
3109         "[[:block=Mathematical Operators:][:block=Miscellaneous Mathematical Symbols-A:][:block=Miscellaneous Mathematical Symbols-B:][:block=Supplemental Mathematical Operators:][:block=Mathematical Alphanumeric Symbols:]]",
3110         214);
3111     U_STRING_DECL(mathPattern, "[:Math:]", 8);
3112     U_STRING_DECL(unassignedPattern, "[:Cn:]", 6);
3113     U_STRING_DECL(unknownPattern, "[:sc=Unknown:]", 14);
3114     U_STRING_DECL(reservedPattern, "[[:Cn:][:Co:][:Cs:]]", 20);
3115
3116     U_STRING_INIT(hyphenPattern, "[:Hyphen:]", 10);
3117     U_STRING_INIT(dashPattern, "[:Dash:]", 8);
3118     U_STRING_INIT(lowerPattern, "[:Lowercase:]", 13);
3119     U_STRING_INIT(formatPattern, "[:Cf:]", 6);
3120     U_STRING_INIT(alphaPattern, "[:Alphabetic:]", 14);
3121
3122     U_STRING_INIT(mathBlocksPattern,
3123         "[[:block=Mathematical Operators:][:block=Miscellaneous Mathematical Symbols-A:][:block=Miscellaneous Mathematical Symbols-B:][:block=Supplemental Mathematical Operators:][:block=Mathematical Alphanumeric Symbols:]]",
3124         214);
3125     U_STRING_INIT(mathPattern, "[:Math:]", 8);
3126     U_STRING_INIT(unassignedPattern, "[:Cn:]", 6);
3127     U_STRING_INIT(unknownPattern, "[:sc=Unknown:]", 14);
3128     U_STRING_INIT(reservedPattern, "[[:Cn:][:Co:][:Cs:]]", 20);
3129
3130     /*
3131      * It used to be that UCD.html and its precursors said
3132      * "Those dashes used to mark connections between pieces of words,
3133      *  plus the Katakana middle dot."
3134      *
3135      * Unicode 4 changed 00AD Soft Hyphen to Cf and removed it from Dash
3136      * but not from Hyphen.
3137      * UTC 94 (2003mar) decided to leave it that way and to change UCD.html.
3138      * Therefore, do not show errors when testing the Hyphen property.
3139      */
3140     log_verbose("Starting with Unicode 4, inconsistencies with [:Hyphen:] are\n"
3141                 "known to the UTC and not considered errors.\n");
3142
3143     errorCode=U_ZERO_ERROR;
3144     set1=uset_openPattern(hyphenPattern, 10, &errorCode);
3145     set2=uset_openPattern(dashPattern, 8, &errorCode);
3146     if(U_SUCCESS(errorCode)) {
3147         /* remove the Katakana middle dot(s) from set1 */
3148         uset_remove(set1, 0x30fb);
3149         uset_remove(set1, 0xff65); /* halfwidth variant */
3150         showAMinusB(set1, set2, "[:Hyphen:]", "[:Dash:]", FALSE);
3151     } else {
3152         log_data_err("error opening [:Hyphen:] or [:Dash:] - %s (Are you missing data?)\n", u_errorName(errorCode));
3153     }
3154
3155     /* check that Cf is neither Hyphen nor Dash nor Alphabetic */
3156     set3=uset_openPattern(formatPattern, 6, &errorCode);
3157     set4=uset_openPattern(alphaPattern, 14, &errorCode);
3158     if(U_SUCCESS(errorCode)) {
3159         showAIntersectB(set3, set1, "[:Cf:]", "[:Hyphen:]", FALSE);
3160         showAIntersectB(set3, set2, "[:Cf:]", "[:Dash:]", TRUE);
3161         showAIntersectB(set3, set4, "[:Cf:]", "[:Alphabetic:]", TRUE);
3162     } else {
3163         log_data_err("error opening [:Cf:] or [:Alpbabetic:] - %s (Are you missing data?)\n", u_errorName(errorCode));
3164     }
3165
3166     uset_close(set1);
3167     uset_close(set2);
3168     uset_close(set3);
3169     uset_close(set4);
3170
3171     /*
3172      * Check that each lowercase character has "small" in its name
3173      * and not "capital".
3174      * There are some such characters, some of which seem odd.
3175      * Use the verbose flag to see these notices.
3176      */
3177     errorCode=U_ZERO_ERROR;
3178     set1=uset_openPattern(lowerPattern, 13, &errorCode);
3179     if(U_SUCCESS(errorCode)) {
3180         for(i=0;; ++i) {
3181             length=uset_getItem(set1, i, &start, &end, NULL, 0, &errorCode);
3182             if(errorCode==U_INDEX_OUTOFBOUNDS_ERROR) {
3183                 break; /* done */
3184             }
3185             if(U_FAILURE(errorCode)) {
3186                 log_err("error iterating over [:Lowercase:] at item %d: %s\n",
3187                         i, u_errorName(errorCode));
3188                 break;
3189             }
3190             if(length!=0) {
3191                 break; /* done with code points, got a string or -1 */
3192             }
3193
3194             while(start<=end) {
3195                 length=u_charName(start, U_UNICODE_CHAR_NAME, buffer, sizeof(buffer), &errorCode);
3196                 if(U_FAILURE(errorCode)) {
3197                     log_data_err("error getting the name of U+%04x - %s\n", start, u_errorName(errorCode));
3198                     errorCode=U_ZERO_ERROR;
3199                 }
3200                 if( (strstr(buffer, "SMALL")==NULL || strstr(buffer, "CAPITAL")!=NULL) &&
3201                     strstr(buffer, "SMALL CAPITAL")==NULL
3202                 ) {
3203                     log_verbose("info: [:Lowercase:] contains U+%04x whose name does not suggest lowercase: %s\n", start, buffer);
3204                 }
3205                 ++start;
3206             }
3207         }
3208     } else {
3209         log_data_err("error opening [:Lowercase:] - %s (Are you missing data?)\n", u_errorName(errorCode));
3210     }
3211     uset_close(set1);
3212
3213     /* verify that all assigned characters in Math blocks are exactly Math characters */
3214     errorCode=U_ZERO_ERROR;
3215     set1=uset_openPattern(mathBlocksPattern, -1, &errorCode);
3216     set2=uset_openPattern(mathPattern, 8, &errorCode);
3217     set3=uset_openPattern(unassignedPattern, 6, &errorCode);
3218     if(U_SUCCESS(errorCode)) {
3219         uset_retainAll(set2, set1); /* [math blocks]&[:Math:] */
3220         uset_complement(set3);      /* assigned characters */
3221         uset_retainAll(set1, set3); /* [math blocks]&[assigned] */
3222         compareUSets(set1, set2,
3223                      "[assigned Math block chars]", "[math blocks]&[:Math:]",
3224                      TRUE);
3225     } else {
3226         log_data_err("error opening [math blocks] or [:Math:] or [:Cn:] - %s (Are you missing data?)\n", u_errorName(errorCode));
3227     }
3228     uset_close(set1);
3229     uset_close(set2);
3230     uset_close(set3);
3231
3232     /* new in Unicode 5.0: exactly all unassigned+PUA+surrogate code points have script=Unknown */
3233     errorCode=U_ZERO_ERROR;
3234     set1=uset_openPattern(unknownPattern, 14, &errorCode);
3235     set2=uset_openPattern(reservedPattern, 20, &errorCode);
3236     if(U_SUCCESS(errorCode)) {
3237         compareUSets(set1, set2,
3238                      "[:sc=Unknown:]", "[[:Cn:][:Co:][:Cs:]]",
3239                      TRUE);
3240     } else {
3241         log_data_err("error opening [:sc=Unknown:] or [[:Cn:][:Co:][:Cs:]] - %s (Are you missing data?)\n", u_errorName(errorCode));
3242     }
3243     uset_close(set1);
3244     uset_close(set2);
3245 }
3246
3247 /*
3248  * Starting with ICU4C 3.4, the core Unicode properties files
3249  * (uprops.icu, ucase.icu, ubidi.icu, unorm.icu)
3250  * are hardcoded in the common DLL and therefore not included
3251  * in the data package any more.
3252  * Test requiring these files are disabled so that
3253  * we need not jump through hoops (like adding snapshots of these files
3254  * to testdata).
3255  * See Jitterbug 4497.
3256  */
3257 #define HARDCODED_DATA_4497 1
3258
3259 /* API coverage for ucase.c */
3260 static void TestUCase() {
3261 #if !HARDCODED_DATA_4497
3262     UDataMemory *pData;
3263     UCaseProps *csp;
3264     const UCaseProps *ccsp;
3265     UErrorCode errorCode;
3266
3267     /* coverage for ucase_openBinary() */
3268     errorCode=U_ZERO_ERROR;
3269     pData=udata_open(NULL, UCASE_DATA_TYPE, UCASE_DATA_NAME, &errorCode);
3270     if(U_FAILURE(errorCode)) {
3271         log_data_err("unable to open " UCASE_DATA_NAME "." UCASE_DATA_TYPE ": %s\n",
3272                     u_errorName(errorCode));
3273         return;
3274     }
3275
3276     csp=ucase_openBinary((const uint8_t *)pData->pHeader, -1, &errorCode);
3277     if(U_FAILURE(errorCode)) {
3278         log_err("ucase_openBinary() fails for the contents of " UCASE_DATA_NAME "." UCASE_DATA_TYPE ": %s\n",
3279                 u_errorName(errorCode));
3280         udata_close(pData);
3281         return;
3282     }
3283
3284     if(UCASE_LOWER!=ucase_getType(csp, 0xdf)) { /* verify islower(sharp s) */
3285         log_err("ucase_openBinary() does not seem to return working UCaseProps\n");
3286     }
3287
3288     ucase_close(csp);
3289     udata_close(pData);
3290
3291     /* coverage for ucase_getDummy() */
3292     errorCode=U_ZERO_ERROR;
3293     ccsp=ucase_getDummy(&errorCode);
3294     if(ucase_tolower(ccsp, 0x41)!=0x41) {
3295         log_err("ucase_tolower(dummy, A)!=A\n");
3296     }
3297 #endif
3298 }
3299
3300 /* API coverage for ubidi_props.c */
3301 static void TestUBiDiProps() {
3302 #if !HARDCODED_DATA_4497
3303     UDataMemory *pData;
3304     UBiDiProps *bdp;
3305     const UBiDiProps *cbdp;
3306     UErrorCode errorCode;
3307
3308     /* coverage for ubidi_openBinary() */
3309     errorCode=U_ZERO_ERROR;
3310     pData=udata_open(NULL, UBIDI_DATA_TYPE, UBIDI_DATA_NAME, &errorCode);
3311     if(U_FAILURE(errorCode)) {
3312         log_data_err("unable to open " UBIDI_DATA_NAME "." UBIDI_DATA_TYPE ": %s\n",
3313                     u_errorName(errorCode));
3314         return;
3315     }
3316
3317     bdp=ubidi_openBinary((const uint8_t *)pData->pHeader, -1, &errorCode);
3318     if(U_FAILURE(errorCode)) {
3319         log_err("ubidi_openBinary() fails for the contents of " UBIDI_DATA_NAME "." UBIDI_DATA_TYPE ": %s\n",
3320                 u_errorName(errorCode));
3321         udata_close(pData);
3322         return;
3323     }
3324
3325     if(0x2215!=ubidi_getMirror(bdp, 0x29F5)) { /* verify some data */
3326         log_err("ubidi_openBinary() does not seem to return working UBiDiProps\n");
3327     }
3328
3329     ubidi_closeProps(bdp);
3330     udata_close(pData);
3331
3332     /* coverage for ubidi_getDummy() */
3333     errorCode=U_ZERO_ERROR;
3334     cbdp=ubidi_getDummy(&errorCode);
3335     if(ubidi_getClass(cbdp, 0x20)!=0) {
3336         log_err("ubidi_getClass(dummy, space)!=0\n");
3337     }
3338 #endif
3339 }
3340
3341 /* test case folding, compare return values with CaseFolding.txt ------------ */
3342
3343 /* bit set for which case foldings for a character have been tested already */
3344 enum {
3345     CF_SIMPLE=1,
3346     CF_FULL=2,
3347     CF_TURKIC=4,
3348     CF_ALL=7
3349 };
3350
3351 static void
3352 testFold(UChar32 c, int which,
3353          UChar32 simple, UChar32 turkic,
3354          const UChar *full, int32_t fullLength,
3355          const UChar *turkicFull, int32_t turkicFullLength) {
3356     UChar s[2], t[32];
3357     UChar32 c2;
3358     int32_t length, length2;
3359
3360     UErrorCode errorCode=U_ZERO_ERROR;
3361
3362     length=0;
3363     U16_APPEND_UNSAFE(s, length, c);
3364
3365     if((which&CF_SIMPLE)!=0 && (c2=u_foldCase(c, 0))!=simple) {
3366         log_err("u_foldCase(U+%04lx, default)=U+%04lx != U+%04lx\n", (long)c, (long)c2, (long)simple);
3367     }
3368     if((which&CF_FULL)!=0) {
3369         length2=u_strFoldCase(t, UPRV_LENGTHOF(t), s, length, 0, &errorCode);
3370         if(length2!=fullLength || 0!=u_memcmp(t, full, fullLength)) {
3371             log_err("u_strFoldCase(U+%04lx, default) does not fold properly\n", (long)c);
3372         }
3373     }
3374     if((which&CF_TURKIC)!=0) {
3375         if((c2=u_foldCase(c, U_FOLD_CASE_EXCLUDE_SPECIAL_I))!=turkic) {
3376             log_err("u_foldCase(U+%04lx, turkic)=U+%04lx != U+%04lx\n", (long)c, (long)c2, (long)simple);
3377         }
3378
3379         length2=u_strFoldCase(t, UPRV_LENGTHOF(t), s, length, U_FOLD_CASE_EXCLUDE_SPECIAL_I, &errorCode);
3380         if(length2!=turkicFullLength || 0!=u_memcmp(t, turkicFull, length2)) {
3381             log_err("u_strFoldCase(U+%04lx, turkic) does not fold properly\n", (long)c);
3382         }
3383     }
3384 }
3385
3386 /* test that c case-folds to itself */
3387 static void
3388 testFoldToSelf(UChar32 c, int which) {
3389     UChar s[2];
3390     int32_t length;
3391
3392     length=0;
3393     U16_APPEND_UNSAFE(s, length, c);
3394     testFold(c, which, c, c, s, length, s, length);
3395 }
3396
3397 struct CaseFoldingData {
3398     USet *notSeen;
3399     UChar32 prev, prevSimple;
3400     UChar prevFull[32];
3401     int32_t prevFullLength;
3402     int which;
3403 };
3404 typedef struct CaseFoldingData CaseFoldingData;
3405
3406 static void U_CALLCONV
3407 caseFoldingLineFn(void *context,
3408                   char *fields[][2], int32_t fieldCount,
3409                   UErrorCode *pErrorCode) {
3410     CaseFoldingData *pData=(CaseFoldingData *)context;
3411     char *end;
3412     UChar full[32];
3413     UChar32 c, prev, simple;
3414     int32_t count;
3415     int which;
3416     char status;
3417
3418     /* get code point */
3419     const char *s=u_skipWhitespace(fields[0][0]);
3420     if(0==strncmp(s, "0000..10FFFF", 12)) {
3421         /*
3422          * Ignore the line
3423          * # @missing: 0000..10FFFF; C; <code point>
3424          * because maps-to-self is already our default, and this line breaks this parser.
3425          */
3426         return;
3427     }
3428     c=(UChar32)strtoul(s, &end, 16);
3429     end=(char *)u_skipWhitespace(end);
3430     if(end<=fields[0][0] || end!=fields[0][1]) {
3431         log_err("syntax error in CaseFolding.txt field 0 at %s\n", fields[0][0]);
3432         *pErrorCode=U_PARSE_ERROR;
3433         return;
3434     }
3435
3436     /* get the status of this mapping */
3437     status=*u_skipWhitespace(fields[1][0]);
3438     if(status!='C' && status!='S' && status!='F' && status!='T') {
3439         log_err("unrecognized status field in CaseFolding.txt at %s\n", fields[0][0]);
3440         *pErrorCode=U_PARSE_ERROR;
3441         return;
3442     }
3443
3444     /* get the mapping */
3445     count=u_parseString(fields[2][0], full, 32, (uint32_t *)&simple, pErrorCode);
3446     if(U_FAILURE(*pErrorCode)) {
3447         log_err("error parsing CaseFolding.txt mapping at %s\n", fields[0][0]);
3448         return;
3449     }
3450
3451     /* there is a simple mapping only if there is exactly one code point (count is in UChars) */
3452     if(count==0 || count>2 || (count==2 && U16_IS_SINGLE(full[1]))) {
3453         simple=c;
3454     }
3455
3456     if(c!=(prev=pData->prev)) {
3457         /*
3458          * Test remaining mappings for the previous code point.
3459          * If a turkic folding was not mentioned, then it should fold the same
3460          * as the regular simple case folding.
3461          */
3462         UChar prevString[2];
3463         int32_t length;
3464
3465         length=0;
3466         U16_APPEND_UNSAFE(prevString, length, prev);
3467         testFold(prev, (~pData->which)&CF_ALL,
3468                  prev, pData->prevSimple,
3469                  prevString, length,
3470                  pData->prevFull, pData->prevFullLength);
3471         pData->prev=pData->prevSimple=c;
3472         length=0;
3473         U16_APPEND_UNSAFE(pData->prevFull, length, c);
3474         pData->prevFullLength=length;
3475         pData->which=0;
3476     }
3477
3478     /*
3479      * Turn the status into a bit set of case foldings to test.
3480      * Remember non-Turkic case foldings as defaults for Turkic mode.
3481      */
3482     switch(status) {
3483     case 'C':
3484         which=CF_SIMPLE|CF_FULL;
3485         pData->prevSimple=simple;
3486         u_memcpy(pData->prevFull, full, count);
3487         pData->prevFullLength=count;
3488         break;
3489     case 'S':
3490         which=CF_SIMPLE;
3491         pData->prevSimple=simple;
3492         break;
3493     case 'F':
3494         which=CF_FULL;
3495         u_memcpy(pData->prevFull, full, count);
3496         pData->prevFullLength=count;
3497         break;
3498     case 'T':
3499         which=CF_TURKIC;
3500         break;
3501     default:
3502         which=0;
3503         break; /* won't happen because of test above */
3504     }
3505
3506     testFold(c, which, simple, simple, full, count, full, count);
3507
3508     /* remember which case foldings of c have been tested */
3509     pData->which|=which;
3510
3511     /* remove c from the set of ones not mentioned in CaseFolding.txt */
3512     uset_remove(pData->notSeen, c);
3513 }
3514
3515 static void
3516 TestCaseFolding() {
3517     CaseFoldingData data={ NULL };
3518     char *fields[3][2];
3519     UErrorCode errorCode;
3520
3521     static char *lastLine= (char *)"10FFFF; C; 10FFFF;";
3522
3523     errorCode=U_ZERO_ERROR;
3524     /* test BMP & plane 1 - nothing interesting above */
3525     data.notSeen=uset_open(0, 0x1ffff);
3526     data.prevFullLength=1; /* length of full case folding of U+0000 */
3527
3528     parseUCDFile("CaseFolding.txt", fields, 3, caseFoldingLineFn, &data, &errorCode);
3529     if(U_SUCCESS(errorCode)) {
3530         int32_t i, start, end;
3531
3532         /* add a pseudo-last line to finish testing of the actual last one */
3533         fields[0][0]=lastLine;
3534         fields[0][1]=lastLine+6;
3535         fields[1][0]=lastLine+7;
3536         fields[1][1]=lastLine+9;
3537         fields[2][0]=lastLine+10;
3538         fields[2][1]=lastLine+17;
3539         caseFoldingLineFn(&data, fields, 3, &errorCode);
3540
3541         /* verify that all code points that are not mentioned in CaseFolding.txt fold to themselves */
3542         for(i=0;
3543             0==uset_getItem(data.notSeen, i, &start, &end, NULL, 0, &errorCode) &&
3544                 U_SUCCESS(errorCode);
3545             ++i
3546         ) {
3547             do {
3548                 testFoldToSelf(start, CF_ALL);
3549             } while(++start<=end);
3550         }
3551     }
3552
3553     uset_close(data.notSeen);
3554 }