Update ICU to 54.1 step 1

source/test/cintltst/trie2test.c

 /*
 ******************************************************************************
 *
-*   Copyright (C) 2001-2008, International Business Machines
+*   Copyright (C) 2001-2014, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 ******************************************************************************
 *   file name:  trietest.c
 *   encoding:   US-ASCII
 *   tab size:   8 (not used)
 *   indentation:4
 *
 *   created on: 2008sep01 (starting from a copy of trietest.c)
 *   created by: Markus W. Scherer
 */
 
 #include <stdio.h>
 #include "unicode/utypes.h"
 #include "utrie2.h"
 #include "utrie.h"
 #include "cstring.h"
 #include "cmemory.h"
 #include "udataswp.h"
 #include "cintltst.h"
 
-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
-
 void addTrie2Test(TestNode** root);
 
 /* Values for setting possibly overlapping, out-of-order ranges of values */
 typedef struct SetRange {
     UChar32 start, limit;
     uint32_t value;
     UBool overwrite;
 } SetRange;
 
 /*
@@ skipping 989 matching lines @@
 
 static const CheckRange
 checkRangesSingleValue[]={
     { 0,        3 },
     { 0x110000, 5 }
 };
 
 static void
 TrieTest(void) {
     testTrieRanges("set1", FALSE,
-        setRanges1, LENGTHOF(setRanges1),
-        checkRanges1, LENGTHOF(checkRanges1));
+        setRanges1, UPRV_LENGTHOF(setRanges1),
+        checkRanges1, UPRV_LENGTHOF(checkRanges1));
     testTrieRanges("set2-overlap", FALSE,
-        setRanges2, LENGTHOF(setRanges2),
-        checkRanges2, LENGTHOF(checkRanges2));
+        setRanges2, UPRV_LENGTHOF(setRanges2),
+        checkRanges2, UPRV_LENGTHOF(checkRanges2));
     testTrieRanges("set3-initial-9", FALSE,
-        setRanges3, LENGTHOF(setRanges3),
-        checkRanges3, LENGTHOF(checkRanges3));
+        setRanges3, UPRV_LENGTHOF(setRanges3),
+        checkRanges3, UPRV_LENGTHOF(checkRanges3));
     testTrieRanges("set-empty", FALSE,
         setRangesEmpty, 0,
-        checkRangesEmpty, LENGTHOF(checkRangesEmpty));
+        checkRangesEmpty, UPRV_LENGTHOF(checkRangesEmpty));
     testTrieRanges("set-single-value", FALSE,
-        setRangesSingleValue, LENGTHOF(setRangesSingleValue),
-        checkRangesSingleValue, LENGTHOF(checkRangesSingleValue));
+        setRangesSingleValue, UPRV_LENGTHOF(setRangesSingleValue),
+        checkRangesSingleValue, UPRV_LENGTHOF(checkRangesSingleValue));
 
     testTrieRanges("set2-overlap.withClone", TRUE,
-        setRanges2, LENGTHOF(setRanges2),
-        checkRanges2, LENGTHOF(checkRanges2));
+        setRanges2, UPRV_LENGTHOF(setRanges2),
+        checkRanges2, UPRV_LENGTHOF(checkRanges2));
 }
 
 static void
 EnumNewTrieForLeadSurrogateTest(void) {
     static const char *const testName="enum-for-lead";
     UTrie2 *trie=makeTrieWithRanges(testName, FALSE,
-                                    setRanges2, LENGTHOF(setRanges2),
-                                    checkRanges2, LENGTHOF(checkRanges2));
+                                    setRanges2, UPRV_LENGTHOF(setRanges2),
+                                    checkRanges2, UPRV_LENGTHOF(checkRanges2));
     while(trie!=NULL) {
         const CheckRange *checkRanges;
 
         checkRanges=checkRanges2_d800+1;
         utrie2_enumForLeadSurrogate(trie, 0xd800,
                                     testEnumValue, testEnumRange,
                                     &checkRanges);
         checkRanges=checkRanges2_d87e+1;
         utrie2_enumForLeadSurrogate(trie, 0xd87e,
                                     testEnumValue, testEnumRange,
@@ skipping 50 matching lines @@
     checkRanges[0].value=errorValue;
     checkRanges[1].value=checkRanges[2].value=initialValue;
 
     errorCode=U_ZERO_ERROR;
     trie=utrie2_openDummy(valueBits, initialValue, errorValue, &errorCode);
     if(U_FAILURE(errorCode)) {
         log_err("utrie2_openDummy(valueBits=%d) failed - %s\n", valueBits, u_errorName(errorCode));
         return;
     }
 
-    testFrozenTrie(testName, trie, valueBits, checkRanges, LENGTHOF(checkRanges));
+    testFrozenTrie(testName, trie, valueBits, checkRanges, UPRV_LENGTHOF(checkRanges));
     utrie2_close(trie);
 }
 
 static void
 DummyTrieTest(void) {
     dummyTest(UTRIE2_16_VALUE_BITS);
     dummyTest(UTRIE2_32_VALUE_BITS);
 }
 
 /* test builder memory management ------------------------------------------- */
