Update ICU to 54.1 step 1

source/test/cintltst/cnormtst.c

 /********************************************************************
  * COPYRIGHT: 
- * Copyright (c) 1997-2012, International Business Machines Corporation and
+ * Copyright (c) 1997-2014, International Business Machines Corporation and
  * others. All Rights Reserved.
  ********************************************************************/
 /********************************************************************************
 *
 * File CNORMTST.C
 *
 * Modification History:
 *        Name                     Description            
 *     Madhu Katragadda            Ported for C API
 *     synwee                      added test for quick check
 *     synwee                      added test for checkFCD
 *********************************************************************************/
 /*tests for u_normalization*/
 #include "unicode/utypes.h"
 #include "unicode/unorm.h"
 #include "unicode/utf16.h"
 #include "cintltst.h"
+#include "cmemory.h"
 
 #if !UCONFIG_NO_NORMALIZATION
 
 #include <stdlib.h>
 #include <time.h>
 #include "unicode/uchar.h"
 #include "unicode/ustring.h"
 #include "unicode/unorm.h"
 #include "cnormtst.h"
 
-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof ((array)[0]))
-
 static void
 TestAPI(void);
 
 static void
 TestNormCoverage(void);
 
 static void
 TestConcatenate(void);
 
 static void
@@ skipping 139 matching lines @@
         length2= unorm_normalize(source, -1, mode, 0, NULL, 0, &status2);
         if(neededLen!=length2) {
           log_err("ERROR in unorm_normalize(%s)[%d]: "
                   "preflight length/NUL %d!=%d preflight length/srcLength\n",
                   modeStrings[mode], (int)x, (int)neededLen, (int)length2);
         }
         if(status==U_BUFFER_OVERFLOW_ERROR)
         {
             status=U_ZERO_ERROR;
         }
-        length2=unorm_normalize(source, u_strlen(source), mode, 0, result, LENGTHOF(result), &status); 
+        length2=unorm_normalize(source, u_strlen(source), mode, 0, result, UPRV_LENGTHOF(result), &status); 
         if(U_FAILURE(status) || neededLen!=length2) {
             log_data_err("ERROR in unorm_normalize(%s/NUL) at %s:  %s - (Are you missing data?)\n",
                          modeStrings[mode], austrdup(source), myErrorName(status));
         } else {
             assertEqual(result, cases[x][expIndex], x);
         }
-        length2=unorm_normalize(source, -1, mode, 0, result, LENGTHOF(result), &status); 
+        length2=unorm_normalize(source, -1, mode, 0, result, UPRV_LENGTHOF(result), &status); 
         if(U_FAILURE(status) || neededLen!=length2) {
             log_data_err("ERROR in unorm_normalize(%s/srcLength) at %s:  %s - (Are you missing data?)\n",
                          modeStrings[mode], austrdup(source), myErrorName(status));
         } else {
             assertEqual(result, cases[x][expIndex], x);
         }
         free(source);
     }
 }
 
 void TestDecomp() {
-    TestNormCases(UNORM_NFD, canonTests, LENGTHOF(canonTests));
+    TestNormCases(UNORM_NFD, canonTests, UPRV_LENGTHOF(canonTests));
 }
 
 void TestCompatDecomp() {
-    TestNormCases(UNORM_NFKD, compatTests, LENGTHOF(compatTests));
+    TestNormCases(UNORM_NFKD, compatTests, UPRV_LENGTHOF(compatTests));
 }
 
 void TestCanonDecompCompose() {
-    TestNormCases(UNORM_NFC, canonTests, LENGTHOF(canonTests));
+    TestNormCases(UNORM_NFC, canonTests, UPRV_LENGTHOF(canonTests));
 }
 
 void TestCompatDecompCompose() {
-    TestNormCases(UNORM_NFKC, compatTests, LENGTHOF(compatTests));
+    TestNormCases(UNORM_NFKC, compatTests, UPRV_LENGTHOF(compatTests));
 }
 
 void TestFCD() {
-    TestNormCases(UNORM_FCD, fcdTests, LENGTHOF(fcdTests));
+    TestNormCases(UNORM_FCD, fcdTests, UPRV_LENGTHOF(fcdTests));
 }
 
 static void assertEqual(const UChar* result, const char* expected, int32_t index)
 {
     UChar *expectedUni = CharsToUChars(expected);
     if(u_strcmp(result, expectedUni)!=0){
         log_err("ERROR in decomposition at index = %d. EXPECTED: %s , GOT: %s\n", index, expected,
             austrdup(result) );
     }
     free(expectedUni);
@@ skipping 150 matching lines @@
       return;
     }
     if (unorm_quickCheck(&cp, 1, UNORM_NFC, &error) != 
                                                              UNORM_YES)
     {
       log_err("ERROR in NFC quick check at U+%04x\n", cp);
       return;
     }
     if (unorm_quickCheck(&cp, 1, UNORM_NFKD, &error) != UNORM_YES)
     {
-      log_err("ERROR in NFKD quick check at U+%04x\n", cp);
+      log_data_err("ERROR in NFKD quick check at U+%04x\n", cp);
       return;
     }
     if (unorm_quickCheck(&cp, 1, UNORM_NFKC, &error) != 
                                                              UNORM_YES)
     {
       log_err("ERROR in NFKC quick check at U+%04x\n", cp);
       return;
     }
     cp ++;
   }
