X-Git-Url: https://git.saurik.com/apple/icu.git/blobdiff_plain/73c04bcfe1096173b00431f0cdc742894b15eef0..f3c0d7a59d99c2a94c6b8822291f0e42be3773c9:/icuSources/test/cintltst/cucdtst.c

diff --git a/icuSources/test/cintltst/cucdtst.c b/icuSources/test/cintltst/cucdtst.c
index 0aa15aff..15edead5 100644
--- a/icuSources/test/cintltst/cucdtst.c
+++ b/icuSources/test/cintltst/cucdtst.c
@@ -1,16 +1,18 @@
+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
 /********************************************************************
  * COPYRIGHT:
- * Copyright (c) 1997-2006, International Business Machines Corporation and
+ * Copyright (c) 1997-2016, 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
-*********************************************************************************
+********************************************************************************
 */
 
 #include <string.h>
@@ -22,6 +24,7 @@
 #include "unicode/putil.h"
 #include "unicode/ustring.h"
 #include "unicode/uloc.h"
+#include "unicode/unorm2.h"
 
 #include "cintltst.h"
 #include "putilimp.h"
@@ -31,11 +34,9 @@
 #include "uprops.h"
 #include "uset_imp.h"
 #include "usc_impl.h"
-#include "unormimp.h"
-#include "udatamem.h" /* for testing ucase_openBinary() */
+#include "udatamem.h"
 #include "cucdapi.h"
-
-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
+#include "cmemory.h"
 
 /* prototypes --------------------------------------------------------------- */
 
@@ -50,15 +51,14 @@ static void TestCodeUnit(void);
 static void TestCodePoint(void);
 static void TestCharLength(void);
 static void TestCharNames(void);
+static void TestUCharFromNameUnderflow(void);
 static void TestMirroring(void);
-/*       void TestUScriptCodeAPI(void);*/    /* defined in cucdapi.h */
 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);
 
