Update ICU to 54.1 step 1

source/test/cintltst/cucdtst.c

 /********************************************************************
  * COPYRIGHT:
- * Copyright (c) 1997-2013, International Business Machines Corporation and
+ * Copyright (c) 1997-2014, International Business Machines Corporation and
  * others. All Rights Reserved.
  ********************************************************************/
 /*******************************************************************************
 *
 * File CUCDTST.C
 *
 * Modification History:
 *        Name                     Description
 *     Madhu Katragadda            Ported for C API, added tests for string functions
 ********************************************************************************
@@ skipping 13 matching lines @@
 #include "cintltst.h"
 #include "putilimp.h"
 #include "uparse.h"
 #include "ucase.h"
 #include "ubidi_props.h"
 #include "uprops.h"
 #include "uset_imp.h"
 #include "usc_impl.h"
 #include "udatamem.h" /* for testing ucase_openBinary() */
 #include "cucdapi.h"
-
-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
+#include "cmemory.h"
 
 /* prototypes --------------------------------------------------------------- */
 
 static void TestUpperLower(void);
 static void TestLetterNumber(void);
 static void TestMisc(void);
 static void TestPOSIX(void);
 static void TestControlPrint(void);
 static void TestIdentifier(void);
 static void TestUnicodeData(void);
 static void TestCodeUnit(void);
 static void TestCodePoint(void);
 static void TestCharLength(void);
 static void TestCharNames(void);
+static void TestUCharFromNameUnderflow(void);
 static void TestMirroring(void);
 static void TestUScriptRunAPI(void);
 static void TestAdditionalProperties(void);
 static void TestNumericProperties(void);
 static void TestPropertyNames(void);
 static void TestPropertyValues(void);
 static void TestConsistency(void);
 static void TestUCase(void);
 static void TestUBiDiProps(void);
 static void TestCaseFolding(void);
@@ skipping 34 matching lines @@
         *pErrorCode=U_ZERO_ERROR;
         u_parseDelimitedFile(backupPath, ';', fields, fieldCount, lineFn, context, pErrorCode);
     }
     if(U_FAILURE(*pErrorCode)) {
         log_err_status(*pErrorCode, "error parsing %s: %s\n", filename, u_errorName(*pErrorCode));
     }
 }
 
 /* test data ---------------------------------------------------------------- */
 