@@ skipping 45 matching lines @@
   {
     if (unorm_quickCheck(&(CPNFC[count]), 1, UNORM_NFC, &error) != 
                                                            UNORM_MAYBE)
     {
       log_data_err("ERROR in NFC quick check at U+%04x - (Are you missing data?)\n", CPNFC[count]);
       return;
     }
     if (unorm_quickCheck(&(CPNFKC[count]), 1, UNORM_NFKC, &error) != 
                                                            UNORM_MAYBE)
     {
-      log_err("ERROR in NFKC quick check at U+%04x\n", CPNFKC[count]);
+      log_data_err("ERROR in NFKC quick check at U+%04x\n", CPNFKC[count]);
       return;
     }
   }
 }
 
 static void TestQuickCheckStringResult() 
 {
   int count;
   UChar *d = NULL;
   UChar *c = NULL;
   UErrorCode error = U_ZERO_ERROR;
 
-  for (count = 0; count < LENGTHOF(canonTests); count ++)
+  for (count = 0; count < UPRV_LENGTHOF(canonTests); count ++)
   {
     d = CharsToUChars(canonTests[count][1]);
     c = CharsToUChars(canonTests[count][2]);
     if (unorm_quickCheck(d, u_strlen(d), UNORM_NFD, &error) != 
                                                             UNORM_YES)
     {
       log_data_err("ERROR in NFD quick check for string at count %d - (Are you missing data?)\n", count);
       return;
     }
 
     if (unorm_quickCheck(c, u_strlen(c), UNORM_NFC, &error) == 
                                                             UNORM_NO)
     {
       log_err("ERROR in NFC quick check for string at count %d\n", count);
       return;
     }
 
     free(d);
     free(c);
   }
 
-  for (count = 0; count < LENGTHOF(compatTests); count ++)
+  for (count = 0; count < UPRV_LENGTHOF(compatTests); count ++)
   {
     d = CharsToUChars(compatTests[count][1]);
     c = CharsToUChars(compatTests[count][2]);
     if (unorm_quickCheck(d, u_strlen(d), UNORM_NFKD, &error) != 
                                                             UNORM_YES)
     {
-      log_err("ERROR in NFKD quick check for string at count %d\n", count);
+      log_data_err("ERROR in NFKD quick check for string at count %d\n", count);
       return;
     }
 
     if (unorm_quickCheck(c, u_strlen(c), UNORM_NFKC, &error) != 
                                                             UNORM_YES)
     {
       log_err("ERROR in NFKC quick check for string at count %d\n", count);
       return;
     }
 
@@ skipping 54 matching lines @@
     }
 
     /* bad length */
     errorCode=U_ZERO_ERROR;
     (void)unorm_isNormalized(notNFC[0]+2, -2, UNORM_NFC, &errorCode);
     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
         log_data_err("error: isNormalized([-2]) did not set U_ILLEGAL_ARGUMENT_ERROR but %s - (Are you missing data?)\n", u_errorName(errorCode));
     }
 
     /* specific cases */
