Update ICU to 54.1 step 1

source/test/intltest/ucharstrietest.cpp

 /*
 *******************************************************************************
-*   Copyright (C) 2010-2013, International Business Machines
+*   Copyright (C) 2010-2014, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *******************************************************************************
 *   file name:  ucharstrietest.cpp
 *   encoding:   US-ASCII
 *   tab size:   8 (not used)
 *   indentation:4
 *
 *   created on: 2010nov16
 *   created by: Markus W. Scherer
 */
 
 #include <string.h>
 
 #include "unicode/utypes.h"
 #include "unicode/appendable.h"
 #include "unicode/localpointer.h"
 #include "unicode/ucharstrie.h"
 #include "unicode/ucharstriebuilder.h"
 #include "unicode/uniset.h"
 #include "unicode/unistr.h"
 #include "intltest.h"
-
-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
+#include "cmemory.h"
 
 struct StringAndValue {
     const char *s;
     int32_t value;
 };
 
 class UCharsTrieTest : public IntlTest {
 public:
     UCharsTrieTest();
     virtual ~UCharsTrieTest();
@@ skipping 94 matching lines @@
     if(errorCode.reset()!=U_ILLEGAL_ARGUMENT_ERROR) {
         errln("UCharsTrieBuilder.add() did not detect duplicates");
         return;
     }
 }
 
 void UCharsTrieTest::TestEmpty() {
     static const StringAndValue data[]={
         { "", 0 }
     };
-    checkData(data, LENGTHOF(data));
+    checkData(data, UPRV_LENGTHOF(data));
 }
 
 void UCharsTrieTest::Test_a() {
     static const StringAndValue data[]={
         { "a", 1 }
     };
-    checkData(data, LENGTHOF(data));
+    checkData(data, UPRV_LENGTHOF(data));
 }
 
 void UCharsTrieTest::Test_a_ab() {
     static const StringAndValue data[]={
         { "a", 1 },
         { "ab", 100 }
     };
-    checkData(data, LENGTHOF(data));
+    checkData(data, UPRV_LENGTHOF(data));
 }
 
 void UCharsTrieTest::TestShortestBranch() {
     static const StringAndValue data[]={
         { "a", 1000 },
         { "b", 2000 }
     };
-    checkData(data, LENGTHOF(data));
+    checkData(data, UPRV_LENGTHOF(data));
 }
 
 void UCharsTrieTest::TestBranches() {
     static const StringAndValue data[]={
         { "a", 0x10 },
         { "cc", 0x40 },
         { "e", 0x100 },
         { "ggg", 0x400 },
         { "i", 0x1000 },
         { "kkkk", 0x4000 },
         { "n", 0x10000 },
         { "ppppp", 0x40000 },
         { "r", 0x100000 },
         { "sss", 0x200000 },
         { "t", 0x400000 },
         { "uu", 0x800000 },
         { "vv", 0x7fffffff },
         { "zz", (int32_t)0x80000000 }
     };
-    for(int32_t length=2; length<=LENGTHOF(data); ++length) {
+    for(int32_t length=2; length<=UPRV_LENGTHOF(data); ++length) {
         logln("TestBranches length=%d", (int)length);
         checkData(data, length);
     }
 }
 
 void UCharsTrieTest::TestLongSequence() {
     static const StringAndValue data[]={
         { "a", -1 },
         // sequence of linear-match nodes
         { "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", -2 },
         // more than 256 units
         { "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
           "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
           "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
           "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
           "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
           "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", -3 }
     };
-    checkData(data, LENGTHOF(data));
+    checkData(data, UPRV_LENGTHOF(data));
 }
 
 void UCharsTrieTest::TestLongBranch() {
     // Split-branch and interesting compact-integer values.
     static const StringAndValue data[]={
         { "a", -2 },
         { "b", -1 },
         { "c", 0 },
         { "d2", 1 },
         { "f", 0x3f },
         { "g", 0x40 },
         { "h", 0x41 },
         { "j23", 0x1900 },
         { "j24", 0x19ff },
         { "j25", 0x1a00 },
         { "k2", 0x1a80 },
         { "k3", 0x1aff },
         { "l234567890", 0x1b00 },
         { "l234567890123", 0x1b01 },
         { "nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn", 0x10ffff },
         { "oooooooooooooooooooooooooooooooooooooooooooooooooooooo", 0x110000 },
         { "pppppppppppppppppppppppppppppppppppppppppppppppppppppp", 0x120000 },
         { "r", 0x333333 },
         { "s2345", 0x4444444 },
         { "t234567890", 0x77777777 },
         { "z", (int32_t)0x80000001 }
     };
-    checkData(data, LENGTHOF(data));
+    checkData(data, UPRV_LENGTHOF(data));
 }
 
 void UCharsTrieTest::TestValuesForState() {
     // Check that saveState() and resetToState() interact properly
     // with next() and current().
     static const StringAndValue data[]={
         { "a", -1 },
         { "ab", -2 },
         { "abc", -3 },
         { "abcd", -4 },
         { "abcde", -5 },
         { "abcdef", -6 }
     };
-    checkData(data, LENGTHOF(data));
+    checkData(data, UPRV_LENGTHOF(data));
 }
 
 void UCharsTrieTest::TestCompact() {
     // Duplicate trailing strings and values provide opportunities for compacting.
     static const StringAndValue data[]={
         { "+", 0 },
         { "+august", 8 },
         { "+december", 12 },
         { "+july", 7 },
         { "+june", 6 },
         { "+november", 11 },
         { "+october", 10 },
         { "+september", 9 },
         { "-", 0 },
         { "-august", 8 },
         { "-december", 12 },
         { "-july", 7 },
         { "-june", 6 },
         { "-november", 11 },
         { "-october", 10 },
         { "-september", 9 },
         // The l+n branch (with its sub-nodes) is a duplicate but will be written
         // both times because each time it follows a different linear-match node.
         { "xjuly", 7 },
         { "xjune", 6 }
     };
-    checkData(data, LENGTHOF(data));
+    checkData(data, UPRV_LENGTHOF(data));
 }
 
 void UCharsTrieTest::TestFirstForCodePoint() {
     static const StringAndValue data[]={
         { "a", 1 },
         { "a\\ud800", 2 },
         { "a\\U00010000", 3 },
         { "\\ud840", 4 },
         { "\\U00020000\\udbff", 5 },
         { "\\U00020000\\U0010ffff", 6 },
         { "\\U00020000\\U0010ffffz", 7 },
         { "\\U00050000xy", 8 },
         { "\\U00050000xyz", 9 }
     };
-    checkData(data, LENGTHOF(data));
+    checkData(data, UPRV_LENGTHOF(data));
 }
 
 void UCharsTrieTest::TestNextForCodePoint() {
     static const StringAndValue data[]={
         { "\\u4dff\\U00010000\\u9999\\U00020000\\udfff\\U0010ffff", 2000000000 },
         { "\\u4dff\\U00010000\\u9999\\U00020002", 44444 },
         { "\\u4dff\\U000103ff", 99999 }
     };
-    LocalPointer<UCharsTrie> trie(buildTrie(data, LENGTHOF(data), USTRINGTRIE_BUILD_FAST));
+    LocalPointer<UCharsTrie> trie(buildTrie(data, UPRV_LENGTHOF(data), USTRINGTRIE_BUILD_FAST));
     if(trie.isNull()) {
         return;  // buildTrie() reported an error
     }
     UStringTrieResult result;
     if( (result=trie->nextForCodePoint(0x4dff))!=USTRINGTRIE_NO_VALUE || result!=trie->current() ||
         (result=trie->nextForCodePoint(0x10000))!=USTRINGTRIE_NO_VALUE || result!=trie->current() ||
         (result=trie->nextForCodePoint(0x9999))!=USTRINGTRIE_NO_VALUE || result!=trie->current() ||
         (result=trie->nextForCodePoint(0x20000))!=USTRINGTRIE_NO_VALUE || result!=trie->current() ||
         (result=trie->nextForCodePoint(0xdfff))!=USTRINGTRIE_NO_VALUE || result!=trie->current() ||
         (result=trie->nextForCodePoint(0x10ffff))!=USTRINGTRIE_FINAL_VALUE || result!=trie->current() ||
@@ skipping 143 matching lines @@
         { "janpp", 1 },
         { "janqqq", 1 },
         { "janr", 1 },
         { "januar", 1 },
         { "january", 1 },
         { "july", 7 },
         { "jun", 6 },
         { "jun.", 6 },
         { "june", 6 }
     };
-    return buildTrie(data, LENGTHOF(data), buildOption);
+    return buildTrie(data, UPRV_LENGTHOF(data), buildOption);
 }
 
 void UCharsTrieTest::TestHasUniqueValue() {
     LocalPointer<UCharsTrie> trie(buildMonthsTrie(USTRINGTRIE_BUILD_FAST));
     if(trie.isNull()) {
         return;  // buildTrie() reported an error
     }
     int32_t uniqueValue;
     if(trie->hasUniqueValue(uniqueValue)) {
         errln("unique value at root");
@@ skipping 111 matching lines @@
         { "l", 1 },
         { "m", 1 },
         { "nnnnnnnnnnnnnnnnnnnnnnnnnnnn", 1 },
         { "o", 1 },
         { "pp", 1 },
         { "qqq", 1 },
         { "r", 1 },
         { "uar", 1 },
         { "uary", 1 }
     };
-    checkIterator(iter, data, LENGTHOF(data));
+    checkIterator(iter, data, UPRV_LENGTHOF(data));
     // Reset, and we should get the same result.
     logln("after iter.reset()");
-    checkIterator(iter.reset(), data, LENGTHOF(data));
+    checkIterator(iter.reset(), data, UPRV_LENGTHOF(data));
 }
 
 void UCharsTrieTest::TestIteratorFromLinearMatch() {
     LocalPointer<UCharsTrie> trie(buildMonthsTrie(USTRINGTRIE_BUILD_SMALL));
     if(trie.isNull()) {
         return;  // buildTrie() reported an error
     }
     // Go into a linear-match node.
     trie->next(u_j);
     trie->next(u_a);
     trie->next(u_n);
     trie->next(u_u);
     trie->next(u_a);
     IcuTestErrorCode errorCode(*this, "TestIteratorFromLinearMatch()");
     UCharsTrie::Iterator iter(*trie, 0, errorCode);
     if(errorCode.logIfFailureAndReset("UCharsTrie::Iterator(trie) constructor")) {
         return;
     }
     // Expected data: Same as in buildMonthsTrie(), except only the suffixes
     // following "janua".
     static const StringAndValue data[]={
         { "r", 1 },
         { "ry", 1 }
     };
-    checkIterator(iter, data, LENGTHOF(data));
+    checkIterator(iter, data, UPRV_LENGTHOF(data));
     // Reset, and we should get the same result.
     logln("after iter.reset()");
-    checkIterator(iter.reset(), data, LENGTHOF(data));
+    checkIterator(iter.reset(), data, UPRV_LENGTHOF(data));
 }
 
 void UCharsTrieTest::TestTruncatingIteratorFromRoot() {
     LocalPointer<UCharsTrie> trie(buildMonthsTrie(USTRINGTRIE_BUILD_FAST));
     if(trie.isNull()) {
         return;  // buildTrie() reported an error
     }
     IcuTestErrorCode errorCode(*this, "TestTruncatingIteratorFromRoot()");
     UCharsTrie::Iterator iter(*trie, 4, errorCode);
     if(errorCode.logIfFailureAndReset("UCharsTrie::Iterator(trie) constructor")) {
@@ skipping 22 matching lines @@
         { "jano", 1 },
         { "janp", -1 },
         { "janq", -1 },
         { "janr", 1 },
         { "janu", -1 },
         { "july", 7 },
         { "jun", 6 },
         { "jun.", 6 },
         { "june", 6 }
     };
-    checkIterator(iter, data, LENGTHOF(data));
+    checkIterator(iter, data, UPRV_LENGTHOF(data));
     // Reset, and we should get the same result.
     logln("after iter.reset()");
-    checkIterator(iter.reset(), data, LENGTHOF(data));
+    checkIterator(iter.reset(), data, UPRV_LENGTHOF(data));
 }
 
 void UCharsTrieTest::TestTruncatingIteratorFromLinearMatchShort() {
     static const StringAndValue data[]={
         { "abcdef", 10 },
         { "abcdepq", 200 },
         { "abcdeyz", 3000 }
     };
-    LocalPointer<UCharsTrie> trie(buildTrie(data, LENGTHOF(data), USTRINGTRIE_BUILD_FAST));
+    LocalPointer<UCharsTrie> trie(buildTrie(data, UPRV_LENGTHOF(data), USTRINGTRIE_BUILD_FAST));
     if(trie.isNull()) {
         return;  // buildTrie() reported an error
     }
     // Go into a linear-match node.
     trie->next(u_a);
     trie->next(u_b);
     IcuTestErrorCode errorCode(*this, "TestTruncatingIteratorFromLinearMatchShort()");
     // Truncate within the linear-match node.
     UCharsTrie::Iterator iter(*trie, 2, errorCode);
     if(errorCode.logIfFailureAndReset("UCharsTrie::Iterator(trie) constructor")) {
         return;
     }
     static const StringAndValue expected[]={
         { "cd", -1 }
     };
-    checkIterator(iter, expected, LENGTHOF(expected));
+    checkIterator(iter, expected, UPRV_LENGTHOF(expected));
     // Reset, and we should get the same result.
     logln("after iter.reset()");
-    checkIterator(iter.reset(), expected, LENGTHOF(expected));
+    checkIterator(iter.reset(), expected, UPRV_LENGTHOF(expected));
 }
 
 void UCharsTrieTest::TestTruncatingIteratorFromLinearMatchLong() {
     static const StringAndValue data[]={
         { "abcdef", 10 },
         { "abcdepq", 200 },
         { "abcdeyz", 3000 }
     };
-    LocalPointer<UCharsTrie> trie(buildTrie(data, LENGTHOF(data), USTRINGTRIE_BUILD_FAST));
+    LocalPointer<UCharsTrie> trie(buildTrie(data, UPRV_LENGTHOF(data), USTRINGTRIE_BUILD_FAST));
     if(trie.isNull()) {
         return;  // buildTrie() reported an error
     }
     // Go into a linear-match node.
     trie->next(u_a);
     trie->next(u_b);
     trie->next(u_c);
     IcuTestErrorCode errorCode(*this, "TestTruncatingIteratorFromLinearMatchLong()");
     // Truncate after the linear-match node.
     UCharsTrie::Iterator iter(*trie, 3, errorCode);
     if(errorCode.logIfFailureAndReset("UCharsTrie::Iterator(trie) constructor")) {
         return;
     }
     static const StringAndValue expected[]={
         { "def", 10 },
         { "dep", -1 },
         { "dey", -1 }
     };
-    checkIterator(iter, expected, LENGTHOF(expected));
+    checkIterator(iter, expected, UPRV_LENGTHOF(expected));
     // Reset, and we should get the same result.
     logln("after iter.reset()");
-    checkIterator(iter.reset(), expected, LENGTHOF(expected));
+    checkIterator(iter.reset(), expected, UPRV_LENGTHOF(expected));
 }
 
 void UCharsTrieTest::TestIteratorFromUChars() {
     static const StringAndValue data[]={
         { "mm", 3 },
         { "mmm", 33 },
         { "mmnop", 333 }
     };
     builder_->clear();
     IcuTestErrorCode errorCode(*this, "TestIteratorFromUChars()");
-    for(int32_t i=0; i<LENGTHOF(data); ++i) {
+    for(int32_t i=0; i<UPRV_LENGTHOF(data); ++i) {
         builder_->add(data[i].s, data[i].value, errorCode);
     }
     UnicodeString trieUChars;
     builder_->buildUnicodeString(USTRINGTRIE_BUILD_FAST, trieUChars, errorCode);
     UCharsTrie::Iterator iter(trieUChars.getBuffer(), 0, errorCode);
-    checkIterator(iter, data, LENGTHOF(data));
+    checkIterator(iter, data, UPRV_LENGTHOF(data));
 }
 
 void UCharsTrieTest::checkData(const StringAndValue data[], int32_t dataLength) {
     logln("checkData(dataLength=%d, fast)", (int)dataLength);
     checkData(data, dataLength, USTRINGTRIE_BUILD_FAST);
     logln("checkData(dataLength=%d, small)", (int)dataLength);
     checkData(data, dataLength, USTRINGTRIE_BUILD_SMALL);
 }
 
 void UCharsTrieTest::checkData(const StringAndValue data[], int32_t dataLength, UStringTrieBuildOption buildOption) {
@@ skipping 272 matching lines @@
             break;
         }
         if(!hasNext) {
             errln("trie iterator next()=FALSE for item %d: %s", (int)i, data[i].s);
             break;
         }
         UnicodeString expectedString=UnicodeString(data[i].s, -1, US_INV).unescape();
         if(iter.getString()!=expectedString) {
             char buffer[1000];
             UnicodeString invString(prettify(iter.getString()));
-            invString.extract(0, invString.length(), buffer, LENGTHOF(buffer), US_INV);
+            invString.extract(0, invString.length(), buffer, UPRV_LENGTHOF(buffer), US_INV);
             errln("trie iterator next().getString()=%s but expected %s for item %d",
                   buffer, data[i].s, (int)i);
         }
         if(iter.getValue()!=data[i].value) {
             errln("trie iterator next().getValue()=%ld=0x%lx but expected %ld=0x%lx for item %d: %s",
                   (long)iter.getValue(), (long)iter.getValue(),
                   (long)data[i].value, (long)data[i].value,
                   (int)i, data[i].s);
         }
     }
     if(iter.hasNext()) {
         errln("trie iterator hasNext()=TRUE after all items");
     }
     UBool hasNext=iter.next(errorCode);
     errorCode.logIfFailureAndReset("trie iterator next() after all items");
     if(hasNext) {
         errln("trie iterator next()=TRUE after all items");
     }
 }