-static const UChar  LAST_CHAR_CODE_IN_FILE = 0xFFFD;
 static const char tagStrings[] = "MnMcMeNdNlNoZsZlZpCcCfCsCoCnLuLlLtLmLoPcPdPsPePoSmScSkSoPiPf";
 static const int32_t tagValues[] =
     {
     /* Mn */ U_NON_SPACING_MARK,
     /* Mc */ U_COMBINING_SPACING_MARK,
     /* Me */ U_ENCLOSING_MARK,
     /* Nd */ U_DECIMAL_DIGIT_NUMBER,
     /* Nl */ U_LETTER_NUMBER,
     /* No */ U_OTHER_NUMBER,
     /* Zs */ U_SPACE_SEPARATOR,
@@ skipping 60 matching lines @@
     addTest(root, &TestUnicodeData, "tsutil/cucdtst/TestUnicodeData");
     addTest(root, &TestAdditionalProperties, "tsutil/cucdtst/TestAdditionalProperties");
     addTest(root, &TestNumericProperties, "tsutil/cucdtst/TestNumericProperties");
     addTest(root, &TestUpperLower, "tsutil/cucdtst/TestUpperLower");
     addTest(root, &TestLetterNumber, "tsutil/cucdtst/TestLetterNumber");
     addTest(root, &TestMisc, "tsutil/cucdtst/TestMisc");
     addTest(root, &TestPOSIX, "tsutil/cucdtst/TestPOSIX");
     addTest(root, &TestControlPrint, "tsutil/cucdtst/TestControlPrint");
     addTest(root, &TestIdentifier, "tsutil/cucdtst/TestIdentifier");
     addTest(root, &TestCharNames, "tsutil/cucdtst/TestCharNames");
+    addTest(root, &TestUCharFromNameUnderflow, "tsutil/cucdtst/TestUCharFromNameUnderflow");
     addTest(root, &TestMirroring, "tsutil/cucdtst/TestMirroring");
     addTest(root, &TestUScriptCodeAPI, "tsutil/cucdtst/TestUScriptCodeAPI");
     addTest(root, &TestHasScript, "tsutil/cucdtst/TestHasScript");
     addTest(root, &TestGetScriptExtensions, "tsutil/cucdtst/TestGetScriptExtensions");
     addTest(root, &TestScriptMetadataAPI, "tsutil/cucdtst/TestScriptMetadataAPI");
     addTest(root, &TestUScriptRunAPI, "tsutil/cucdtst/TestUScriptRunAPI");
     addTest(root, &TestPropertyNames, "tsutil/cucdtst/TestPropertyNames");
     addTest(root, &TestPropertyValues, "tsutil/cucdtst/TestPropertyValues");
     addTest(root, &TestConsistency, "tsutil/cucdtst/TestConsistency");
     addTest(root, &TestUCase, "tsutil/cucdtst/TestUCase");
@@ skipping 355 matching lines @@
     static const int32_t sampleDigitValues[] = {0, 2, 3, 5};
 
     uint32_t mask;
 
     int32_t i;
     char icuVersion[U_MAX_VERSION_STRING_LENGTH];
     UVersionInfo realVersion;
 
     memset(icuVersion, 0, U_MAX_VERSION_STRING_LENGTH);
 
-    testSampleCharProps(u_isspace, "u_isspace", sampleSpaces, LENGTHOF(sampleSpaces), TRUE);
-    testSampleCharProps(u_isspace, "u_isspace", sampleNonSpaces, LENGTHOF(sampleNonSpaces), FALSE);
+    testSampleCharProps(u_isspace, "u_isspace", sampleSpaces, UPRV_LENGTHOF(sampleSpaces), TRUE);
+    testSampleCharProps(u_isspace, "u_isspace", sampleNonSpaces, UPRV_LENGTHOF(sampleNonSpaces), FALSE);
 
     testSampleCharProps(u_isJavaSpaceChar, "u_isJavaSpaceChar",
-                        sampleSpaces, LENGTHOF(sampleSpaces), TRUE);
+                        sampleSpaces, UPRV_LENGTHOF(sampleSpaces), TRUE);
     testSampleCharProps(u_isJavaSpaceChar, "u_isJavaSpaceChar",
-                        sampleNonSpaces, LENGTHOF(sampleNonSpaces), FALSE);
+                        sampleNonSpaces, UPRV_LENGTHOF(sampleNonSpaces), FALSE);
 
     testSampleCharProps(u_isWhitespace, "u_isWhitespace",
-                        sampleWhiteSpaces, LENGTHOF(sampleWhiteSpaces), TRUE);
+                        sampleWhiteSpaces, UPRV_LENGTHOF(sampleWhiteSpaces), TRUE);
     testSampleCharProps(u_isWhitespace, "u_isWhitespace",
-                        sampleNonWhiteSpaces, LENGTHOF(sampleNonWhiteSpaces), FALSE);
+                        sampleNonWhiteSpaces, UPRV_LENGTHOF(sampleNonWhiteSpaces), FALSE);
 
     testSampleCharProps(u_isdefined, "u_isdefined",
-                        sampleDefined, LENGTHOF(sampleDefined), TRUE);
+                        sampleDefined, UPRV_LENGTHOF(sampleDefined), TRUE);
     testSampleCharProps(u_isdefined, "u_isdefined",
-                        sampleUndefined, LENGTHOF(sampleUndefined), FALSE);
+                        sampleUndefined, UPRV_LENGTHOF(sampleUndefined), FALSE);
 
-    testSampleCharProps(u_isbase, "u_isbase", sampleBase, LENGTHOF(sampleBase), TRUE);
-    testSampleCharProps(u_isbase, "u_isbase", sampleNonBase, LENGTHOF(sampleNonBase), FALSE);
+    testSampleCharProps(u_isbase, "u_isbase", sampleBase, UPRV_LENGTHOF(sampleBase), TRUE);
+    testSampleCharProps(u_isbase, "u_isbase", sampleNonBase, UPRV_LENGTHOF(sampleNonBase), FALSE);
 