@@ skipping 40 matching lines @@
     utrie2_set32ForLeadSurrogateCodeUnit(trie, 0xd999, 94, &errorCode);
     utrie2_set32ForLeadSurrogateCodeUnit(trie, 0xdbff, 99, &errorCode);
     if(U_FAILURE(errorCode)) {
         log_err("error: setting lots of ranges into a trie (%s) failed - %s\n",
                 testName, u_errorName(errorCode));
         utrie2_close(trie);
         return;
     }
 
     trie=testTrieSerializeAllValueBits(testName, trie, FALSE,
-                                       checkRanges, LENGTHOF(checkRanges));
+                                       checkRanges, UPRV_LENGTHOF(checkRanges));
     utrie2_close(trie);
 }
 
 static void
 GrowDataArrayTest(void) {
     static const CheckRange
     checkRanges[]={
         { 0,        1 },
         { 0x720,    2 },
         { 0x7a0,    3 },
@@ skipping 37 matching lines @@
     utrie2_set32ForLeadSurrogateCodeUnit(trie, 0xd999, 94, &errorCode);
     utrie2_set32ForLeadSurrogateCodeUnit(trie, 0xdbff, 99, &errorCode);
     if(U_FAILURE(errorCode)) {
         log_err("error: setting lots of values into a trie (%s) failed - %s\n",
                 testName, u_errorName(errorCode));
         utrie2_close(trie);
         return;
     }
 
     trie=testTrieSerializeAllValueBits(testName, trie, FALSE,
-                                          checkRanges, LENGTHOF(checkRanges));
+                                          checkRanges, UPRV_LENGTHOF(checkRanges));
     utrie2_close(trie);
 }
 
 /* versions 1 and 2 --------------------------------------------------------- */
 
 static void
 GetVersionTest(void) {
     uint32_t data[4];
     if( /* version 1 */
         (data[0]=0x54726965, 1!=utrie2_getVersion(data, sizeof(data), FALSE)) ||
@@ skipping 141 matching lines @@
                 break;
             }
         }
     }
     utrie2_close(trie2);
 }
 
 static void
 Trie12ConversionTest(void) {
     testTrie2FromTrie1("trie1->trie2",
-                       setRanges2, LENGTHOF(setRanges2),
-                       checkRanges2, LENGTHOF(checkRanges2));
+                       setRanges2, UPRV_LENGTHOF(setRanges2),
+                       checkRanges2, UPRV_LENGTHOF(checkRanges2));
 }
 
 void
 addTrie2Test(TestNode** root) {
     addTest(root, &TrieTest, "tsutil/trie2test/TrieTest");
     addTest(root, &EnumNewTrieForLeadSurrogateTest,
                   "tsutil/trie2test/EnumNewTrieForLeadSurrogateTest");
     addTest(root, &DummyTrieTest, "tsutil/trie2test/DummyTrieTest");
     addTest(root, &FreeBlocksTest, "tsutil/trie2test/FreeBlocksTest");
     addTest(root, &GrowDataArrayTest, "tsutil/trie2test/GrowDataArrayTest");
     addTest(root, &GetVersionTest, "tsutil/trie2test/GetVersionTest");
     addTest(root, &Trie12ConversionTest, "tsutil/trie2test/Trie12ConversionTest");
 }