-    for(i=0; i<LENGTHOF(notNFC); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(notNFC); ++i) {
         errorCode=U_ZERO_ERROR;
         if(unorm_isNormalized(notNFC[i], -1, UNORM_NFC, &errorCode) || U_FAILURE(errorCode)) {
             log_data_err("error: isNormalized(notNFC[%d], NFC) is wrong (%s) - (Are you missing data?)\n", i, u_errorName(errorCode));
         }
         errorCode=U_ZERO_ERROR;
         if(unorm_isNormalized(notNFC[i], -1, UNORM_NFKC, &errorCode) || U_FAILURE(errorCode)) {
             log_data_err("error: isNormalized(notNFC[%d], NFKC) is wrong (%s) - (Are you missing data?)\n", i, u_errorName(errorCode));
         }
     }
-    for(i=0; i<LENGTHOF(notNFKC); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(notNFKC); ++i) {
         errorCode=U_ZERO_ERROR;
         if(unorm_isNormalized(notNFKC[i], -1, UNORM_NFKC, &errorCode) || U_FAILURE(errorCode)) {
             log_data_err("error: isNormalized(notNFKC[%d], NFKC) is wrong (%s) - (Are you missing data?)\n", i, u_errorName(errorCode));
         }
     }
 }
 
 void TestCheckFCD() 
 {
   UErrorCode status = U_ZERO_ERROR;
@@ skipping 723 matching lines @@
         { 0x2128, { 0x007A, 0 } },
         { 0x1D5DB, { 0x0068, 0 } },
         { 0x1D5ED, { 0x007A, 0 } },
         { 0x0061, { 0 } }
     };
 
     UChar buffer[8];
     UErrorCode errorCode;
     int32_t i, length;
 
-    for(i=0; i<LENGTHOF(tests); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(tests); ++i) {
         errorCode=U_ZERO_ERROR;
-        length=u_getFC_NFKC_Closure(tests[i].c, buffer, LENGTHOF(buffer), &errorCode);
+        length=u_getFC_NFKC_Closure(tests[i].c, buffer, UPRV_LENGTHOF(buffer), &errorCode);
         if(U_FAILURE(errorCode) || length!=u_strlen(buffer) || 0!=u_strcmp(tests[i].s, buffer)) {
             log_data_err("u_getFC_NFKC_Closure(U+%04lx) is wrong (%s) - (Are you missing data?)\n", tests[i].c, u_errorName(errorCode));
         }
     }
 
     /* error handling */
     errorCode=U_ZERO_ERROR;
-    length=u_getFC_NFKC_Closure(0x5c, NULL, LENGTHOF(buffer), &errorCode);
+    length=u_getFC_NFKC_Closure(0x5c, NULL, UPRV_LENGTHOF(buffer), &errorCode);
     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
         log_err("u_getFC_NFKC_Closure(dest=NULL) is wrong (%s)\n", u_errorName(errorCode));
     }
 