-    testSampleCharProps(u_isdigit, "u_isdigit", sampleDigits, LENGTHOF(sampleDigits), TRUE);
-    testSampleCharProps(u_isdigit, "u_isdigit", sampleNonDigits, LENGTHOF(sampleNonDigits), FALSE);
+    testSampleCharProps(u_isdigit, "u_isdigit", sampleDigits, UPRV_LENGTHOF(sampleDigits), TRUE);
+    testSampleCharProps(u_isdigit, "u_isdigit", sampleNonDigits, UPRV_LENGTHOF(sampleNonDigits), FALSE);
 
-    for (i = 0; i < LENGTHOF(sampleDigits); i++) {
+    for (i = 0; i < UPRV_LENGTHOF(sampleDigits); i++) {
         if (u_charDigitValue(sampleDigits[i]) != sampleDigitValues[i]) {
             log_err("error: u_charDigitValue(U+04x)=%d != %d\n",
                     sampleDigits[i], u_charDigitValue(sampleDigits[i]), sampleDigitValues[i]);
         }
     }
 
     /* Tests the ICU version #*/
     u_getVersion(realVersion);
     u_versionToString(realVersion, icuVersion);
     if (strncmp(icuVersion, U_ICU_VERSION, uprv_min((int32_t)strlen(icuVersion), (int32_t)strlen(U_ICU_VERSION))) != 0)
@@ skipping 117 matching lines @@
             { 0x5a, 36, 35 },
             { 0x7a, 36, 35 },
             { 0xff3a, 36, 35 },
             { 0xff5a, 36, 35 },
 
             /* wrong radix values */
             { 0x0031, 1, -1 },
             { 0xff3a, 37, -1 }
         };
 
-        for(i=0; i<LENGTHOF(data); ++i) {
+        for(i=0; i<UPRV_LENGTHOF(data); ++i) {
             if(u_digit(data[i].c, data[i].radix)!=data[i].value) {
                 log_err("u_digit(U+%04x, %d)=%d expected %d\n",
                         data[i].c,
                         data[i].radix,
                         u_digit(data[i].c, data[i].radix),
                         data[i].value);
             }
         }
     }
 }