@@ -99,13 +99,12 @@ parseUCDFile(const char *filename,
         u_parseDelimitedFile(backupPath, ';', fields, fieldCount, lineFn, context, pErrorCode);
     }
     if(U_FAILURE(*pErrorCode)) {
-        log_err("error parsing %s: %s\n", filename, u_errorName(*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[] =
     {
@@ -160,17 +159,23 @@ static const char dirStrings[][5] = {
     "RLO",
     "PDF",
     "NSM",
-    "BN"
+    "BN",
+    /* new in Unicode 6.3/ICU 52 */
+    "FSI",
+    "LRI",
+    "RLI",
+    "PDI"
 };
 
 void addUnicodeTest(TestNode** root);
 
 void addUnicodeTest(TestNode** root)
 {
-    addTest(root, &TestUnicodeData, "tsutil/cucdtst/TestUnicodeData");
     addTest(root, &TestCodeUnit, "tsutil/cucdtst/TestCodeUnit");
     addTest(root, &TestCodePoint, "tsutil/cucdtst/TestCodePoint");
     addTest(root, &TestCharLength, "tsutil/cucdtst/TestCharLength");
+    addTest(root, &TestBinaryValues, "tsutil/cucdtst/TestBinaryValues");
+    addTest(root, &TestUnicodeData, "tsutil/cucdtst/TestUnicodeData");
     addTest(root, &TestAdditionalProperties, "tsutil/cucdtst/TestAdditionalProperties");
     addTest(root, &TestNumericProperties, "tsutil/cucdtst/TestNumericProperties");
     addTest(root, &TestUpperLower, "tsutil/cucdtst/TestUpperLower");
@@ -180,13 +185,16 @@ void addUnicodeTest(TestNode** root)
     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");
     addTest(root, &TestUBiDiProps, "tsutil/cucdtst/TestUBiDiProps");
     addTest(root, &TestCaseFolding, "tsutil/cucdtst/TestCaseFolding");
 }
@@ -315,7 +323,7 @@ Checks LetterLike Symbols which were previously a source of confusion
             0x1FFC,
             0x1FFC,
         };
-        int32_t num = sizeof(expected)/sizeof(expected[0]);
+        int32_t num = UPRV_LENGTHOF(expected);
         for(i=0; i<num; i++){
             if(!u_istitle(expected[i])){
                 log_err("u_istitle failed for 0x%4X. Expected TRUE, got FALSE\n",expected[i]);
@@ -514,21 +522,33 @@ static void TestLetterNumber()
     }
 }
 
+static void testSampleCharProps(UBool propFn(UChar32), const char *propName,
+                                const UChar32 *sampleChars, int32_t sampleCharsLength,
+                                UBool expected) {
+    int32_t i;
+    for (i = 0; i < sampleCharsLength; ++i) {
+        UBool result = propFn(sampleChars[i]);
+        if (result != expected) {
+            log_err("error: character property function %s(U+%04x)=%d is wrong\n",
+                    propName, sampleChars[i], result);
+        }
+    }
+}
+
 /* Tests for isDefined(u_isdefined)(, isBaseForm(u_isbase()), isSpaceChar(u_isspace()), isWhiteSpace(), u_CharDigitValue() */
 static void TestMisc()
 {
-    static const UChar sampleSpaces[] = {0x0020, 0x00a0, 0x2000, 0x2001, 0x2005};
-    static const UChar sampleNonSpaces[] = {0x61, 0x62, 0x63, 0x64, 0x74};
-    static const UChar sampleUndefined[] = {0xfff1, 0xfff7, 0xfa6b };
-    static const UChar sampleDefined[] = {0x523E, 0x4f88, 0xfffd};
-    static const UChar sampleBase[] = {0x0061, 0x0031, 0x03d2};
-    static const UChar sampleNonBase[] = {0x002B, 0x0020, 0x203B};
+    static const UChar32 sampleSpaces[] = {0x0020, 0x00a0, 0x2000, 0x2001, 0x2005};
+    static const UChar32 sampleNonSpaces[] = {0x61, 0x62, 0x63, 0x64, 0x74};
+    static const UChar32 sampleUndefined[] = {0xfff1, 0xfff7, 0xfa6e};
+    static const UChar32 sampleDefined[] = {0x523E, 0x4f88, 0xfffd};
+    static const UChar32 sampleBase[] = {0x0061, 0x0031, 0x03d2};
+    static const UChar32 sampleNonBase[] = {0x002B, 0x0020, 0x203B};
 /*    static const UChar sampleChars[] = {0x000a, 0x0045, 0x4e00, 0xDC00, 0xFFE8, 0xFFF0};*/
-    static const UChar sampleDigits[]= {0x0030, 0x0662, 0x0F23, 0x0ED5};
-    static const UChar sampleNonDigits[] = {0x0010, 0x0041, 0x0122, 0x68FE};
-    static const UChar sampleWhiteSpaces[] = {0x2008, 0x2009, 0x200a, 0x001c, 0x000c};
-    static const UChar sampleNonWhiteSpaces[] = {0x61, 0x62, 0x3c, 0x28, 0x3f};
-
+    static const UChar32 sampleDigits[]= {0x0030, 0x0662, 0x0F23, 0x0ED5};
+    static const UChar32 sampleNonDigits[] = {0x0010, 0x0041, 0x0122, 0x68FE};
+    static const UChar32 sampleWhiteSpaces[] = {0x2008, 0x2009, 0x200a, 0x001c, 0x000c};
+    static const UChar32 sampleNonWhiteSpaces[] = {0x61, 0x62, 0x3c, 0x28, 0x3f, 0x85, 0x2007, 0xffef};
 
     static const int32_t sampleDigitValues[] = {0, 2, 3, 5};
 
@@ -540,53 +560,34 @@ static void TestMisc()
 
     memset(icuVersion, 0, U_MAX_VERSION_STRING_LENGTH);
 
-    log_verbose("Testing for isspace and nonspaces\n");
-    for (i = 0; i < 5; i++) {
-        if (!(u_isspace(sampleSpaces[i])) ||
-                (u_isspace(sampleNonSpaces[i])))
-        {
-            log_err("Space char test error : %d or %d \n", (int32_t)sampleSpaces[i], (int32_t)sampleNonSpaces[i]);
-        }
-        if (!(u_isJavaSpaceChar(sampleSpaces[i])) ||
-                (u_isJavaSpaceChar(sampleNonSpaces[i])))
-        {
-            log_err("u_isJavaSpaceChar() test error : %d or %d \n", (int32_t)sampleSpaces[i], (int32_t)sampleNonSpaces[i]);
-        }
-    }
+    testSampleCharProps(u_isspace, "u_isspace", sampleSpaces, UPRV_LENGTHOF(sampleSpaces), TRUE);
+    testSampleCharProps(u_isspace, "u_isspace", sampleNonSpaces, UPRV_LENGTHOF(sampleNonSpaces), FALSE);
 
-    log_verbose("Testing for isspace and nonspaces\n");
-    for (i = 0; i < 5; i++) {
-        if (!(u_isWhitespace(sampleWhiteSpaces[i])) ||
-                (u_isWhitespace(sampleNonWhiteSpaces[i])))
-        {
-            log_err("White Space char test error : %lx or %lx \n", sampleWhiteSpaces[i], sampleNonWhiteSpaces[i]);
-        }
-    }
+    testSampleCharProps(u_isJavaSpaceChar, "u_isJavaSpaceChar",
+                        sampleSpaces, UPRV_LENGTHOF(sampleSpaces), TRUE);
+    testSampleCharProps(u_isJavaSpaceChar, "u_isJavaSpaceChar",
+                        sampleNonSpaces, UPRV_LENGTHOF(sampleNonSpaces), FALSE);
 
-    log_verbose("Testing for isdefined\n");
-    for (i = 0; i < 3; i++) {
-        if ((u_isdefined(sampleUndefined[i])) ||
-                !(u_isdefined(sampleDefined[i])))
-        {
-            log_err("Undefined char test error : U+%04x or U+%04x\n", (int32_t)sampleUndefined[i], (int32_t)sampleDefined[i]);
-        }
-    }
+    testSampleCharProps(u_isWhitespace, "u_isWhitespace",
+                        sampleWhiteSpaces, UPRV_LENGTHOF(sampleWhiteSpaces), TRUE);
+    testSampleCharProps(u_isWhitespace, "u_isWhitespace",
+                        sampleNonWhiteSpaces, UPRV_LENGTHOF(sampleNonWhiteSpaces), FALSE);
 
-    log_verbose("Testing for isbase\n");
-    for (i = 0; i < 3; i++) {
-        if ((u_isbase(sampleNonBase[i])) ||
-                !(u_isbase(sampleBase[i])))
-        {
-            log_err("Non-baseform char test error : U+%04x or U+%04x",(int32_t)sampleNonBase[i], (int32_t)sampleBase[i]);
-        }
-    }
+    testSampleCharProps(u_isdefined, "u_isdefined",
+                        sampleDefined, UPRV_LENGTHOF(sampleDefined), TRUE);
+    testSampleCharProps(u_isdefined, "u_isdefined",
+                        sampleUndefined, UPRV_LENGTHOF(sampleUndefined), FALSE);
+
+    testSampleCharProps(u_isbase, "u_isbase", sampleBase, UPRV_LENGTHOF(sampleBase), TRUE);
+    testSampleCharProps(u_isbase, "u_isbase", sampleNonBase, UPRV_LENGTHOF(sampleNonBase), FALSE);
 
-    log_verbose("Testing for isdigit \n");
-    for (i = 0; i < 4; i++) {
-        if ((u_isdigit(sampleDigits[i]) && 
-            (u_charDigitValue(sampleDigits[i])!= sampleDigitValues[i])) ||
-            (u_isdigit(sampleNonDigits[i]))) {
-            log_err("Digit char test error : %lx   or   %lx\n", sampleDigits[i], sampleNonDigits[i]);
+    testSampleCharProps(u_isdigit, "u_isdigit", sampleDigits, UPRV_LENGTHOF(sampleDigits), TRUE);
+    testSampleCharProps(u_isdigit, "u_isdigit", sampleNonDigits, UPRV_LENGTHOF(sampleNonDigits), FALSE);
+
+    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]);
         }
     }
 
@@ -721,7 +722,7 @@ static void TestMisc()
             { 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,
@@ -822,7 +823,7 @@ TestPOSIX() {
 
     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",
@@ -836,40 +837,19 @@ TestPOSIX() {
 /* Tests for isControl(u_iscntrl()) and isPrintable(u_isprint()) */
 static void TestControlPrint()
 {
-    const UChar sampleControl[] = {0x1b, 0x97, 0x82, 0x2028, 0x2029, 0x200c, 0x202b};
-    const UChar sampleNonControl[] = {0x61, 0x0031, 0x00e2};
-    const UChar samplePrintable[] = {0x0042, 0x005f, 0x2014};
-    const UChar sampleNonPrintable[] = {0x200c, 0x009f, 0x001b};
+    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;
-    int i;
-
-    log_verbose("Testing for iscontrol\n");
-    for (i = 0; i < LENGTHOF(sampleControl); i++) {
-        if (!u_iscntrl(sampleControl[i]))
-        {
-            log_err("Control char test error : U+%04x should be control but is not\n", (int32_t)sampleControl[i]);
-        }
-    }
 
-    log_verbose("Testing for !iscontrol\n");
-    for (i = 0; i < LENGTHOF(sampleNonControl); i++) {
-        if (u_iscntrl(sampleNonControl[i]))
-        {
-            log_err("Control char test error : U+%04x should not be control but is\n", (int32_t)sampleNonControl[i]);
-        }
-    }
+    testSampleCharProps(u_iscntrl, "u_iscntrl", sampleControl, UPRV_LENGTHOF(sampleControl), TRUE);
+    testSampleCharProps(u_iscntrl, "u_iscntrl", sampleNonControl, UPRV_LENGTHOF(sampleNonControl), FALSE);
 
-    log_verbose("testing for isprintable\n");
-    for (i = 0; i < 3; i++) {
-        if (!u_isprint(samplePrintable[i]))
-        {
-            log_err("Printable char test error : U+%04x should be printable but is not\n", (int32_t)samplePrintable[i]);
-        }
-        if (u_isprint(sampleNonPrintable[i]))
-        {
-            log_err("Printable char test error : U+%04x should not be printable but is\n", (int32_t)sampleNonPrintable[i]);
-        }
-    }
+    testSampleCharProps(u_isprint, "u_isprint",
+                        samplePrintable, UPRV_LENGTHOF(samplePrintable), TRUE);
+    testSampleCharProps(u_isprint, "u_isprint",
+                        sampleNonPrintable, UPRV_LENGTHOF(sampleNonPrintable), FALSE);
 
     /* test all ISO 8 controls */
     for(c=0; c<=0x9f; ++c) {
@@ -905,68 +885,61 @@ static void TestControlPrint()
 /* u_isJavaIDStart, u_isJavaIDPart, u_isIDStart(), u_isIDPart(), u_isIDIgnorable()*/
 static void TestIdentifier()
 {
-    const UChar sampleJavaIDStart[] = {0x0071, 0x00e4, 0x005f};
-    const UChar sampleNonJavaIDStart[] = {0x0020, 0x2030, 0x0082};
-    const UChar sampleJavaIDPart[] = {0x005f, 0x0032, 0x0045};
-    const UChar sampleNonJavaIDPart[] = {0x2030, 0x2020, 0x0020};
-    const UChar sampleUnicodeIDStart[] = {0x0250, 0x00e2, 0x0061};
-    const UChar sampleNonUnicodeIDStart[] = {0x2000, 0x000a, 0x2019};
-    const UChar sampleUnicodeIDPart[] = {0x005f, 0x0032, 0x0045};
-    const UChar sampleNonUnicodeIDPart[] = {0x2030, 0x00a3, 0x0020};
-    const UChar sampleIDIgnore[] = {0x0006, 0x0010, 0x206b};
-    const UChar sampleNonIDIgnore[] = {0x0075, 0x00a3, 0x0061};
-
-    int i;
-
-    log_verbose("Testing sampleJavaID start \n");
-    for (i = 0; i < 3; i++) {
-        if (!(u_isJavaIDStart(sampleJavaIDStart[i])) ||
-                (u_isJavaIDStart(sampleNonJavaIDStart[i])))
-            log_err("Java ID Start char test error : %lx or %lx\n",
-            sampleJavaIDStart[i], sampleNonJavaIDStart[i]);
-    }
-
-    log_verbose("Testing sampleJavaID part \n");
-    for (i = 0; i < 3; i++) {
-        if (!(u_isJavaIDPart(sampleJavaIDPart[i])) ||
-                (u_isJavaIDPart(sampleNonJavaIDPart[i])))
-            log_err("Java ID Part char test error : %lx or %lx\n",
-             sampleJavaIDPart[i], sampleNonJavaIDPart[i]);
-    }
-
-    log_verbose("Testing sampleUnicodeID start \n");
-    for (i = 0; i < 3; i++) {
-        /* T_test_logln_ustr((int32_t)i); */
-        if (!(u_isIDStart(sampleUnicodeIDStart[i])) ||
-                (u_isIDStart(sampleNonUnicodeIDStart[i])))
-        {
-            log_err("Unicode ID Start char test error : %lx  or  %lx\n", sampleUnicodeIDStart[i],
-                                    sampleNonUnicodeIDStart[i]);
-        }
-    }
-
-    log_verbose("Testing sample unicode ID part \n");
-    for (i = 2; i < 3; i++) {   /* nos *** starts with 2 instead of 0, until clarified */
-        /* T_test_logln_ustr((int32_t)i); */
-        if (!(u_isIDPart(sampleUnicodeIDPart[i])) ||
-                (u_isIDPart(sampleNonUnicodeIDPart[i])))
-           {
-            log_err("Unicode ID Part char test error : %lx  or  %lx", sampleUnicodeIDPart[i], sampleNonUnicodeIDPart[i]);
-            }
-    }
-
-    log_verbose("Testing  sampleId ignore\n");
-    for (i = 0; i < 3; i++) {
-        /*T_test_logln_ustr((int32_t)i); */
-        if (!(u_isIDIgnorable(sampleIDIgnore[i])) ||
-                (u_isIDIgnorable(sampleNonIDIgnore[i])))
-        {
-            log_err("ID ignorable char test error : U+%04x  or  U+%04x\n", sampleIDIgnore[i], sampleNonIDIgnore[i]);
-        }
-    }
+    const UChar32 sampleJavaIDStart[] = {0x0071, 0x00e4, 0x005f};
+    const UChar32 sampleNonJavaIDStart[] = {0x0020, 0x2030, 0x0082};
+    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, UPRV_LENGTHOF(sampleJavaIDStart), TRUE);
+    testSampleCharProps(u_isJavaIDStart, "u_isJavaIDStart",
+                        sampleNonJavaIDStart, UPRV_LENGTHOF(sampleNonJavaIDStart), FALSE);
+
+    testSampleCharProps(u_isJavaIDPart, "u_isJavaIDPart",
+                        sampleJavaIDPart, UPRV_LENGTHOF(sampleJavaIDPart), TRUE);
+    testSampleCharProps(u_isJavaIDPart, "u_isJavaIDPart",
+                        sampleNonJavaIDPart, UPRV_LENGTHOF(sampleNonJavaIDPart), FALSE);
+
+    /* IDPart should imply IDStart */
+    testSampleCharProps(u_isJavaIDPart, "u_isJavaIDPart",
+                        sampleJavaIDStart, UPRV_LENGTHOF(sampleJavaIDStart), TRUE);
+
+    testSampleCharProps(u_isIDStart, "u_isIDStart",
+                        sampleUnicodeIDStart, UPRV_LENGTHOF(sampleUnicodeIDStart), TRUE);
+    testSampleCharProps(u_isIDStart, "u_isIDStart",
+                        sampleNonUnicodeIDStart, UPRV_LENGTHOF(sampleNonUnicodeIDStart), FALSE);
+
+    testSampleCharProps(u_isIDPart, "u_isIDPart",
+                        sampleUnicodeIDPart, UPRV_LENGTHOF(sampleUnicodeIDPart), TRUE);
+    testSampleCharProps(u_isIDPart, "u_isIDPart",
+                        sampleNonUnicodeIDPart, UPRV_LENGTHOF(sampleNonUnicodeIDPart), FALSE);
+
+    /* IDPart should imply IDStart */
+    testSampleCharProps(u_isIDPart, "u_isIDPart",
+                        sampleUnicodeIDStart, UPRV_LENGTHOF(sampleUnicodeIDStart), TRUE);
+
+    testSampleCharProps(u_isIDIgnorable, "u_isIDIgnorable",
+                        sampleIDIgnore, UPRV_LENGTHOF(sampleIDIgnore), TRUE);
+    testSampleCharProps(u_isIDIgnorable, "u_isIDIgnorable",
+                        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
+} UnicodeDataContext;
+
 /*
  * ### TODO
  * This test fails incorrectly if the First or Last code point of a repetitive area
@@ -986,11 +959,19 @@ unicodeDataLineFn(void *context,
                   UErrorCode *pErrorCode)
 {
     char buffer[100];
+    const char *d;
     char *end;
     uint32_t value;
     UChar32 c;
     int32_t i;
     int8_t type;
+    int32_t dt;
+    UChar dm[32], s[32];
+    int32_t dmLength, length;
+
+#if !UCONFIG_NO_NORMALIZATION
+    const UNormalizer2 *nfc, *nfkc;
+#endif
 
     /* get the character code, field 0 */
     c=strtoul(fields[0][0], &end, 16);
@@ -1027,20 +1008,116 @@ unicodeDataLineFn(void *context,
     if(value!=u_getCombiningClass(c) || value!=(uint32_t)u_getIntPropertyValue(c, UCHAR_CANONICAL_COMBINING_CLASS)) {
         log_err("error: u_getCombiningClass(U+%04lx)==%hu instead of %lu\n", c, u_getCombiningClass(c), value);
     }
+    nfkc=((UnicodeDataContext *)context)->nfkc;
+    if(value!=unorm2_getCombiningClass(nfkc, c)) {
+        log_err("error: unorm2_getCombiningClass(nfkc, U+%04lx)==%hu instead of %lu\n", c, unorm2_getCombiningClass(nfkc, c), value);
+    }
 #endif
 
     /* get BiDi category, field 4 */
     *fields[4][1]=0;
     i=MakeDir(fields[4][0]);
+#if U_ICU_VERSION_MAJOR_NUM!=59
+    // TODO: Remove this version check, see ticket #13061.
     if(i!=u_charDirection(c) || i!=u_getIntPropertyValue(c, UCHAR_BIDI_CLASS)) {
         log_err("error: u_charDirection(U+%04lx)==%u instead of %u (%s)\n", c, u_charDirection(c), MakeDir(fields[4][0]), fields[4][0]);
     }
+#endif
+
+    /* get Decomposition_Type & Decomposition_Mapping, field 5 */
+    d=NULL;
+    if(fields[5][0]==fields[5][1]) {
+        /* no decomposition, except UnicodeData.txt omits Hangul syllable decompositions */
+        if(c==0xac00 || c==0xd7a3) {
+            dt=U_DT_CANONICAL;
+        } else {
+            dt=U_DT_NONE;
+        }
+    } else {
+        d=fields[5][0];
+        *fields[5][1]=0;
+        dt=UCHAR_INVALID_CODE;
+        if(*d=='<') {
+            end=strchr(++d, '>');
+            if(end!=NULL) {
+                *end=0;
+                dt=u_getPropertyValueEnum(UCHAR_DECOMPOSITION_TYPE, d);
+                d=u_skipWhitespace(end+1);
+            }
+        } else {
+            dt=U_DT_CANONICAL;
+        }
+    }
+    if(dt>U_DT_NONE) {
+        if(c==0xac00) {
+            dm[0]=0x1100;
+            dm[1]=0x1161;
+            dm[2]=0;
+            dmLength=2;
+        } else if(c==0xd7a3) {
+            dm[0]=0xd788;
+            dm[1]=0x11c2;
+            dm[2]=0;
+            dmLength=2;
+        } else {
+            dmLength=u_parseString(d, dm, 32, NULL, pErrorCode);
+        }
+    } else {
+        dmLength=-1;
+    }
+    if(dt<0 || U_FAILURE(*pErrorCode)) {
+        log_err("error in UnicodeData.txt: syntax error in U+%04lX decomposition field\n", (long)c);
+        return;
+    }
+#if !UCONFIG_NO_NORMALIZATION
+    i=u_getIntPropertyValue(c, UCHAR_DECOMPOSITION_TYPE);
+    if(i!=dt) {
+        log_err("error: u_getIntPropertyValue(U+%04lx, UCHAR_DECOMPOSITION_TYPE)==%d instead of %d\n", c, i, dt);
+    }
+    /* Expect Decomposition_Mapping=nfkc.getRawDecomposition(c). */
+    length=unorm2_getRawDecomposition(nfkc, c, s, 32, pErrorCode);
+    if(U_FAILURE(*pErrorCode) || length!=dmLength || (length>0 && 0!=u_strcmp(s, dm))) {
+        log_err("error: unorm2_getRawDecomposition(nfkc, U+%04lx)==%d instead of %d "
+                "or the Decomposition_Mapping is different (%s)\n",
+                c, length, dmLength, u_errorName(*pErrorCode));
+        return;
+    }
+    /* For canonical decompositions only, expect Decomposition_Mapping=nfc.getRawDecomposition(c). */
+    if(dt!=U_DT_CANONICAL) {
+        dmLength=-1;
+    }
+    nfc=((UnicodeDataContext *)context)->nfc;
+    length=unorm2_getRawDecomposition(nfc, c, s, 32, pErrorCode);
+    if(U_FAILURE(*pErrorCode) || length!=dmLength || (length>0 && 0!=u_strcmp(s, dm))) {
+        log_err("error: unorm2_getRawDecomposition(nfc, U+%04lx)==%d instead of %d "
+                "or the Decomposition_Mapping is different (%s)\n",
+                c, length, dmLength, u_errorName(*pErrorCode));
+        return;
+    }
+    /* recompose */
+    if(dt==U_DT_CANONICAL && !u_hasBinaryProperty(c, UCHAR_FULL_COMPOSITION_EXCLUSION)) {
+        UChar32 a, b, composite;
+        i=0;
+        U16_NEXT(dm, i, dmLength, a);
+        U16_NEXT(dm, i, dmLength, b);
+        /* i==dmLength */
+        composite=unorm2_composePair(nfc, a, b);
+        if(composite!=c) {
+            log_err("error: nfc U+%04lX decomposes to U+%04lX+U+%04lX but does not compose back (instead U+%04lX)\n",
+                    (long)c, (long)a, (long)b, (long)composite);
+        }
+        /*
+         * Note: NFKC has fewer round-trip mappings than NFC,
+         * so we can't just test unorm2_composePair(nfkc, a, b) here without further data.
+         */
+    }
+#endif
 
     /* get ISO Comment, field 11 */
     *fields[11][1]=0;
     i=u_getISOComment(c, buffer, sizeof(buffer), pErrorCode);
     if(U_FAILURE(*pErrorCode) || 0!=strcmp(fields[11][0], buffer)) {
-        log_err("error: u_getISOComment(U+%04lx) wrong (%s): \"%s\" should be \"%s\"\n",
+        log_err_status(*pErrorCode, "error: u_getISOComment(U+%04lx) wrong (%s): \"%s\" should be \"%s\"\n",
             c, u_errorName(*pErrorCode),
             U_FAILURE(*pErrorCode) ? buffer : "[error]",
             fields[11][0]);
@@ -1115,7 +1192,7 @@ enumTypeRange(const void *context, UChar32 start, UChar32 limit, UCharCategory t
         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]) {
@@ -1138,12 +1215,15 @@ enumTypeRange(const void *context, UChar32 start, UChar32 limit, UCharCategory t
 
 static UBool U_CALLCONV
 enumDefaultsRange(const void *context, UChar32 start, UChar32 limit, UCharCategory type) {
-    /* default Bidi classes for unassigned code points */
+    /* default Bidi classes for unassigned code points, from the DerivedBidiClass.txt header */
     static const int32_t defaultBidi[][2]={ /* { limit, class } */
         { 0x0590, U_LEFT_TO_RIGHT },
         { 0x0600, U_RIGHT_TO_LEFT },
         { 0x07C0, U_RIGHT_TO_LEFT_ARABIC },
-        { 0x0900, U_RIGHT_TO_LEFT },
+        { 0x08A0, U_RIGHT_TO_LEFT },
+        { 0x0900, U_RIGHT_TO_LEFT_ARABIC },  /* Unicode 6.1 changes U+08A0..U+08FF from R to AL */
+        { 0x20A0, U_LEFT_TO_RIGHT },
+        { 0x20D0, U_EUROPEAN_NUMBER_TERMINATOR },  /* Unicode 6.3 changes the currency symbols block U+20A0..U+20CF to default to ET not L */
         { 0xFB1D, U_LEFT_TO_RIGHT },
         { 0xFB50, U_RIGHT_TO_LEFT },
         { 0xFE00, U_RIGHT_TO_LEFT_ARABIC },
@@ -1151,6 +1231,10 @@ enumDefaultsRange(const void *context, UChar32 start, UChar32 limit, UCharCatego
         { 0xFF00, U_RIGHT_TO_LEFT_ARABIC },
         { 0x10800, U_LEFT_TO_RIGHT },
         { 0x11000, U_RIGHT_TO_LEFT },
+        { 0x1E800, U_LEFT_TO_RIGHT },  /* new default-R range in Unicode 5.2: U+1E800 - U+1EFFF */
+        { 0x1EE00, U_RIGHT_TO_LEFT },
+        { 0x1EF00, U_RIGHT_TO_LEFT_ARABIC },  /* Unicode 6.1 changes U+1EE00..U+1EEFF from R to AL */
+        { 0x1F000, U_RIGHT_TO_LEFT },
         { 0x110000, U_LEFT_TO_RIGHT }
     };
 
@@ -1179,25 +1263,12 @@ enumDefaultsRange(const void *context, UChar32 start, UChar32 limit, UCharCatego
 
     /*
      * Verify default Bidi classes.
-     * For recent Unicode versions, see UCD.html.
-     *
-     * For older Unicode versions:
-     * See table 3-7 "Bidirectional Character Types" in UAX #9.
-     * http://www.unicode.org/reports/tr9/
-     *
-     * See also DerivedBidiClass.txt for Cn code points!
-     *
-     * 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.
+     * See DerivedBidiClass.txt, especially for unassigned code points.
      */
     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)) {
@@ -1206,12 +1277,15 @@ enumDefaultsRange(const void *context, UChar32 start, UChar32 limit, UCharCatego
                         shouldBeDir=(UCharDirection)defaultBidi[i][1];
                     }
 
+#if U_ICU_VERSION_MAJOR_NUM!=59
+// TODO: Remove this version check, see ticket #13061.
                     if( u_charDirection(c)!=shouldBeDir ||
                         u_getIntPropertyValue(c, UCHAR_BIDI_CLASS)!=shouldBeDir
                     ) {
                         log_err("error: u_charDirection(unassigned/PUA U+%04lx)=%s should be %s\n",
                             c, dirStrings[u_charDirection(c)], dirStrings[shouldBeDir]);
                     }
+#endif
                     ++c;
                 }
             }
@@ -1231,6 +1305,8 @@ static void TestUnicodeData()
     UChar32 c;
     int8_t type;
 
+    UnicodeDataContext context;
+
     u_versionFromString(expectVersionArray, U_UNICODE_VERSION);
     u_getUnicodeVersion(versionArray);
     if(memcmp(versionArray, expectVersionArray, U_MAX_VERSION_LENGTH) != 0)
@@ -1252,7 +1328,15 @@ static void TestUnicodeData()
     }
 
     errorCode=U_ZERO_ERROR;
-    parseUCDFile("UnicodeData.txt", fields, 15, unicodeDataLineFn, NULL, &errorCode);
+#if !UCONFIG_NO_NORMALIZATION
+    context.nfc=unorm2_getNFCInstance(&errorCode);
+    context.nfkc=unorm2_getNFKCInstance(&errorCode);
+    if(U_FAILURE(errorCode)) {
+        log_data_err("error: unable to open an NFC or NFKC UNormalizer2 - %s\n", u_errorName(errorCode));
+        return;
+    }
+#endif
+    parseUCDFile("UnicodeData.txt", fields, 15, unicodeDataLineFn, &context, &errorCode);
     if(U_FAILURE(errorCode)) {
         return; /* if we couldn't parse UnicodeData.txt, we should return */
     }
@@ -1305,7 +1389,7 @@ static void TestCodeUnit(){
 
     int32_t i;
 
-    for(i=0; i<(int32_t)(sizeof(codeunit)/sizeof(codeunit[0])); i++){
+    for(i=0; i<UPRV_LENGTHOF(codeunit); i++){
         UChar c=codeunit[i];
         if(i<4){
             if(!(UTF_IS_SINGLE(c)) || (UTF_IS_LEAD(c)) || (UTF_IS_TRAIL(c)) ||(UTF_IS_SURROGATE(c))){
@@ -1357,7 +1441,7 @@ static void TestCodePoint(){
         0xfffe,
     };
     int32_t i;
-    for(i=0; i<(int32_t)(sizeof(codePoint)/sizeof(codePoint[0])); i++){
+    for(i=0; i<UPRV_LENGTHOF(codePoint); i++){
         UChar32 c=codePoint[i];
         if(i<6){
             if(!UTF_IS_SURROGATE(c) || !U_IS_SURROGATE(c) || !U16_IS_SURROGATE(c)){
@@ -1399,7 +1483,7 @@ static void TestCodePoint(){
                 log_err("ERROR: isError() failed for U+%04x\n", c);
             }
         }
-        else if(i >=18 && i<(int32_t)(sizeof(codePoint)/sizeof(codePoint[0]))){
+        else if(i >=18 && i<UPRV_LENGTHOF(codePoint)){
             if(UTF_IS_SURROGATE(c) || U_IS_SURROGATE(c) || U16_IS_SURROGATE(c)){
                 log_err("ERROR: isSurrogate() failed for U+%04x\n", c);
             }
@@ -1451,10 +1535,10 @@ static void TestCharLength()
 
     int32_t i;
     UBool multiple;
-    for(i=0; i<(int32_t)(sizeof(codepoint)/sizeof(codepoint[0])); i=(int16_t)(i+2)){
+    for(i=0; i<UPRV_LENGTHOF(codepoint); i=(int16_t)(i+2)){
         UChar32 c=codepoint[i+1];
         if(UTF_CHAR_LENGTH(c) != codepoint[i] || U16_LENGTH(c) != codepoint[i]){
-            log_err("The no: of code units for U+%04x:- Expected: %d Got: %d\n", c, codepoint[i], UTF_CHAR_LENGTH(c));
+            log_err("The no: of code units for U+%04x:- Expected: %d Got: %d\n", c, codepoint[i], U16_LENGTH(c));
         }
         multiple=(UBool)(codepoint[i] == 1 ? FALSE : TRUE);
         if(UTF_NEED_MULTIPLE_UCHAR(c) != multiple){
@@ -1483,7 +1567,7 @@ static int32_t MakeProp(char* str)
 static int32_t MakeDir(char* str) 
 {
     int32_t pos = 0;
-    for (pos = 0; pos < 19; pos++) {
+    for (pos = 0; pos < U_CHAR_DIRECTION_COUNT; pos++) {
         if (strcmp(str, dirStrings[pos]) == 0) {
             return pos;
         }
@@ -1495,19 +1579,29 @@ static int32_t MakeDir(char* str)
 
 static const struct {
     uint32_t code;
-    const char *name, *oldName, *extName;
+    const char *name, *oldName, *extName, *alias;
 } names[]={
     {0x0061, "LATIN SMALL LETTER A", "", "LATIN SMALL LETTER A"},
-    {0x0284, "LATIN SMALL LETTER DOTLESS J WITH STROKE AND HOOK", "LATIN SMALL LETTER DOTLESS J BAR HOOK", "LATIN SMALL LETTER DOTLESS J WITH STROKE AND HOOK" },
+    {0x01a2, "LATIN CAPITAL LETTER OI", "",
+             "LATIN CAPITAL LETTER OI",
+             "LATIN CAPITAL LETTER GHA"},
+    {0x0284, "LATIN SMALL LETTER DOTLESS J WITH STROKE AND HOOK", "",
+             "LATIN SMALL LETTER DOTLESS J WITH STROKE AND HOOK" },
+    {0x0fd0, "TIBETAN MARK BSKA- SHOG GI MGO RGYAN", "",
+             "TIBETAN MARK BSKA- SHOG GI MGO RGYAN",
+             "TIBETAN MARK BKA- SHOG GI MGO RGYAN"},
     {0x3401, "CJK UNIFIED IDEOGRAPH-3401", "", "CJK UNIFIED IDEOGRAPH-3401" },
     {0x7fed, "CJK UNIFIED IDEOGRAPH-7FED", "", "CJK UNIFIED IDEOGRAPH-7FED" },
     {0xac00, "HANGUL SYLLABLE GA", "", "HANGUL SYLLABLE GA" },
     {0xd7a3, "HANGUL SYLLABLE HIH", "", "HANGUL SYLLABLE HIH" },
     {0xd800, "", "", "<lead surrogate-D800>" },
     {0xdc00, "", "", "<trail surrogate-DC00>" },
-    {0xff08, "FULLWIDTH LEFT PARENTHESIS", "FULLWIDTH OPENING PARENTHESIS", "FULLWIDTH LEFT PARENTHESIS" },
+    {0xff08, "FULLWIDTH LEFT PARENTHESIS", "", "FULLWIDTH LEFT PARENTHESIS" },
     {0xffe5, "FULLWIDTH YEN SIGN", "", "FULLWIDTH YEN SIGN" },
     {0xffff, "", "", "<noncharacter-FFFF>" },
+    {0x1d0c5, "BYZANTINE MUSICAL SYMBOL FHTORA SKLIRON CHROMA VASIS", "",
+              "BYZANTINE MUSICAL SYMBOL FHTORA SKLIRON CHROMA VASIS",
+              "BYZANTINE MUSICAL SYMBOL FTHORA SKLIRON CHROMA VASIS"},
     {0x23456, "CJK UNIFIED IDEOGRAPH-23456", "", "CJK UNIFIED IDEOGRAPH-23456" }
 };
 
@@ -1516,6 +1610,7 @@ enumCharNamesFn(void *context,
                 UChar32 code, UCharNameChoice nameChoice,
                 const char *name, int32_t length) {
     int32_t *pCount=(int32_t *)context;
+    const char *expected;
     int i;
 
     if(length<=0 || length!=(int32_t)strlen(name)) {
@@ -1525,7 +1620,7 @@ enumCharNamesFn(void *context,
     }
 
     ++*pCount;
-    for(i=0; i<sizeof(names)/sizeof(names[0]); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(names); ++i) {
         if(code==(UChar32)names[i].code) {
             switch (nameChoice) {
                 case U_EXTENDED_CHAR_NAME:
@@ -1539,8 +1634,15 @@ enumCharNamesFn(void *context,
                     }
                     break;
                 case U_UNICODE_10_CHAR_NAME:
-                    if(names[i].oldName[0]==0 || 0!=strcmp(name, names[i].oldName)) {
-                        log_err("u_enumCharName(0x%lx - 1.0)=%s instead of %s\n", code, name, names[i].oldName);
+                    expected=names[i].oldName;
+                    if(expected[0]==0 || 0!=strcmp(name, expected)) {
+                        log_err("u_enumCharName(0x%lx - 1.0)=%s instead of %s\n", code, name, expected);
+                    }
+                    break;
+                case U_CHAR_NAME_ALIAS:
+                    expected=names[i].alias;
+                    if(expected==NULL || expected[0]==0 || 0!=strcmp(name, expected)) {
+                        log_err("u_enumCharName(0x%lx - alias)=%s instead of %s\n", code, name, expected);
                     }
                     break;
                 case U_CHAR_NAME_CHOICE_COUNT:
@@ -1596,6 +1698,7 @@ TestCharNames() {
     static char name[80];
     UErrorCode errorCode=U_ZERO_ERROR;
     struct enumExtCharNamesContext extContext;
+    const char *expected;
     int32_t length;
     UChar32 c;
     int32_t i;
@@ -1612,7 +1715,7 @@ TestCharNames() {
     /* ### TODO same tests for max ISO comment length as for max name length */
 
     log_verbose("Testing u_charName()\n");
-    for(i=0; i<(int32_t)(sizeof(names)/sizeof(names[0])); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(names); ++i) {
         /* modern Unicode character name */
         length=u_charName(names[i].code, U_UNICODE_CHAR_NAME, name, sizeof(name), &errorCode);
         if(U_FAILURE(errorCode)) {
@@ -1656,6 +1759,35 @@ TestCharNames() {
                 log_err("u_charFromName(%s - 1.0) gets 0x%lx instead of 0x%lx\n", names[i].oldName, c, names[i].code);
             }
         }
+
+        /* Unicode character name alias */
+        length=u_charName(names[i].code, U_CHAR_NAME_ALIAS, name, sizeof(name), &errorCode);
+        if(U_FAILURE(errorCode)) {
+            log_err("u_charName(0x%lx - alias) error %s\n", names[i].code, u_errorName(errorCode));
+            return;
+        }
+        expected=names[i].alias;
+        if(expected==NULL) {
+            expected="";
+        }
+        if(length<0 || (length>0 && 0!=strcmp(name, expected)) || length!=(uint16_t)strlen(name)) {
+            log_err("u_charName(0x%lx - alias) gets %s length %ld instead of nothing or %s\n",
+                    names[i].code, name, length, expected);
+        }
+
+        /* find the Unicode character name alias if it is stored (length>0 means that we could read it) */
+        if(expected[0]!=0 /* && length>0 */) {
+            c=u_charFromName(U_CHAR_NAME_ALIAS, expected, &errorCode);
+            if(U_FAILURE(errorCode)) {
+                log_err("u_charFromName(%s - alias) error %s\n",
+                        expected, u_errorName(errorCode));
+                return;
+            }
+            if(c!=(UChar32)names[i].code) {
+                log_err("u_charFromName(%s - alias) gets 0x%lx instead of 0x%lx\n",
+                        expected, c, names[i].code);
+            }
+        }
     }
 
     /* test u_enumCharNames() */
@@ -1680,7 +1812,7 @@ TestCharNames() {
     }
 
     /* Test getCharNameCharacters */
-    if(!QUICK) {
+    if(!getTestOption(QUICK_OPTION)) {
         enum { BUFSIZE = 256 };
         UErrorCode ec = U_ZERO_ERROR;
         char buf[BUFSIZE];
@@ -1789,7 +1921,7 @@ TestCharNames() {
         if (!ok) {
             log_err("FAIL: uprv_getCharNameCharacters() returned %s, expected %s (too many lowercase a-z are ok)\n",
                     aescstrdup(pat, l1), aescstrdup(dumbPat, l2));
-        } else if(VERBOSITY) {
+        } else if(getTestOption(VERBOSITY_OPTION)) {
             log_verbose("Ok: uprv_getCharNameCharacters() returned %s\n", aescstrdup(pat, l1));
         }
 
@@ -1800,6 +1932,35 @@ TestCharNames() {
     /* ### 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
@@ -1825,7 +1986,9 @@ TestMirroring() {
     log_verbose("Testing u_charMirror()\n");
     if(!(u_charMirror(0x3c)==0x3e && u_charMirror(0x5d)==0x5b && u_charMirror(0x208d)==0x208e && u_charMirror(0x3017)==0x3016 &&
          u_charMirror(0xbb)==0xab && u_charMirror(0x2215)==0x29F5 && u_charMirror(0x29F5)==0x2215 && /* large delta between the code points */
-         u_charMirror(0x2e)==0x2e && u_charMirror(0x6f3)==0x6f3 && u_charMirror(0x301c)==0x301c && u_charMirror(0xa4ab)==0xa4ab 
+         u_charMirror(0x2e)==0x2e && u_charMirror(0x6f3)==0x6f3 && u_charMirror(0x301c)==0x301c && u_charMirror(0xa4ab)==0xa4ab &&
+         /* see Unicode Corrigendum #6 at http://www.unicode.org/versions/corrigendum6.html */
+         u_charMirror(0x2018)==0x2018 && u_charMirror(0x201b)==0x201b && u_charMirror(0x301d)==0x301d
          )
     ) {
         log_err("u_charMirror() does not work correctly\n");
@@ -1836,7 +1999,7 @@ TestMirroring() {
     set=uset_openPattern(mirroredPattern, 17, &errorCode);
 
     if (U_FAILURE(errorCode)) {
-        log_data_err("uset_openPattern(mirroredPattern, 17, &errorCode) failed!");
+        log_data_err("uset_openPattern(mirroredPattern, 17, &errorCode) failed!\n");
     } else {
         for(i=0; 0==uset_getItem(set, i, &start, &end, NULL, 0, &errorCode); ++i) {
             do {
@@ -1845,6 +2008,18 @@ TestMirroring() {
                 if(c3!=start) {
                     log_err("u_charMirror() does not roundtrip: U+%04lx->U+%04lx->U+%04lx\n", (long)start, (long)c2, (long)c3);
                 }
+                c3=u_getBidiPairedBracket(start);
+                if(u_getIntPropertyValue(start, UCHAR_BIDI_PAIRED_BRACKET_TYPE)==U_BPT_NONE) {
+                    if(c3!=start) {
+                        log_err("u_getBidiPairedBracket(U+%04lx) != self for bpt(c)==None\n",
+                                (long)start);
+                    }
+                } else {
+                    if(c3!=c2) {
+                        log_err("u_getBidiPairedBracket(U+%04lx) != U+%04lx = bmg(c)'\n",
+                                (long)start, (long)c2);
+                    }
+                }
             } while(++start<=end);
         }
     }
@@ -1924,11 +2099,11 @@ TestUScriptRunAPI()
       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) {
@@ -2084,7 +2259,7 @@ TestAdditionalProperties() {
     };
 
     /* test data for u_hasBinaryProperty() */
-    static int32_t
+    static const int32_t
     props[][3]={ /* code point, property, value */
         { 0x0627, UCHAR_ALPHABETIC, TRUE },
         { 0x1034a, UCHAR_ALPHABETIC, TRUE },
@@ -2099,6 +2274,12 @@ TestAdditionalProperties() {
         { 0x003c, UCHAR_BIDI_MIRRORED, TRUE },
         { 0x003d, UCHAR_BIDI_MIRRORED, FALSE },
 
+        /* see Unicode Corrigendum #6 at http://www.unicode.org/versions/corrigendum6.html */
+        { 0x2018, UCHAR_BIDI_MIRRORED, FALSE },
+        { 0x201d, UCHAR_BIDI_MIRRORED, FALSE },
+        { 0x201f, UCHAR_BIDI_MIRRORED, FALSE },
+        { 0x301e, UCHAR_BIDI_MIRRORED, FALSE },
+
         { 0x058a, UCHAR_DASH, TRUE },
         { 0x007e, UCHAR_DASH, FALSE },
 
@@ -2205,15 +2386,19 @@ TestAdditionalProperties() {
         { 0xfe02, UCHAR_DEFAULT_IGNORABLE_CODE_POINT, TRUE },
         { 0x1801, UCHAR_DEFAULT_IGNORABLE_CODE_POINT, FALSE },
 
-        { 0x0341, UCHAR_DEPRECATED, TRUE },
-        { 0xe0041, UCHAR_DEPRECATED, FALSE },
+        { 0x0149, UCHAR_DEPRECATED, TRUE },         /* changed in Unicode 5.2 */
+        { 0x0341, UCHAR_DEPRECATED, FALSE },        /* changed in Unicode 5.2 */
+        { 0xe0001, UCHAR_DEPRECATED, TRUE },        /* changed from Unicode 5 to 5.1 */
+        { 0xe0100, UCHAR_DEPRECATED, FALSE },
 
         { 0x00a0, UCHAR_GRAPHEME_BASE, TRUE },
         { 0x0a4d, UCHAR_GRAPHEME_BASE, FALSE },
-        { 0xff9f, UCHAR_GRAPHEME_BASE, TRUE },      /* changed from Unicode 3.2 to 4 */
+        { 0xff9d, UCHAR_GRAPHEME_BASE, TRUE },
+        { 0xff9f, UCHAR_GRAPHEME_BASE, FALSE },     /* changed from Unicode 3.2 to 4 and again from 5 to 5.1 */
 
         { 0x0300, UCHAR_GRAPHEME_EXTEND, TRUE },
-        { 0xff9f, UCHAR_GRAPHEME_EXTEND, FALSE },   /* changed from Unicode 3.2 to 4 */
+        { 0xff9d, UCHAR_GRAPHEME_EXTEND, FALSE },
+        { 0xff9f, UCHAR_GRAPHEME_EXTEND, TRUE },    /* changed from Unicode 3.2 to 4 and again from 5 to 5.1 */
         { 0x0603, UCHAR_GRAPHEME_EXTEND, FALSE },
 
         { 0x0a4d, UCHAR_GRAPHEME_LINK, TRUE },
@@ -2256,15 +2441,14 @@ TestAdditionalProperties() {
         { 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 */
-        { 0x08ba, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT },
+        { 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 },
 
-        { 0x0606, 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 },
@@ -2277,7 +2461,7 @@ TestAdditionalProperties() {
         { 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 },
@@ -2316,14 +2500,14 @@ TestAdditionalProperties() {
         { 0x10EEEE, UCHAR_EAST_ASIAN_WIDTH, U_EA_AMBIGUOUS },
 
         /* UCHAR_GENERAL_CATEGORY tested for assigned characters in TestUnicodeData() */
-        { 0xd7d7, UCHAR_GENERAL_CATEGORY, 0 },
+        { 0xd7c7, UCHAR_GENERAL_CATEGORY, 0 },
+        { 0xd7d7, UCHAR_GENERAL_CATEGORY, U_OTHER_LETTER },     /* changed in Unicode 5.2 */
 
         { 0x0444, UCHAR_JOINING_GROUP, U_JG_NO_JOINING_GROUP },
         { 0x0639, UCHAR_JOINING_GROUP, U_JG_AIN },
         { 0x072A, UCHAR_JOINING_GROUP, U_JG_DALATH_RISH },
         { 0x0647, UCHAR_JOINING_GROUP, U_JG_HEH },
         { 0x06C1, UCHAR_JOINING_GROUP, U_JG_HEH_GOAL },
-        { 0x06C3, UCHAR_JOINING_GROUP, U_JG_HAMZA_ON_HEH_GOAL },
 
         { 0x200C, UCHAR_JOINING_TYPE, U_JT_NON_JOINING },
         { 0x200D, UCHAR_JOINING_TYPE, U_JT_JOIN_CAUSING },
@@ -2355,27 +2539,43 @@ TestAdditionalProperties() {
 
         /* UCHAR_SCRIPT tested in TestUScriptCodeAPI() */
 
+        { 0x10ff, UCHAR_HANGUL_SYLLABLE_TYPE, 0 },
         { 0x1100, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LEADING_JAMO },
         { 0x1111, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LEADING_JAMO },
         { 0x1159, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LEADING_JAMO },
+        { 0x115a, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LEADING_JAMO },     /* changed in Unicode 5.2 */
+        { 0x115e, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LEADING_JAMO },     /* changed in Unicode 5.2 */
         { 0x115f, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LEADING_JAMO },
 
+        { 0xa95f, UCHAR_HANGUL_SYLLABLE_TYPE, 0 },
+        { 0xa960, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LEADING_JAMO },     /* changed in Unicode 5.2 */
+        { 0xa97c, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LEADING_JAMO },     /* changed in Unicode 5.2 */
+        { 0xa97d, UCHAR_HANGUL_SYLLABLE_TYPE, 0 },
+
         { 0x1160, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_VOWEL_JAMO },
         { 0x1161, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_VOWEL_JAMO },
         { 0x1172, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_VOWEL_JAMO },
         { 0x11a2, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_VOWEL_JAMO },
+        { 0x11a3, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_VOWEL_JAMO },       /* changed in Unicode 5.2 */
+        { 0x11a7, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_VOWEL_JAMO },       /* changed in Unicode 5.2 */
+
+        { 0xd7af, UCHAR_HANGUL_SYLLABLE_TYPE, 0 },
+        { 0xd7b0, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_VOWEL_JAMO },       /* changed in Unicode 5.2 */
+        { 0xd7c6, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_VOWEL_JAMO },       /* changed in Unicode 5.2 */
+        { 0xd7c7, UCHAR_HANGUL_SYLLABLE_TYPE, 0 },
 
         { 0x11a8, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_TRAILING_JAMO },
         { 0x11b8, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_TRAILING_JAMO },
         { 0x11c8, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_TRAILING_JAMO },
         { 0x11f9, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_TRAILING_JAMO },
+        { 0x11fa, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_TRAILING_JAMO },    /* changed in Unicode 5.2 */
+        { 0x11ff, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_TRAILING_JAMO },    /* changed in Unicode 5.2 */
+        { 0x1200, UCHAR_HANGUL_SYLLABLE_TYPE, 0 },
 
-        { 0x115a, UCHAR_HANGUL_SYLLABLE_TYPE, 0 },
-        { 0x115e, UCHAR_HANGUL_SYLLABLE_TYPE, 0 },
-        { 0x11a3, UCHAR_HANGUL_SYLLABLE_TYPE, 0 },
-        { 0x11a7, UCHAR_HANGUL_SYLLABLE_TYPE, 0 },
-        { 0x11fa, UCHAR_HANGUL_SYLLABLE_TYPE, 0 },
-        { 0x11ff, UCHAR_HANGUL_SYLLABLE_TYPE, 0 },
+        { 0xd7ca, UCHAR_HANGUL_SYLLABLE_TYPE, 0 },
+        { 0xd7cb, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_TRAILING_JAMO },    /* changed in Unicode 5.2 */
+        { 0xd7fb, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_TRAILING_JAMO },    /* changed in Unicode 5.2 */
+        { 0xd7fc, UCHAR_HANGUL_SYLLABLE_TYPE, 0 },
 
         { 0xac00, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LV_SYLLABLE },
         { 0xac1c, UCHAR_HANGUL_SYLLABLE_TYPE, U_HST_LV_SYLLABLE },
@@ -2433,6 +2633,51 @@ TestAdditionalProperties() {
         { 0xff63, UCHAR_SENTENCE_BREAK, U_SB_CLOSE },
         { 0x2028, UCHAR_SENTENCE_BREAK, U_SB_SEP },
 
+        { -1, 0x520, 0 }, /* version break for Unicode 5.2 */
+
+        /* unassigned code points in new default Bidi R blocks */
+        { 0x1ede4, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT },
+        { 0x1efe4, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT },
+
+        /* test some script codes >127 */
+        { 0xa6e6,  UCHAR_SCRIPT, USCRIPT_BAMUM },
+        { 0xa4d0,  UCHAR_SCRIPT, USCRIPT_LISU },
+        { 0x10a7f,  UCHAR_SCRIPT, USCRIPT_OLD_SOUTH_ARABIAN },
+
+        { -1, 0x600, 0 }, /* version break for Unicode 6.0 */
+
+        /* value changed in Unicode 6.0 */
+        { 0x06C3, UCHAR_JOINING_GROUP, U_JG_TEH_MARBUTA_GOAL },
+
+        { -1, 0x610, 0 }, /* version break for Unicode 6.1 */
+
+        /* unassigned code points in new/changed default Bidi AL blocks */
+        { 0x08ba, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT_ARABIC },
+        { 0x1eee4, UCHAR_BIDI_CLASS, U_RIGHT_TO_LEFT_ARABIC },
+
+        { -1, 0x630, 0 }, /* version break for Unicode 6.3 */
+
+        /* unassigned code points in the currency symbols block now default to ET */
+        { 0x20C0, UCHAR_BIDI_CLASS, U_EUROPEAN_NUMBER_TERMINATOR },
+        { 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 }
@@ -2455,7 +2700,7 @@ TestAdditionalProperties() {
     }
 
     /* test u_charAge() */
-    for(i=0; i<sizeof(charAges)/sizeof(charAges[0]); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(charAges); ++i) {
         u_charAge(charAges[i].c, version);
         if(0!=memcmp(version, charAges[i].version, sizeof(UVersionInfo))) {
             log_err("error: u_charAge(U+%04lx)={ %u, %u, %u, %u } instead of { %u, %u, %u, %u }\n",
@@ -2479,7 +2724,7 @@ TestAdditionalProperties() {
     if( u_getIntPropertyMaxValue(UCHAR_ID_CONTINUE)!=1) {
         log_err("error: u_getIntPropertyMaxValue(UCHAR_ID_CONTINUE) wrong\n");
     }
-    if( u_getIntPropertyMaxValue(UCHAR_BINARY_LIMIT-1)!=1) {
+    if( u_getIntPropertyMaxValue((UProperty)(UCHAR_BINARY_LIMIT-1))!=1) {
         log_err("error: u_getIntPropertyMaxValue(UCHAR_BINARY_LIMIT-1) wrong\n");
     }
     if( u_getIntPropertyMaxValue(UCHAR_BIDI_CLASS)!=(int32_t)U_CHAR_DIRECTION_COUNT-1 ) {
@@ -2512,6 +2757,9 @@ TestAdditionalProperties() {
     if(u_getIntPropertyMaxValue(UCHAR_WORD_BREAK)!=(int32_t)U_WB_COUNT-1) {
         log_err("error: u_getIntPropertyMaxValue(UCHAR_WORD_BREAK) wrong\n");
     }
+    if(u_getIntPropertyMaxValue(UCHAR_BIDI_PAIRED_BRACKET_TYPE)!=(int32_t)U_BPT_COUNT-1) {
+        log_err("error: u_getIntPropertyMaxValue(UCHAR_BIDI_PAIRED_BRACKET_TYPE) wrong\n");
+    }
     /*JB#2410*/
     if( u_getIntPropertyMaxValue(0x2345)!=-1) {
         log_err("error: u_getIntPropertyMaxValue(0x2345) wrong\n");
@@ -2530,7 +2778,9 @@ TestAdditionalProperties() {
     }
 
     /* test u_hasBinaryProperty() and u_getIntPropertyValue() */
-    for(i=0; i<sizeof(props)/sizeof(props[0]); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(props); ++i) {
+        const char *whichName;
+
         if(props[i][0]<0) {
             /* Unicode version break */
             if(uVersion<props[i][1]) {
@@ -2542,19 +2792,20 @@ TestAdditionalProperties() {
 
         c=(UChar32)props[i][0];
         which=(UProperty)props[i][1];
+        whichName=u_getPropertyName(which, U_LONG_PROPERTY_NAME);
 
         if(which<UCHAR_INT_START) {
             result=u_hasBinaryProperty(c, which);
             if(result!=props[i][2]) {
-                log_err("error: u_hasBinaryProperty(U+%04lx, %d)=%d is wrong (props[%d])\n",
-                        c, which, result, i);
+                log_data_err("error: u_hasBinaryProperty(U+%04lx, %s)=%d is wrong (props[%d]) - (Are you missing data?)\n",
+                        c, whichName, result, i);
             }
         }
 
         result=u_getIntPropertyValue(c, which);
         if(result!=props[i][2]) {
-            log_err("error: u_getIntPropertyValue(U+%04lx, 0x1000+%d)=%d is wrong, should be %d (props[%d])\n",
-                    c, (int32_t)which-0x1000, result, props[i][2], i);
+            log_data_err("error: u_getIntPropertyValue(U+%04lx, %s)=%d is wrong, should be %d (props[%d]) - (Are you missing data?)\n",
+                    c, whichName, result, props[i][2], i);
         }
 
         /* test separate functions, too */
@@ -2600,7 +2851,14 @@ TestNumericProperties(void) {
         { 0x0F33, U_NT_NUMERIC, -1./2. },
         { 0x0C66, U_NT_DECIMAL, 0 },
         { 0x96f6, U_NT_NUMERIC, 0 },
+        { 0xa833, U_NT_NUMERIC, 1./16. },
+        { 0x2152, U_NT_NUMERIC, 1./10. },
+        { 0x2151, U_NT_NUMERIC, 1./9. },
+        { 0x1245f, U_NT_NUMERIC, 1./8. },
+        { 0x2150, U_NT_NUMERIC, 1./7. },
         { 0x2159, U_NT_NUMERIC, 1./6. },
+        { 0x09f6, U_NT_NUMERIC, 3./16. },
+        { 0x2155, U_NT_NUMERIC, 1./5. },
         { 0x00BD, U_NT_NUMERIC, 1./2. },
         { 0x0031, U_NT_DECIMAL, 1. },
         { 0x4e00, U_NT_NUMERIC, 1. },
@@ -2634,21 +2892,25 @@ TestNumericProperties(void) {
         { 0x2181, U_NT_NUMERIC, 5000. },
         { 0x137C, U_NT_NUMERIC, 10000. },
         { 0x4e07, U_NT_NUMERIC, 10000. },
+        { 0x12432, U_NT_NUMERIC, 216000. },
+        { 0x12433, U_NT_NUMERIC, 432000. },
         { 0x4ebf, U_NT_NUMERIC, 100000000. },
         { 0x5146, U_NT_NUMERIC, 1000000000000. },
+        { -1, U_NT_NONE, U_NO_NUMERIC_VALUE },
         { 0x61, U_NT_NONE, U_NO_NUMERIC_VALUE },
         { 0x3000, U_NT_NONE, U_NO_NUMERIC_VALUE },
         { 0xfffe, U_NT_NONE, U_NO_NUMERIC_VALUE },
         { 0x10301, U_NT_NONE, U_NO_NUMERIC_VALUE },
         { 0xe0033, U_NT_NONE, U_NO_NUMERIC_VALUE },
-        { 0x10ffff, 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);
@@ -2671,6 +2933,7 @@ TestPropertyNames(void) {
     UBool atLeastSomething = FALSE;
 
     for (p=0; ; ++p) {
+        UProperty propEnum = (UProperty)p;
         UBool sawProp = FALSE;
         if(p > 10 && !atLeastSomething) {
           log_data_err("Never got anything after 10 tries.\nYour data is probably fried. Quitting this test\n", p, choice);
@@ -2678,9 +2941,10 @@ TestPropertyNames(void) {
         }
 
         for (choice=0; ; ++choice) {
-            const char* name = u_getPropertyName(p, choice);
+            const char* name = u_getPropertyName(propEnum, (UPropertyNameChoice)choice);
             if (name) {
-                if (!sawProp) log_verbose("prop 0x%04x+%2d:", p&~0xfff, p&0xfff);
+                if (!sawProp)
+                    log_verbose("prop 0x%04x+%2d:", p&~0xfff, p&0xfff);
                 log_verbose("%d=\"%s\"", choice, name);
                 sawProp = TRUE;
                 atLeastSomething = TRUE;
@@ -2696,7 +2960,7 @@ TestPropertyNames(void) {
         }
         if (sawProp) {
             /* looks like a valid property; check the values */
-            const char* pname = u_getPropertyName(p, U_LONG_PROPERTY_NAME);
+            const char* pname = u_getPropertyName(propEnum, U_LONG_PROPERTY_NAME);
             int32_t max = 0;
             if (p == UCHAR_CANONICAL_COMBINING_CLASS) {
                 max = 255;
@@ -2712,14 +2976,14 @@ TestPropertyNames(void) {
             for (v=-1; ; ++v) {
                 UBool sawValue = FALSE;
                 for (choice=0; ; ++choice) {
-                    const char* vname = u_getPropertyValueName(p, v, choice);
+                    const char* vname = u_getPropertyValueName(propEnum, v, (UPropertyNameChoice)choice);
                     if (vname) {
                         if (!sawValue) log_verbose(" %s, value %d:", pname, v);
                         log_verbose("%d=\"%s\"", choice, vname);
                         sawValue = TRUE;
 
                         /* test reverse mapping */
-                        rev = u_getPropertyValueEnum(p, vname);
+                        rev = u_getPropertyValueEnum(propEnum, vname);
                         if (rev != v) {
                             log_err("Value round-trip failure (%s): %d -> %s -> %d\n",
                                     pname, v, vname, rev);
@@ -2760,15 +3024,17 @@ TestPropertyValues(void) {
     /* Min should be 0 for everything. */
     /* Until JB#2478 is fixed, the one exception is UCHAR_BLOCK. */
     for (p=UCHAR_INT_START; p<UCHAR_INT_LIMIT; ++p) {
-        min = u_getIntPropertyMinValue(p);
+        UProperty propEnum = (UProperty)p;
+        min = u_getIntPropertyMinValue(propEnum);
         if (min != 0) {
             if (p == UCHAR_BLOCK) {
                 /* This is okay...for now.  See JB#2487.
                    TODO Update this for JB#2487. */
             } else {
                 const char* name;
-                name = u_getPropertyName(p, U_LONG_PROPERTY_NAME);
-                if (name == NULL) name = "<ERROR>";
+                name = u_getPropertyName(propEnum, U_LONG_PROPERTY_NAME);
+                if (name == NULL)
+                    name = "<ERROR>";
                 log_err("FAIL: u_getIntPropertyMinValue(%s) = %d, exp. 0\n",
                         name, min);
             }
@@ -2781,7 +3047,7 @@ TestPropertyValues(void) {
     }
 
     /* Max should be -1 for invalid properties. */
-    max = u_getIntPropertyMaxValue(-1);
+    max = u_getIntPropertyMaxValue(UCHAR_INVALID_CODE);
     if (max != -1) {
         log_err("FAIL: u_getIntPropertyMaxValue(-1) = %d, exp. -1\n",
                 max);
@@ -2814,32 +3080,13 @@ TestPropertyValues(void) {
     }
 }
 
-/* add characters from a serialized set to a normal one */
-static void
-_setAddSerialized(USet *set, const USerializedSet *sset) {
-    UChar32 start, end;
-    int32_t i, count;
-
-    count=uset_getSerializedRangeCount(sset);
-    for(i=0; i<count; ++i) {
-        uset_getSerializedRange(sset, i, &start, &end);
-        uset_addRange(set, start, end);
-    }
-}
-
 /* various tests for consistency of UCD data and API behavior */
 static void
 TestConsistency() {
-#if !UCONFIG_NO_NORMALIZATION
-    UChar buffer16[300];
-#endif
     char buffer[300];
     USet *set1, *set2, *set3, *set4;
     UErrorCode errorCode;
 
-#if !UCONFIG_NO_NORMALIZATION
-    USerializedSet sset;
-#endif
     UChar32 start, end;
     int32_t i, length;
 
@@ -2851,7 +3098,7 @@ TestConsistency() {
 
     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);
@@ -2865,7 +3112,7 @@ TestConsistency() {
 
     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);
@@ -2878,7 +3125,7 @@ TestConsistency() {
      *
      * Unicode 4 changed 00AD Soft Hyphen to Cf and removed it from Dash
      * but not from Hyphen.
-     * UTC 94 (2003mar) decided to leave it that way and to changed UCD.html.
+     * UTC 94 (2003mar) decided to leave it that way and to change UCD.html.
      * Therefore, do not show errors when testing the Hyphen property.
      */
     log_verbose("Starting with Unicode 4, inconsistencies with [:Hyphen:] are\n"
@@ -2893,7 +3140,7 @@ TestConsistency() {
         uset_remove(set1, 0xff65); /* halfwidth variant */
         showAMinusB(set1, set2, "[:Hyphen:]", "[:Dash:]", FALSE);
     } else {
-        log_err("error opening [:Hyphen:] or [:Dash:] - %s\n", u_errorName(errorCode));
+        log_data_err("error opening [:Hyphen:] or [:Dash:] - %s (Are you missing data?)\n", u_errorName(errorCode));
     }
 
     /* check that Cf is neither Hyphen nor Dash nor Alphabetic */
@@ -2904,7 +3151,7 @@ TestConsistency() {
         showAIntersectB(set3, set2, "[:Cf:]", "[:Dash:]", TRUE);
         showAIntersectB(set3, set4, "[:Cf:]", "[:Alphabetic:]", TRUE);
     } else {
-        log_err("error opening [:Cf:] or [:Alpbabetic:] - %s\n", u_errorName(errorCode));
+        log_data_err("error opening [:Cf:] or [:Alpbabetic:] - %s (Are you missing data?)\n", u_errorName(errorCode));
     }
 
     uset_close(set1);
@@ -2938,9 +3185,8 @@ TestConsistency() {
             while(start<=end) {
                 length=u_charName(start, U_UNICODE_CHAR_NAME, buffer, sizeof(buffer), &errorCode);
                 if(U_FAILURE(errorCode)) {
-                    log_err("error getting the name of U+%04x - %s\n", start, u_errorName(errorCode));
+                    log_data_err("error getting the name of U+%04x - %s\n", start, u_errorName(errorCode));
                     errorCode=U_ZERO_ERROR;
-                    continue;
                 }
                 if( (strstr(buffer, "SMALL")==NULL || strstr(buffer, "CAPITAL")!=NULL) &&
                     strstr(buffer, "SMALL CAPITAL")==NULL
@@ -2951,46 +3197,10 @@ TestConsistency() {
             }
         }
     } else {
-        log_err("error opening [:Lowercase:] - %s\n", u_errorName(errorCode));
+        log_data_err("error opening [:Lowercase:] - %s (Are you missing data?)\n", u_errorName(errorCode));
     }
     uset_close(set1);
 
-#if !UCONFIG_NO_NORMALIZATION
-
-    /*
-     * Test for an example that unorm_getCanonStartSet() delivers
-     * all characters that compose from the input one,
-     * even in multiple steps.
-     * For example, the set for "I" (0049) should contain both
-     * I-diaeresis (00CF) and I-diaeresis-acute (1E2E).
-     * In general, the set for the middle such character should be a subset
-     * of the set for the first.
-     */
-    set1=uset_open(1, 0);
-    set2=uset_open(1, 0);
-
-    if (unorm_getCanonStartSet(0x49, &sset)) {
-        _setAddSerialized(set1, &sset);
-
-        /* enumerate all characters that are plausible to be latin letters */
-        for(start=0xa0; start<0x2000; ++start) {
-            if(unorm_getDecomposition(start, FALSE, buffer16, LENGTHOF(buffer16))>1 && buffer16[0]==0x49) {
-                uset_add(set2, start);
-            }
-        }
-
-        compareUSets(set1, set2,
-                     "[canon start set of 0049]", "[all c with canon decomp with 0049]",
-                     TRUE);
-    } else {
-      log_err("error calling unorm_getCanonStartSet()\n");
-    }
-
-    uset_close(set1);
-    uset_close(set2);
-
-#endif
-
     /* verify that all assigned characters in Math blocks are exactly Math characters */
     errorCode=U_ZERO_ERROR;
     set1=uset_openPattern(mathBlocksPattern, -1, &errorCode);
@@ -3004,7 +3214,7 @@ TestConsistency() {
                      "[assigned Math block chars]", "[math blocks]&[:Math:]",
                      TRUE);
     } else {
-        log_err("error opening [math blocks] or [:Math:] or [:Cn:] - %s\n", u_errorName(errorCode));
+        log_data_err("error opening [math blocks] or [:Math:] or [:Cn:] - %s (Are you missing data?)\n", u_errorName(errorCode));
     }
     uset_close(set1);
     uset_close(set2);
@@ -3019,7 +3229,7 @@ TestConsistency() {
                      "[:sc=Unknown:]", "[[:Cn:][:Co:][:Cs:]]",
                      TRUE);
     } else {
-        log_err("error opening [:sc=Unknown:] or [[:Cn:][:Co:][:Cs:]] - %s\n", u_errorName(errorCode));
+        log_data_err("error opening [:sc=Unknown:] or [[:Cn:][:Co:][:Cs:]] - %s (Are you missing data?)\n", u_errorName(errorCode));
     }
     uset_close(set1);
     uset_close(set2);
@@ -3037,59 +3247,14 @@ TestConsistency() {
  */
 #define HARDCODED_DATA_4497 1
 
-/* API coverage for ucase.c */
-static void TestUCase() {
-#if !HARDCODED_DATA_4497
-    UDataMemory *pData;
-    UCaseProps *csp;
-#endif
-    const UCaseProps *ccsp;
-    UErrorCode errorCode;
-
-#if !HARDCODED_DATA_4497
-    /* coverage for ucase_openBinary() */
-    errorCode=U_ZERO_ERROR;
-    pData=udata_open(NULL, UCASE_DATA_TYPE, UCASE_DATA_NAME, &errorCode);
-    if(U_FAILURE(errorCode)) {
-        log_data_err("unable to open " UCASE_DATA_NAME "." UCASE_DATA_TYPE ": %s\n",
-                    u_errorName(errorCode));
-        return;
-    }
-
-    csp=ucase_openBinary((const uint8_t *)pData->pHeader, -1, &errorCode);
-    if(U_FAILURE(errorCode)) {
-        log_err("ucase_openBinary() fails for the contents of " UCASE_DATA_NAME "." UCASE_DATA_TYPE ": %s\n",
-                u_errorName(errorCode));
-        udata_close(pData);
-        return;
-    }
-
-    if(UCASE_LOWER!=ucase_getType(csp, 0xdf)) { /* verify islower(sharp s) */
-        log_err("ucase_openBinary() does not seem to return working UCaseProps\n");
-    }
-
-    ucase_close(csp);
-    udata_close(pData);
-#endif
-
-    /* coverage for ucase_getDummy() */
-    errorCode=U_ZERO_ERROR;
-    ccsp=ucase_getDummy(&errorCode);
-    if(ucase_tolower(ccsp, 0x41)!=0x41) {
-        log_err("ucase_tolower(dummy, A)!=A\n");
-    }
-}
-
 /* API coverage for ubidi_props.c */
 static void TestUBiDiProps() {
 #if !HARDCODED_DATA_4497
     UDataMemory *pData;
     UBiDiProps *bdp;
-#endif
     const UBiDiProps *cbdp;
     UErrorCode errorCode;
 
-#if !HARDCODED_DATA_4497
     /* coverage for ubidi_openBinary() */
     errorCode=U_ZERO_ERROR;
     pData=udata_open(NULL, UBIDI_DATA_TYPE, UBIDI_DATA_NAME, &errorCode);
@@ -3113,7 +3278,6 @@ static void TestUBiDiProps() {
 
     ubidi_closeProps(bdp);
     udata_close(pData);
-#endif
 
     /* coverage for ubidi_getDummy() */
     errorCode=U_ZERO_ERROR;
@@ -3121,6 +3285,7 @@ static void TestUBiDiProps() {
     if(ubidi_getClass(cbdp, 0x20)!=0) {
         log_err("ubidi_getClass(dummy, space)!=0\n");
     }
+#endif
 }
 
 /* test case folding, compare return values with CaseFolding.txt ------------ */
@@ -3151,7 +3316,7 @@ testFold(UChar32 c, int which,
         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);
         }
@@ -3161,7 +3326,7 @@ testFold(UChar32 c, int which,
             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);
         }
@@ -3201,7 +3366,16 @@ caseFoldingLineFn(void *context,
     char status;
 
     /* get code point */
-    c=(UChar32)strtoul(u_skipWhitespace(fields[0][0]), &end, 16);
+    const char *s=u_skipWhitespace(fields[0][0]);
+    if(0==strncmp(s, "0000..10FFFF", 12)) {
+        /*
+         * Ignore the line
+         * # @missing: 0000..10FFFF; C; <code point>
+         * because maps-to-self is already our default, and this line breaks this parser.
+         */
+        return;
+    }
+    c=(UChar32)strtoul(s, &end, 16);
     end=(char *)u_skipWhitespace(end);
     if(end<=fields[0][0] || end!=fields[0][1]) {
         log_err("syntax error in CaseFolding.txt field 0 at %s\n", fields[0][0]);
@@ -3235,14 +3409,14 @@ caseFoldingLineFn(void *context,
          * If a turkic folding was not mentioned, then it should fold the same
          * as the regular simple case folding.
          */
-        UChar s[2];
+        UChar prevString[2];
         int32_t length;
 
         length=0;
-        U16_APPEND_UNSAFE(s, length, prev);
+        U16_APPEND_UNSAFE(prevString, length, prev);
         testFold(prev, (~pData->which)&CF_ALL,
                  prev, pData->prevSimple,
-                 s, length,
+                 prevString, length,
                  pData->prevFull, pData->prevFullLength);
         pData->prev=pData->prevSimple=c;
         length=0;