-    length=u_getFC_NFKC_Closure(0x5c, buffer, LENGTHOF(buffer), &errorCode);
+    length=u_getFC_NFKC_Closure(0x5c, buffer, UPRV_LENGTHOF(buffer), &errorCode);
     if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
         log_err("u_getFC_NFKC_Closure(U_FAILURE) is wrong (%s)\n", u_errorName(errorCode));
     }
 }
 
 static void
 TestQuickCheckPerCP() {
     UErrorCode errorCode;
     UChar32 c, lead, trail;
     UChar s[U16_MAX_LENGTH], nfd[16];
@@ skipping 38 matching lines @@
         if(qc1!=qc2) {
             log_data_err("u_getIntPropertyValue(NFKC)=%d != %d=unorm_quickCheck(NFKC) for U+%04x - (Are you missing data?)\n", qc1, qc2, c);
         }
 
         qc1=u_getIntPropertyValue(c, UCHAR_NFKD_QUICK_CHECK);
         qc2=unorm_quickCheck(s, length, UNORM_NFKD, &errorCode);
         if(qc1!=qc2) {
             log_data_err("u_getIntPropertyValue(NFKD)=%d != %d=unorm_quickCheck(NFKD) for U+%04x - (Are you missing data?)\n", qc1, qc2, c);
         }
 
-        length=unorm_normalize(s, length, UNORM_NFD, 0, nfd, LENGTHOF(nfd), &errorCode);
+        length=unorm_normalize(s, length, UNORM_NFD, 0, nfd, UPRV_LENGTHOF(nfd), &errorCode);
         /* length-length == 0 is used to get around a compiler warning. */
         U16_GET(nfd, 0, length-length, length, lead);
         U16_GET(nfd, 0, length-1, length, trail);
 
         lccc1=u_getIntPropertyValue(c, UCHAR_LEAD_CANONICAL_COMBINING_CLASS);
         lccc2=u_getCombiningClass(lead);
         tccc1=u_getIntPropertyValue(c, UCHAR_TRAIL_CANONICAL_COMBINING_CLASS);
         tccc2=u_getCombiningClass(trail);
 
         if(lccc1!=lccc2) {
-            log_err("u_getIntPropertyValue(lccc)=%d != %d=u_getCombiningClass(lead) for U+%04x\n",
+            log_data_err("u_getIntPropertyValue(lccc)=%d != %d=u_getCombiningClass(lead) for U+%04x\n",
                     lccc1, lccc2, c);
         }
         if(tccc1!=tccc2) {
-            log_err("u_getIntPropertyValue(tccc)=%d != %d=u_getCombiningClass(trail) for U+%04x\n",
+            log_data_err("u_getIntPropertyValue(tccc)=%d != %d=u_getCombiningClass(trail) for U+%04x\n",
                     tccc1, tccc2, c);
         }
 
         /* skip some code points */
         c=(20*c)/19+1;
     }
 }
 
 static void
 TestComposition(void) {
@@ skipping 14 matching lines @@
         { UNORM_NFC, 0, { 0xac00, 0x0300, 0x0327, 0x11a8 },         { 0xac00, 0x0327, 0x0300, 0x11a8 } },
         { UNORM_NFC, 0, { 0x0b47, 0x0300, 0x0b3e },                 { 0x0b47, 0x0300, 0x0b3e } },
 
         /* TODO: add test cases for UNORM_FCC here (j2151) */
     };
 
     UChar output[16];
     UErrorCode errorCode;
     int32_t i, length;
 
-    for(i=0; i<LENGTHOF(cases); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(cases); ++i) {
         errorCode=U_ZERO_ERROR;
         length=unorm_normalize(
                     cases[i].input, -1,
                     cases[i].mode, cases[i].options,
-                    output, LENGTHOF(output),
+                    output, UPRV_LENGTHOF(output),
                     &errorCode);
         if( U_FAILURE(errorCode) ||
             length!=u_strlen(cases[i].expect) ||
             0!=u_memcmp(output, cases[i].expect, length)
         ) {
             log_data_err("unexpected result for case %d - (Are you missing data?)\n", i);
         }
     }
 }
 
 static void
 TestGetDecomposition() {
     UChar decomp[32];
     int32_t length;
 
     UErrorCode errorCode=U_ZERO_ERROR;
     const UNormalizer2 *n2=unorm2_getInstance(NULL, "nfc", UNORM2_COMPOSE_CONTIGUOUS, &errorCode);
     if(U_FAILURE(errorCode)) {
         log_err_status(errorCode, "unorm2_getInstance(nfc/FCC) failed: %s\n", u_errorName(errorCode));
         return;
     }
 
-    length=unorm2_getDecomposition(n2, 0x20, decomp, LENGTHOF(decomp), &errorCode);
+    length=unorm2_getDecomposition(n2, 0x20, decomp, UPRV_LENGTHOF(decomp), &errorCode);
     if(U_FAILURE(errorCode) || length>=0) {
         log_err("unorm2_getDecomposition(fcc, space) failed\n");
     }
     errorCode=U_ZERO_ERROR;
-    length=unorm2_getDecomposition(n2, 0xe4, decomp, LENGTHOF(decomp), &errorCode);
+    length=unorm2_getDecomposition(n2, 0xe4, decomp, UPRV_LENGTHOF(decomp), &errorCode);
     if(U_FAILURE(errorCode) || length!=2 || decomp[0]!=0x61 || decomp[1]!=0x308 || decomp[2]!=0) {
         log_err("unorm2_getDecomposition(fcc, a-umlaut) failed\n");
     }
     errorCode=U_ZERO_ERROR;
-    length=unorm2_getDecomposition(n2, 0xac01, decomp, LENGTHOF(decomp), &errorCode);
+    length=unorm2_getDecomposition(n2, 0xac01, decomp, UPRV_LENGTHOF(decomp), &errorCode);
     if(U_FAILURE(errorCode) || length!=3 || decomp[0]!=0x1100 || decomp[1]!=0x1161 || decomp[2]!=0x11a8 || decomp[3]!=0) {
         log_err("unorm2_getDecomposition(fcc, Hangul syllable U+AC01) failed\n");
     }
     errorCode=U_ZERO_ERROR;
     length=unorm2_getDecomposition(n2, 0xac01, NULL, 0, &errorCode);
     if(errorCode!=U_BUFFER_OVERFLOW_ERROR || length!=3) {
         log_err("unorm2_getDecomposition(fcc, Hangul syllable U+AC01) overflow failed\n");
     }
     errorCode=U_ZERO_ERROR;
     length=unorm2_getDecomposition(n2, 0xac01, decomp, -1, &errorCode);
@@ skipping 16 matching lines @@
     const UNormalizer2 *n2=unorm2_getNFKCInstance(&errorCode);
     if(U_FAILURE(errorCode)) {
         log_err_status(errorCode, "unorm2_getNFKCInstance() failed: %s\n", u_errorName(errorCode));
         return;
     }
     /*
      * Raw decompositions from NFKC data are the Unicode Decomposition_Mapping values,
      * without recursive decomposition.
      */
 
-    length=unorm2_getRawDecomposition(n2, 0x20, decomp, LENGTHOF(decomp), &errorCode);
+    length=unorm2_getRawDecomposition(n2, 0x20, decomp, UPRV_LENGTHOF(decomp), &errorCode);
     if(U_FAILURE(errorCode) || length>=0) {
         log_err("unorm2_getDecomposition(nfkc, space) failed\n");
     }
     errorCode=U_ZERO_ERROR;
-    length=unorm2_getRawDecomposition(n2, 0xe4, decomp, LENGTHOF(decomp), &errorCode);
+    length=unorm2_getRawDecomposition(n2, 0xe4, decomp, UPRV_LENGTHOF(decomp), &errorCode);
     if(U_FAILURE(errorCode) || length!=2 || decomp[0]!=0x61 || decomp[1]!=0x308 || decomp[2]!=0) {
         log_err("unorm2_getDecomposition(nfkc, a-umlaut) failed\n");
     }
     /* U+1E08 LATIN CAPITAL LETTER C WITH CEDILLA AND ACUTE */
     errorCode=U_ZERO_ERROR;
-    length=unorm2_getRawDecomposition(n2, 0x1e08, decomp, LENGTHOF(decomp), &errorCode);
+    length=unorm2_getRawDecomposition(n2, 0x1e08, decomp, UPRV_LENGTHOF(decomp), &errorCode);
     if(U_FAILURE(errorCode) || length!=2 || decomp[0]!=0xc7 || decomp[1]!=0x301 || decomp[2]!=0) {
         log_err("unorm2_getDecomposition(nfkc, c-cedilla-acute) failed\n");
     }
     /* U+212B ANGSTROM SIGN */
     errorCode=U_ZERO_ERROR;
-    length=unorm2_getRawDecomposition(n2, 0x212b, decomp, LENGTHOF(decomp), &errorCode);
+    length=unorm2_getRawDecomposition(n2, 0x212b, decomp, UPRV_LENGTHOF(decomp), &errorCode);
     if(U_FAILURE(errorCode) || length!=1 || decomp[0]!=0xc5 || decomp[1]!=0) {
         log_err("unorm2_getDecomposition(nfkc, angstrom sign) failed\n");
     }
     errorCode=U_ZERO_ERROR;
-    length=unorm2_getRawDecomposition(n2, 0xac00, decomp, LENGTHOF(decomp), &errorCode);
+    length=unorm2_getRawDecomposition(n2, 0xac00, decomp, UPRV_LENGTHOF(decomp), &errorCode);
     if(U_FAILURE(errorCode) || length!=2 || decomp[0]!=0x1100 || decomp[1]!=0x1161 || decomp[2]!=0) {
         log_err("unorm2_getDecomposition(nfkc, Hangul syllable U+AC00) failed\n");
     }
     /* A Hangul LVT syllable has a raw decomposition of an LV syllable + T. */
     errorCode=U_ZERO_ERROR;
-    length=unorm2_getRawDecomposition(n2, 0xac01, decomp, LENGTHOF(decomp), &errorCode);
+    length=unorm2_getRawDecomposition(n2, 0xac01, decomp, UPRV_LENGTHOF(decomp), &errorCode);
     if(U_FAILURE(errorCode) || length!=2 || decomp[0]!=0xac00 || decomp[1]!=0x11a8 || decomp[2]!=0) {
         log_err("unorm2_getDecomposition(nfkc, Hangul syllable U+AC01) failed\n");
     }
     errorCode=U_ZERO_ERROR;
     length=unorm2_getRawDecomposition(n2, 0xac01, NULL, 0, &errorCode);
     if(errorCode!=U_BUFFER_OVERFLOW_ERROR || length!=2) {
         log_err("unorm2_getDecomposition(nfkc, Hangul syllable U+AC01) overflow failed\n");
     }
     errorCode=U_ZERO_ERROR;
     length=unorm2_getRawDecomposition(n2, 0xac01, decomp, -1, &errorCode);
@@ skipping 20 matching lines @@
         log_err_status(errorCode, "unorm2_getNFCInstance() failed: %s\n", u_errorName(errorCode));
         return;
     }
     /*
      * Use length=-1 to fool the estimate of the ReorderingBuffer capacity.
      * Use a capacity of 6 or 7 so that the middle sequence <41 327 30A>
      * still fits into a[] but the full result still overflows this capacity.
      * (Let it modify the destination buffer before reallocating internally.)
      */
     length=unorm2_append(n2, a, -1, 6, b, -1, &errorCode);