@@ skipping 80 matching lines @@
 };
 
 static void
 TestPOSIX() {
     uint32_t mask;
     int32_t cl, i;
     UBool expect;
 
     mask=1;
     for(cl=0; cl<12; ++cl) {
-        for(i=0; i<LENGTHOF(posixData); ++i) {
+        for(i=0; i<UPRV_LENGTHOF(posixData); ++i) {
             expect=(UBool)((posixData[i].posixResults&mask)!=0);
             if(posixClasses[cl].fn(posixData[i].c)!=expect) {
                 log_err("u_%s(U+%04x)=%s is wrong\n",
                     posixClasses[cl].name, posixData[i].c, expect ? "FALSE" : "TRUE");
             }
         }
         mask<<=1;
     }
 }
 
 /* Tests for isControl(u_iscntrl()) and isPrintable(u_isprint()) */
 static void TestControlPrint()
 {
     const UChar32 sampleControl[] = {0x1b, 0x97, 0x82, 0x2028, 0x2029, 0x200c, 0x202b};
     const UChar32 sampleNonControl[] = {0x61, 0x0031, 0x00e2};
     const UChar32 samplePrintable[] = {0x0042, 0x005f, 0x2014};
     const UChar32 sampleNonPrintable[] = {0x200c, 0x009f, 0x001b};
     UChar32 c;
 
-    testSampleCharProps(u_iscntrl, "u_iscntrl", sampleControl, LENGTHOF(sampleControl), TRUE);
-    testSampleCharProps(u_iscntrl, "u_iscntrl", sampleNonControl, LENGTHOF(sampleNonControl), FALSE);
+    testSampleCharProps(u_iscntrl, "u_iscntrl", sampleControl, UPRV_LENGTHOF(sampleControl), TRUE);
+    testSampleCharProps(u_iscntrl, "u_iscntrl", sampleNonControl, UPRV_LENGTHOF(sampleNonControl), FALSE);
 
     testSampleCharProps(u_isprint, "u_isprint",
-                        samplePrintable, LENGTHOF(samplePrintable), TRUE);
+                        samplePrintable, UPRV_LENGTHOF(samplePrintable), TRUE);
     testSampleCharProps(u_isprint, "u_isprint",
-                        sampleNonPrintable, LENGTHOF(sampleNonPrintable), FALSE);
+                        sampleNonPrintable, UPRV_LENGTHOF(sampleNonPrintable), FALSE);
 
     /* test all ISO 8 controls */
     for(c=0; c<=0x9f; ++c) {
         if(c==0x20) {
             /* skip ASCII graphic characters and continue with DEL */
             c=0x7f;
         }
         if(!u_iscntrl(c)) {
             log_err("error: u_iscntrl(ISO 8 control U+%04x)=FALSE\n", c);
         }
@@ skipping 27 matching lines @@
     const UChar32 sampleJavaIDPart[] = {0x005f, 0x0032, 0x0045};
     const UChar32 sampleNonJavaIDPart[] = {0x2030, 0x2020, 0x0020};
     const UChar32 sampleUnicodeIDStart[] = {0x0250, 0x00e2, 0x0061};
     const UChar32 sampleNonUnicodeIDStart[] = {0x2000, 0x000a, 0x2019};
     const UChar32 sampleUnicodeIDPart[] = {0x005f, 0x0032, 0x0045};
     const UChar32 sampleNonUnicodeIDPart[] = {0x2030, 0x00a3, 0x0020};
     const UChar32 sampleIDIgnore[] = {0x0006, 0x0010, 0x206b, 0x85};
     const UChar32 sampleNonIDIgnore[] = {0x0075, 0x00a3, 0x0061};
 
     testSampleCharProps(u_isJavaIDStart, "u_isJavaIDStart",
-                        sampleJavaIDStart, LENGTHOF(sampleJavaIDStart), TRUE);
+                        sampleJavaIDStart, UPRV_LENGTHOF(sampleJavaIDStart), TRUE);
     testSampleCharProps(u_isJavaIDStart, "u_isJavaIDStart",
-                        sampleNonJavaIDStart, LENGTHOF(sampleNonJavaIDStart), FALSE);
+                        sampleNonJavaIDStart, UPRV_LENGTHOF(sampleNonJavaIDStart), FALSE);
 
     testSampleCharProps(u_isJavaIDPart, "u_isJavaIDPart",
-                        sampleJavaIDPart, LENGTHOF(sampleJavaIDPart), TRUE);
+                        sampleJavaIDPart, UPRV_LENGTHOF(sampleJavaIDPart), TRUE);
     testSampleCharProps(u_isJavaIDPart, "u_isJavaIDPart",
-                        sampleNonJavaIDPart, LENGTHOF(sampleNonJavaIDPart), FALSE);
+                        sampleNonJavaIDPart, UPRV_LENGTHOF(sampleNonJavaIDPart), FALSE);
 
     /* IDPart should imply IDStart */
     testSampleCharProps(u_isJavaIDPart, "u_isJavaIDPart",
-                        sampleJavaIDStart, LENGTHOF(sampleJavaIDStart), TRUE);
+                        sampleJavaIDStart, UPRV_LENGTHOF(sampleJavaIDStart), TRUE);
 
     testSampleCharProps(u_isIDStart, "u_isIDStart",
-                        sampleUnicodeIDStart, LENGTHOF(sampleUnicodeIDStart), TRUE);
+                        sampleUnicodeIDStart, UPRV_LENGTHOF(sampleUnicodeIDStart), TRUE);
     testSampleCharProps(u_isIDStart, "u_isIDStart",
-                        sampleNonUnicodeIDStart, LENGTHOF(sampleNonUnicodeIDStart), FALSE);
+                        sampleNonUnicodeIDStart, UPRV_LENGTHOF(sampleNonUnicodeIDStart), FALSE);
 
     testSampleCharProps(u_isIDPart, "u_isIDPart",
-                        sampleUnicodeIDPart, LENGTHOF(sampleUnicodeIDPart), TRUE);
+                        sampleUnicodeIDPart, UPRV_LENGTHOF(sampleUnicodeIDPart), TRUE);
     testSampleCharProps(u_isIDPart, "u_isIDPart",
-                        sampleNonUnicodeIDPart, LENGTHOF(sampleNonUnicodeIDPart), FALSE);
+                        sampleNonUnicodeIDPart, UPRV_LENGTHOF(sampleNonUnicodeIDPart), FALSE);
 
     /* IDPart should imply IDStart */
     testSampleCharProps(u_isIDPart, "u_isIDPart",
-                        sampleUnicodeIDStart, LENGTHOF(sampleUnicodeIDStart), TRUE);
+                        sampleUnicodeIDStart, UPRV_LENGTHOF(sampleUnicodeIDStart), TRUE);
 
     testSampleCharProps(u_isIDIgnorable, "u_isIDIgnorable",
-                        sampleIDIgnore, LENGTHOF(sampleIDIgnore), TRUE);
+                        sampleIDIgnore, UPRV_LENGTHOF(sampleIDIgnore), TRUE);
     testSampleCharProps(u_isIDIgnorable, "u_isIDIgnorable",
-                        sampleNonIDIgnore, LENGTHOF(sampleNonIDIgnore), FALSE);
+                        sampleNonIDIgnore, UPRV_LENGTHOF(sampleNonIDIgnore), FALSE);
 }
 
 /* for each line of UnicodeData.txt, check some of the properties */
 typedef struct UnicodeDataContext {
 #if UCONFIG_NO_NORMALIZATION
     const void *dummy;
 #else
     const UNormalizer2 *nfc;
     const UNormalizer2 *nfkc;
 #endif
@@ skipping 241 matching lines @@
         {0xeffff, U_UNASSIGNED}
     };
 
     int32_t i, count;
 
     if(0!=strcmp((const char *)context, "a1")) {
         log_err("error: u_enumCharTypes() passes on an incorrect context pointer\n");
         return FALSE;
     }
 
