Update ICU to 54.1 step 1

source/test/intltest/tstnorm.cpp

 /********************************************************************
  * COPYRIGHT: 
- * Copyright (c) 1997-2011, International Business Machines Corporation and
+ * Copyright (c) 1997-2014, International Business Machines Corporation and
  * others. All Rights Reserved.
  ********************************************************************/
 
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_NORMALIZATION
 
 #include "unicode/uchar.h"
 #include "unicode/errorcode.h"
 #include "unicode/normlzr.h"
 #include "unicode/uniset.h"
 #include "unicode/usetiter.h"
 #include "unicode/schriter.h"
 #include "unicode/utf16.h"
 #include "cstring.h"
 #include "normalizer2impl.h"
 #include "tstnorm.h"
 
-#define LENGTHOF(array) ((int32_t)(sizeof(array)/sizeof((array)[0])))
-#define ARRAY_LENGTH(array) LENGTHOF(array)
+#define ARRAY_LENGTH(array) UPRV_LENGTHOF(array)
 
 #define CASE(id,test) case id:                          \
                           name = #test;                 \
                           if (exec) {                   \
                               logln(#test "---");       \
                               logln((UnicodeString)""); \
                               test();                   \
                           }                             \
                           break
 
@@ skipping 706 matching lines @@
         EXPECT_MIDDLE=3,
         SRC_MIDDLE_2=2,
         EXPECT_MIDDLE_2=1
     };
 
     // movement vector
     // - for previous(), 0 for current(), + for next()
     // for both sets of test data
     static const char *const moves="0+0+0--0-0-+++0--+++++++0--------";
 