-    if(errorCode!=U_BUFFER_OVERFLOW_ERROR || length!=LENGTHOF(expected)) {
+    if(errorCode!=U_BUFFER_OVERFLOW_ERROR || length!=UPRV_LENGTHOF(expected)) {
         log_err("unorm2_append(preflight) returned wrong length of %d\n", (int)length);
         return;
     }
     /* Verify that the middle is unchanged or restored. (ICU ticket #7848) */
     if(a[0]!=0x61 || a[1]!=0x62 || a[2]!=0x63 || a[3]!=0x41 || a[4]!=0x327 || a[5]!=0) {
         log_err("unorm2_append(overflow) modified the first string\n");
         return;
     }
     errorCode=U_ZERO_ERROR;
-    length=unorm2_append(n2, a, -1, LENGTHOF(a), b, -1, &errorCode);
-    if(U_FAILURE(errorCode) || length!=LENGTHOF(expected) || 0!=u_memcmp(a, expected, length)) {
+    length=unorm2_append(n2, a, -1, UPRV_LENGTHOF(a), b, -1, &errorCode);
+    if(U_FAILURE(errorCode) || length!=UPRV_LENGTHOF(expected) || 0!=u_memcmp(a, expected, length)) {
         log_err("unorm2_append(real) failed - %s, length %d\n", u_errorName(errorCode), (int)length);
         return;
     }
 }
 
 static void
 TestGetEasyToUseInstance() {
     static const UChar in[]={
         0xA0,  /* -> <noBreak> 0020 */
         0xC7, 0x301  /* = 1E08 = 0043 0327 0301 */
     };
     UChar out[32];
     int32_t length;
 
     UErrorCode errorCode=U_ZERO_ERROR;
     const UNormalizer2 *n2=unorm2_getNFCInstance(&errorCode);
     if(U_FAILURE(errorCode)) {
         log_err_status(errorCode, "unorm2_getNFCInstance() failed: %s\n", u_errorName(errorCode));
         return;
     }
-    length=unorm2_normalize(n2, in, LENGTHOF(in), out, LENGTHOF(out), &errorCode);
+    length=unorm2_normalize(n2, in, UPRV_LENGTHOF(in), out, UPRV_LENGTHOF(out), &errorCode);
     if(U_FAILURE(errorCode) || length!=2 || out[0]!=0xa0 || out[1]!=0x1e08) {
         log_err("unorm2_getNFCInstance() did not return an NFC instance (normalized length=%d; %s)\n",
                 (int)length, u_errorName(errorCode));
     }
 
     errorCode=U_ZERO_ERROR;
     n2=unorm2_getNFDInstance(&errorCode);
     if(U_FAILURE(errorCode)) {
         log_err_status(errorCode, "unorm2_getNFDInstance() failed: %s\n", u_errorName(errorCode));
         return;
     }
-    length=unorm2_normalize(n2, in, LENGTHOF(in), out, LENGTHOF(out), &errorCode);
+    length=unorm2_normalize(n2, in, UPRV_LENGTHOF(in), out, UPRV_LENGTHOF(out), &errorCode);
     if(U_FAILURE(errorCode) || length!=4 || out[0]!=0xa0 || out[1]!=0x43 || out[2]!=0x327 || out[3]!=0x301) {
         log_err("unorm2_getNFDInstance() did not return an NFD instance (normalized length=%d; %s)\n",
                 (int)length, u_errorName(errorCode));
     }
 
     errorCode=U_ZERO_ERROR;
     n2=unorm2_getNFKCInstance(&errorCode);
     if(U_FAILURE(errorCode)) {
         log_err_status(errorCode, "unorm2_getNFKCInstance() failed: %s\n", u_errorName(errorCode));
         return;
     }
-    length=unorm2_normalize(n2, in, LENGTHOF(in), out, LENGTHOF(out), &errorCode);
+    length=unorm2_normalize(n2, in, UPRV_LENGTHOF(in), out, UPRV_LENGTHOF(out), &errorCode);
     if(U_FAILURE(errorCode) || length!=2 || out[0]!=0x20 || out[1]!=0x1e08) {
         log_err("unorm2_getNFKCInstance() did not return an NFKC instance (normalized length=%d; %s)\n",
                 (int)length, u_errorName(errorCode));
     }
 
     errorCode=U_ZERO_ERROR;
     n2=unorm2_getNFKDInstance(&errorCode);
     if(U_FAILURE(errorCode)) {
         log_err_status(errorCode, "unorm2_getNFKDInstance() failed: %s\n", u_errorName(errorCode));
         return;
     }
-    length=unorm2_normalize(n2, in, LENGTHOF(in), out, LENGTHOF(out), &errorCode);
+    length=unorm2_normalize(n2, in, UPRV_LENGTHOF(in), out, UPRV_LENGTHOF(out), &errorCode);
     if(U_FAILURE(errorCode) || length!=4 || out[0]!=0x20 || out[1]!=0x43 || out[2]!=0x327 || out[3]!=0x301) {
         log_err("unorm2_getNFKDInstance() did not return an NFKD instance (normalized length=%d; %s)\n",
                 (int)length, u_errorName(errorCode));
     }
 
     errorCode=U_ZERO_ERROR;
     n2=unorm2_getNFKCCasefoldInstance(&errorCode);
     if(U_FAILURE(errorCode)) {
         log_err_status(errorCode, "unorm2_getNFKCCasefoldInstance() failed: %s\n", u_errorName(errorCode));
         return;
     }
-    length=unorm2_normalize(n2, in, LENGTHOF(in), out, LENGTHOF(out), &errorCode);
+    length=unorm2_normalize(n2, in, UPRV_LENGTHOF(in), out, UPRV_LENGTHOF(out), &errorCode);
     if(U_FAILURE(errorCode) || length!=2 || out[0]!=0x20 || out[1]!=0x1e09) {
         log_err("unorm2_getNFKCCasefoldInstance() did not return an NFKC_Casefold instance (normalized length=%d; %s)\n",
                 (int)length, u_errorName(errorCode));
     }
 }
 
 #endif /* #if !UCONFIG_NO_NORMALIZATION */