-    count=LENGTHOF(test);
+    count=UPRV_LENGTHOF(test);
     for(i=0; i<count; ++i) {
         if(start<=test[i][0] && test[i][0]<limit) {
             if(type!=(UCharCategory)test[i][1]) {
                 log_err("error: u_enumCharTypes() has range [U+%04lx, U+%04lx[ with %ld instead of U+%04lx with %ld\n",
                         start, limit, (long)type, test[i][0], test[i][1]);
             }
             /* stop at the range that includes the last test code point (increases code coverage for enumeration) */
             return i==(count-1) ? FALSE : TRUE;
         }
     }
@@ skipping 68 matching lines @@
      * Unicode 4.0.1/Public Review Issue #28 (http://www.unicode.org/review/resolved-pri.html)
      * changed some default values.
      * In particular, non-characters and unassigned Default Ignorable Code Points
      * change from L to BN.
      *
      * UCD.html version 4.0.1 does not yet reflect these changes.
      */
     if(type==U_UNASSIGNED || type==U_PRIVATE_USE_CHAR) {
         /* enumerate the intersections of defaultBidi ranges with [start..limit[ */
         c=start;
-        for(i=0; i<LENGTHOF(defaultBidi) && c<limit; ++i) {
+        for(i=0; i<UPRV_LENGTHOF(defaultBidi) && c<limit; ++i) {
             if((int32_t)c<defaultBidi[i][0]) {
                 while(c<limit && (int32_t)c<defaultBidi[i][0]) {
                     if(U_IS_UNICODE_NONCHAR(c) || u_hasBinaryProperty(c, UCHAR_DEFAULT_IGNORABLE_CODE_POINT)) {
                         shouldBeDir=U_BOUNDARY_NEUTRAL;
                     } else {
                         shouldBeDir=(UCharDirection)defaultBidi[i][1];
                     }
 
                     if( u_charDirection(c)!=shouldBeDir ||
                         u_getIntPropertyValue(c, UCHAR_BIDI_CLASS)!=shouldBeDir
@@ skipping 640 matching lines @@
             log_verbose("Ok: uprv_getCharNameCharacters() returned %s\n", aescstrdup(pat, l1));
         }
 
         uset_close(set);
         uset_close(dumb);
     }
 
     /* ### TODO: test error cases and other interesting things */
 }
 
+static void
+TestUCharFromNameUnderflow() {
+    // Ticket #10889: Underflow crash when there is no dash.
+    UErrorCode errorCode=U_ZERO_ERROR;
+    UChar32 c=u_charFromName(U_EXTENDED_CHAR_NAME, "<NO BREAK SPACE>", &errorCode);
+    if(U_SUCCESS(errorCode)) {
+        log_err("u_charFromName(<NO BREAK SPACE>) = U+%04x but should fail - %s\n", c, u_errorName(errorCode));
+    }
+
+    // Test related edge cases.
+    errorCode=U_ZERO_ERROR;
+    c=u_charFromName(U_EXTENDED_CHAR_NAME, "<-00a0>", &errorCode);
+    if(U_SUCCESS(errorCode)) {
+        log_err("u_charFromName(<-00a0>) = U+%04x but should fail - %s\n", c, u_errorName(errorCode));
+    }
+
+    errorCode=U_ZERO_ERROR;
+    c=u_charFromName(U_EXTENDED_CHAR_NAME, "<control->", &errorCode);
+    if(U_SUCCESS(errorCode)) {
+        log_err("u_charFromName(<control->) = U+%04x but should fail - %s\n", c, u_errorName(errorCode));
+    }
+
+    errorCode=U_ZERO_ERROR;
+    c=u_charFromName(U_EXTENDED_CHAR_NAME, "<control-111111>", &errorCode);
+    if(U_SUCCESS(errorCode)) {
+        log_err("u_charFromName(<control-111111>) = U+%04x but should fail - %s\n", c, u_errorName(errorCode));
+    }
+}
+
 /* test u_isMirrored() and u_charMirror() ----------------------------------- */
 
 static void
 TestMirroring() {
     USet *set;
     UErrorCode errorCode;
 
     UChar32 start, end, c2, c3;
     int32_t i;
 
@@ skipping 118 matching lines @@
     };
     
     static const RunTestData testData2[] = {
        {"((((((((((abc))))))))))", USCRIPT_LATIN}
     };
     
     static const struct {
       const RunTestData *testData;
       int32_t nRuns;
     } testDataEntries[] = {
-        {testData1, LENGTHOF(testData1)},
-        {testData2, LENGTHOF(testData2)}
+        {testData1, UPRV_LENGTHOF(testData1)},
+        {testData2, UPRV_LENGTHOF(testData2)}
     };
     
-    static const int32_t nTestEntries = LENGTHOF(testDataEntries);
+    static const int32_t nTestEntries = UPRV_LENGTHOF(testDataEntries);
     int32_t testEntry;
     
     for (testEntry = 0; testEntry < nTestEntries; testEntry += 1) {
         UChar testString[1024];
         int32_t runStarts[256];
         int32_t nTestRuns = testDataEntries[testEntry].nRuns;
         const RunTestData *testData = testDataEntries[testEntry].testData;
     
         int32_t run, stringLimit;
         UScriptRun *scriptRun = NULL;
@@ skipping 324 matching lines @@
         { 0x05ed, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT },
         { 0x07f2, UCHAR_BIDI_CLASS, U_DIR_NON_SPACING_MARK }, /* Nko, new in Unicode 5.0 */
         { 0x07fe, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT }, /* unassigned R */
         { 0x089f, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT },
         { 0xfb37, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT },
         { 0xfb42, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT },
         { 0x10806, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT },
         { 0x10909, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT },
         { 0x10fe4, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT },
 
-        { 0x0605, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT_ARABIC },
-        { 0x061c, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT_ARABIC },
+        { 0x061d, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT_ARABIC },
         { 0x063f, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT_ARABIC },
         { 0x070e, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT_ARABIC },
         { 0x0775, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT_ARABIC },
         { 0xfbc2, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT_ARABIC },
         { 0xfd90, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT_ARABIC },
         { 0xfefe, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT_ARABIC },
 
         { 0x02AF, UCHAR_BLOCK, UBLOCK_IPA_EXTENSIONS },
         { 0x0C4E, UCHAR_BLOCK, UBLOCK_TELUGU },
         { 0x155A, UCHAR_BLOCK, UBLOCK_UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS },
         { 0x1717, UCHAR_BLOCK, UBLOCK_TAGALOG },
         { 0x1900, UCHAR_BLOCK, UBLOCK_LIMBU },
-        { 0x1AFF, UCHAR_BLOCK, UBLOCK_NO_BLOCK },
+        { 0x1CBF, UCHAR_BLOCK, UBLOCK_NO_BLOCK },
         { 0x3040, UCHAR_BLOCK, UBLOCK_HIRAGANA },
         { 0x1D0FF, UCHAR_BLOCK, UBLOCK_BYZANTINE_MUSICAL_SYMBOLS },
         { 0x50000, UCHAR_BLOCK, UBLOCK_NO_BLOCK },
         { 0xEFFFF, UCHAR_BLOCK, UBLOCK_NO_BLOCK },
         { 0x10D0FF, UCHAR_BLOCK, UBLOCK_SUPPLEMENTARY_PRIVATE_USE_AREA_B },
 
         /* UCHAR_CANONICAL_COMBINING_CLASS tested for assigned characters in TestUnicodeData() */
         { 0xd7d7, UCHAR_CANONICAL_COMBINING_CLASS, 0 },
 
         { 0x00A0, UCHAR_DECOMPOSITION_TYPE, U_DT_NOBREAK },
@@ skipping 187 matching lines @@
         { 0x20CF, UCHAR_BIDI_CLASS, U_EUROPEAN_NUMBER_TERMINATOR },
 
         /* new property in Unicode 6.3 */
         { 0x0027, UCHAR_BIDI_PAIRED_BRACKET_TYPE, U_BPT_NONE },
         { 0x0028, UCHAR_BIDI_PAIRED_BRACKET_TYPE, U_BPT_OPEN },
         { 0x0029, UCHAR_BIDI_PAIRED_BRACKET_TYPE, U_BPT_CLOSE },
         { 0xFF5C, UCHAR_BIDI_PAIRED_BRACKET_TYPE, U_BPT_NONE },
         { 0xFF5B, UCHAR_BIDI_PAIRED_BRACKET_TYPE, U_BPT_OPEN },
         { 0xFF5D, UCHAR_BIDI_PAIRED_BRACKET_TYPE, U_BPT_CLOSE },
 
+        { -1, 0x700, 0 }, /* version break for Unicode 7.0 */
+
+        /* new character range with Joining_Group values */
+        { 0x10ABF, UCHAR_JOINING_GROUP, U_JG_NO_JOINING_GROUP },
+        { 0x10AC0, UCHAR_JOINING_GROUP, U_JG_MANICHAEAN_ALEPH },
+        { 0x10AC1, UCHAR_JOINING_GROUP, U_JG_MANICHAEAN_BETH },
+        { 0x10AEF, UCHAR_JOINING_GROUP, U_JG_MANICHAEAN_HUNDRED },
+        { 0x10AF0, UCHAR_JOINING_GROUP, U_JG_NO_JOINING_GROUP },
+
         /* undefined UProperty values */
         { 0x61, 0x4a7, 0 },
         { 0x234bc, 0x15ed, 0 }
     };
 
     UVersionInfo version;
     UChar32 c;
     int32_t i, result, uVersion;
     UProperty which;
 
@@ skipping 212 matching lines @@
         { 0x10301, U_NT_NONE, U_NO_NUMERIC_VALUE },
         { 0xe0033, U_NT_NONE, U_NO_NUMERIC_VALUE },
         { 0x10ffff, U_NT_NONE, U_NO_NUMERIC_VALUE },
         { 0x110000, U_NT_NONE, U_NO_NUMERIC_VALUE }
     };
 
     double nv;
     UChar32 c;
     int32_t i, type;
 
-    for(i=0; i<LENGTHOF(values); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(values); ++i) {
         c=values[i].c;
         type=u_getIntPropertyValue(c, UCHAR_NUMERIC_TYPE);
         nv=u_getNumericValue(c);
 
         if(type!=values[i].type) {
             log_err("UCHAR_NUMERIC_TYPE(U+%04lx)=%d should be %d\n", c, type, values[i].type);
         }
         if(0.000001 <= fabs(nv - values[i].numValue)) {
             log_err("u_getNumericValue(U+%04lx)=%g should be %g\n", c, nv, values[i].numValue);
         }
@@ skipping 167 matching lines @@
     int32_t i, length;
 
     U_STRING_DECL(hyphenPattern, "[:Hyphen:]", 10);
     U_STRING_DECL(dashPattern, "[:Dash:]", 8);
     U_STRING_DECL(lowerPattern, "[:Lowercase:]", 13);
     U_STRING_DECL(formatPattern, "[:Cf:]", 6);
     U_STRING_DECL(alphaPattern, "[:Alphabetic:]", 14);
 
     U_STRING_DECL(mathBlocksPattern,
         "[[:block=Mathematical Operators:][:block=Miscellaneous Mathematical Symbols-A:][:block=Miscellaneous Mathematical Symbols-B:][:block=Supplemental Mathematical Operators:][:block=Mathematical Alphanumeric Symbols:]]",
-        1+32+46+46+45+43+1+1); /* +1 for NUL */
+        214);
     U_STRING_DECL(mathPattern, "[:Math:]", 8);
     U_STRING_DECL(unassignedPattern, "[:Cn:]", 6);
     U_STRING_DECL(unknownPattern, "[:sc=Unknown:]", 14);
     U_STRING_DECL(reservedPattern, "[[:Cn:][:Co:][:Cs:]]", 20);
 
     U_STRING_INIT(hyphenPattern, "[:Hyphen:]", 10);
     U_STRING_INIT(dashPattern, "[:Dash:]", 8);
     U_STRING_INIT(lowerPattern, "[:Lowercase:]", 13);
     U_STRING_INIT(formatPattern, "[:Cf:]", 6);
     U_STRING_INIT(alphaPattern, "[:Alphabetic:]", 14);
 
     U_STRING_INIT(mathBlocksPattern,
         "[[:block=Mathematical Operators:][:block=Miscellaneous Mathematical Symbols-A:][:block=Miscellaneous Mathematical Symbols-B:][:block=Supplemental Mathematical Operators:][:block=Mathematical Alphanumeric Symbols:]]",
-        1+32+46+46+45+43+1+1); /* +1 for NUL */
+        214);
     U_STRING_INIT(mathPattern, "[:Math:]", 8);
     U_STRING_INIT(unassignedPattern, "[:Cn:]", 6);
     U_STRING_INIT(unknownPattern, "[:sc=Unknown:]", 14);
     U_STRING_INIT(reservedPattern, "[[:Cn:][:Co:][:Cs:]]", 20);
 
     /*
      * It used to be that UCD.html and its precursors said
      * "Those dashes used to mark connections between pieces of words,
      *  plus the Katakana middle dot."
      *
@@ skipping 224 matching lines @@
 
     UErrorCode errorCode=U_ZERO_ERROR;
 
     length=0;
     U16_APPEND_UNSAFE(s, length, c);
 
     if((which&CF_SIMPLE)!=0 && (c2=u_foldCase(c, 0))!=simple) {
         log_err("u_foldCase(U+%04lx, default)=U+%04lx != U+%04lx\n", (long)c, (long)c2, (long)simple);
     }
     if((which&CF_FULL)!=0) {
-        length2=u_strFoldCase(t, LENGTHOF(t), s, length, 0, &errorCode);
+        length2=u_strFoldCase(t, UPRV_LENGTHOF(t), s, length, 0, &errorCode);
         if(length2!=fullLength || 0!=u_memcmp(t, full, fullLength)) {
             log_err("u_strFoldCase(U+%04lx, default) does not fold properly\n", (long)c);
         }
     }
     if((which&CF_TURKIC)!=0) {
         if((c2=u_foldCase(c, U_FOLD_CASE_EXCLUDE_SPECIAL_I))!=turkic) {
             log_err("u_foldCase(U+%04lx, turkic)=U+%04lx != U+%04lx\n", (long)c, (long)c2, (long)simple);
         }
 
-        length2=u_strFoldCase(t, LENGTHOF(t), s, length, U_FOLD_CASE_EXCLUDE_SPECIAL_I, &errorCode);
+        length2=u_strFoldCase(t, UPRV_LENGTHOF(t), s, length, U_FOLD_CASE_EXCLUDE_SPECIAL_I, &errorCode);
         if(length2!=turkicFullLength || 0!=u_memcmp(t, turkicFull, length2)) {
             log_err("u_strFoldCase(U+%04lx, turkic) does not fold properly\n", (long)c);
         }
     }
 }
 
 /* test that c case-folds to itself */
 static void
 testFoldToSelf(UChar32 c, int which) {
     UChar s[2];
@@ skipping 155 matching lines @@
             ++i
         ) {
             do {
                 testFoldToSelf(start, CF_ALL);
             } while(++start<=end);
         }
     }
 
     uset_close(data.notSeen);
 }