-    TestPreviousNext(src, LENGTHOF(src),
-                     expect, LENGTHOF(expect),
+    TestPreviousNext(src, UPRV_LENGTHOF(src),
+                     expect, UPRV_LENGTHOF(expect),
                      expectIndex,
                      SRC_MIDDLE, EXPECT_MIDDLE,
                      moves, UNORM_NFD, "basic");
 
-    TestPreviousNext(src_j2911, LENGTHOF(src_j2911),
-                     expect_j2911, LENGTHOF(expect_j2911),
+    TestPreviousNext(src_j2911, UPRV_LENGTHOF(src_j2911),
+                     expect_j2911, UPRV_LENGTHOF(expect_j2911),
                      expectIndex_j2911,
                      SRC_MIDDLE, EXPECT_MIDDLE,
                      moves, UNORM_NFKC, "j2911");
 
     // try again from different "middle" indexes
-    TestPreviousNext(src, LENGTHOF(src),
-                     expect, LENGTHOF(expect),
+    TestPreviousNext(src, UPRV_LENGTHOF(src),
+                     expect, UPRV_LENGTHOF(expect),
                      expectIndex,
                      SRC_MIDDLE_2, EXPECT_MIDDLE_2,
                      moves, UNORM_NFD, "basic_2");
 
-    TestPreviousNext(src_j2911, LENGTHOF(src_j2911),
-                     expect_j2911, LENGTHOF(expect_j2911),
+    TestPreviousNext(src_j2911, UPRV_LENGTHOF(src_j2911),
+                     expect_j2911, UPRV_LENGTHOF(expect_j2911),
                      expectIndex_j2911,
                      SRC_MIDDLE_2, EXPECT_MIDDLE_2,
                      moves, UNORM_NFKC, "j2911_2");
 }
 
 void BasicNormalizerTest::TestConcatenate() {
     static const char *const
     cases[][4]={
         /* mode, left, right, result */
         {
@@ skipping 276 matching lines @@
     } opt[]={
         { 0, "default" },
         { U_COMPARE_CODE_POINT_ORDER, "c.p. order" },
         { U_COMPARE_IGNORE_CASE, "ignore case" },
         { U_COMPARE_CODE_POINT_ORDER|U_COMPARE_IGNORE_CASE, "c.p. order & ignore case" },
         { U_COMPARE_IGNORE_CASE|U_FOLD_CASE_EXCLUDE_SPECIAL_I, "ignore case & special i" },
         { U_COMPARE_CODE_POINT_ORDER|U_COMPARE_IGNORE_CASE|U_FOLD_CASE_EXCLUDE_SPECIAL_I, "c.p. order & ignore case & special i" },
         { UNORM_UNICODE_3_2<<UNORM_COMPARE_NORM_OPTIONS_SHIFT, "Unicode 3.2" }
     };
 
-    int32_t i, j, k, count=LENGTHOF(strings);
+    int32_t i, j, k, count=UPRV_LENGTHOF(strings);
     int32_t result, refResult;
 
     UErrorCode errorCode;
 
     // create the UnicodeStrings
     for(i=0; i<count; ++i) {
         s[i]=UnicodeString(strings[i], "").unescape();
     }
 
     // test them each with each other
     for(i=0; i<count; ++i) {
         for(j=i; j<count; ++j) {
-            for(k=0; k<LENGTHOF(opt); ++k) {
+            for(k=0; k<UPRV_LENGTHOF(opt); ++k) {
                 // test Normalizer::compare
                 errorCode=U_ZERO_ERROR;
                 result=_norm_compare(s[i], s[j], opt[k].options, errorCode);
                 refResult=ref_norm_compare(s[i], s[j], opt[k].options, errorCode);
                 if(_sign(result)!=_sign(refResult)) {
                     errln("Normalizer::compare(%d, %d, %s)%s should be %s %s",
                         i, j, opt[k].name, _signString(result), _signString(refResult),
                         U_SUCCESS(errorCode) ? "" : u_errorName(errorCode));
                 }
 
@@ skipping 19 matching lines @@
     UnicodeString s1, s2;
 
     const Normalizer2Impl *nfcImpl=Normalizer2Factory::getNFCImpl(errorCode);
     if(U_FAILURE(errorCode) || !nfcImpl->ensureCanonIterData(errorCode)) {
         dataerrln("Normalizer2Factory::getNFCImpl().ensureCanonIterData() failed: %s",
               u_errorName(errorCode));
         return;
     }
 
     // collect all sets into one for contiguous output
-    for(i=0; i<LENGTHOF(iI); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(iI); ++i) {
         if(nfcImpl->getCanonStartSet(iI[i], iSet)) {
             set.addAll(iSet);
         }
     }
 
     // test all of these precomposed characters
-    const Normalizer2 *nfcNorm2=Normalizer2Factory::getNFCInstance(errorCode);
+    const Normalizer2 *nfcNorm2=Normalizer2::getNFCInstance(errorCode);
     UnicodeSetIterator it(set);
     while(it.next() && !it.isString()) {
         UChar32 c=it.getCodepoint();
         if(!nfcNorm2->getDecomposition(c, s2)) {
             dataerrln("NFC.getDecomposition(i-composite U+%04lx) failed", (long)c);
             return;
         }
 
         s1.setTo(c);
-        for(k=0; k<LENGTHOF(opt); ++k) {
+        for(k=0; k<UPRV_LENGTHOF(opt); ++k) {
             // test Normalizer::compare
             errorCode=U_ZERO_ERROR;
             result=_norm_compare(s1, s2, opt[k].options, errorCode);
             refResult=ref_norm_compare(s1, s2, opt[k].options, errorCode);
             if(_sign(result)!=_sign(refResult)) {
                 errln("Normalizer::compare(U+%04x with its NFD, %s)%s should be %s %s",
                     c, opt[k].name, _signString(result), _signString(refResult),
                     U_SUCCESS(errorCode) ? "" : u_errorName(errorCode));
             }
 
@@ skipping 283 matching lines @@
         { "\\uE111\\u1161\\uE112\\u1162", "\\uAE4C\\u1102\\u0062\\u1162" },
         { "\\uFFF3\\uFFF7\\U00010036\\U00010077", "\\U00010037\\U00010037\\uFFF6\\U00010037" }
     };
     IcuTestErrorCode errorCode(*this, "BasicNormalizerTest/TestCustomComp");
     const Normalizer2 *customNorm2=
         Normalizer2::getInstance(loadTestData(errorCode), "testnorm",
                                  UNORM2_COMPOSE, errorCode);
     if(errorCode.logDataIfFailureAndReset("unable to load testdata/testnorm.nrm")) {
         return;
     }
-    for(int32_t i=0; i<LENGTHOF(pairs); ++i) {
+    for(int32_t i=0; i<UPRV_LENGTHOF(pairs); ++i) {
         const StringPair &pair=pairs[i];
         UnicodeString input=UnicodeString(pair.input, -1, US_INV).unescape();
         UnicodeString expected=UnicodeString(pair.expected, -1, US_INV).unescape();
         UnicodeString result=customNorm2->normalize(input, errorCode);
         if(result!=expected) {
             errln("custom compose Normalizer2 did not normalize input %d as expected", i);
         }
     }
 }
 
@@ skipping 11 matching lines @@
         { "\\uE111\\u1161\\uE112\\u1162", "\\uAE4C\\u1102\\u0062\\u1162" },
         { "\\uFFF3\\uFFF7\\U00010036\\U00010077", "\\U00010037\\U00010037\\uFFF6\\U00010037" }
     };
     IcuTestErrorCode errorCode(*this, "BasicNormalizerTest/TestCustomFCC");
     const Normalizer2 *customNorm2=
         Normalizer2::getInstance(loadTestData(errorCode), "testnorm",
                                  UNORM2_COMPOSE_CONTIGUOUS, errorCode);
     if(errorCode.logDataIfFailureAndReset("unable to load testdata/testnorm.nrm")) {
         return;
     }
-    for(int32_t i=0; i<LENGTHOF(pairs); ++i) {
+    for(int32_t i=0; i<UPRV_LENGTHOF(pairs); ++i) {
         const StringPair &pair=pairs[i];
         UnicodeString input=UnicodeString(pair.input, -1, US_INV).unescape();
         UnicodeString expected=UnicodeString(pair.expected, -1, US_INV).unescape();
         UnicodeString result=customNorm2->normalize(input, errorCode);
         if(result!=expected) {
             errln("custom FCC Normalizer2 did not normalize input %d as expected", i);
         }
     }
 }
 
 /* Improve code coverage of Normalizer2 */
 void
 BasicNormalizerTest::TestFilteredNormalizer2Coverage() {
     UErrorCode errorCode = U_ZERO_ERROR;
-    const Normalizer2 *nfcNorm2=Normalizer2Factory::getNFCInstance(errorCode);
+    const Normalizer2 *nfcNorm2=Normalizer2::getNFCInstance(errorCode);
     if (U_FAILURE(errorCode)) {
-        dataerrln("Normalizer2Factory::getNFCInstance() call failed - %s", u_errorName(status));
+        dataerrln("Normalizer2::getNFCInstance() call failed - %s", u_errorName(status));
         return;
     }
     UnicodeSet filter(UNICODE_STRING_SIMPLE("[^\\u00a0-\\u00ff\\u0310-\\u031f]"), errorCode);
     FilteredNormalizer2 fn2(*nfcNorm2, filter);
 
     UChar32 char32 = 0x0054;
 
     if (fn2.isInert(char32)) {
         errln("FilteredNormalizer2.isInert() failed.");
     }
@@ skipping 16 matching lines @@
 
     UnicodeString newString1 = UNICODE_STRING_SIMPLE("[^\\u0100-\\u01ff]");
     UnicodeString newString2 = UNICODE_STRING_SIMPLE("[^\\u0200-\\u02ff]");
     fn2.append(newString1, newString2, errorCode);
     if (U_FAILURE(errorCode)) {
         errln("FilteredNormalizer2.append() failed.");
     }
 }
 
 #endif /* #if !UCONFIG_NO_NORMALIZATION */