Update ICU to 54.1 step 1

source/test/intltest/bytestrietest.cpp

 /*
 *******************************************************************************
-*   Copyright (C) 2010-2013, International Business Machines
+*   Copyright (C) 2010-2014, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *******************************************************************************
 *   file name:  bytetrietest.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/bytestrie.h"
 #include "unicode/bytestriebuilder.h"
 #include "unicode/localpointer.h"
 #include "unicode/stringpiece.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 BytesTrieTest : public IntlTest {
 public:
     BytesTrieTest();
     virtual ~BytesTrieTest();
@@ skipping 87 matching lines @@
     if(errorCode.reset()!=U_ILLEGAL_ARGUMENT_ERROR) {
         errln("BytesTrieBuilder.add() did not detect duplicates");
         return;
     }
 }
 
 void BytesTrieTest::TestEmpty() {
     static const StringAndValue data[]={
         { "", 0 }
     };
-    checkData(data, LENGTHOF(data));
+    checkData(data, UPRV_LENGTHOF(data));
 }
 
 void BytesTrieTest::Test_a() {
     static const StringAndValue data[]={
         { "a", 1 }
     };
-    checkData(data, LENGTHOF(data));
+    checkData(data, UPRV_LENGTHOF(data));
 }
 
 void BytesTrieTest::Test_a_ab() {
     static const StringAndValue data[]={
         { "a", 1 },
         { "ab", 100 }
     };
-    checkData(data, LENGTHOF(data));
+    checkData(data, UPRV_LENGTHOF(data));
 }
 
 void BytesTrieTest::TestShortestBranch() {
     static const StringAndValue data[]={
         { "a", 1000 },
         { "b", 2000 }
     };
-    checkData(data, LENGTHOF(data));
+    checkData(data, UPRV_LENGTHOF(data));
 }
 
 void BytesTrieTest::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 BytesTrieTest::TestLongSequence() {
     static const StringAndValue data[]={
         { "a", -1 },
         // sequence of linear-match nodes
         { "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", -2 },
         // more than 256 bytes
         { "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
           "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
           "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
           "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
           "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
           "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", -3 }
     };
-    checkData(data, LENGTHOF(data));
+    checkData(data, UPRV_LENGTHOF(data));
 }
 
 void BytesTrieTest::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 BytesTrieTest::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 BytesTrieTest::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));
 }
 
 BytesTrie *BytesTrieTest::buildMonthsTrie(UStringTrieBuildOption buildOption) {
     // All types of nodes leading to the same value,
     // for code coverage of recursive functions.
     // In particular, we need a lot of branches on some single level
     // to exercise a split-branch node.
     static const StringAndValue data[]={
         { "august", 8 },
         { "jan", 1 },
@@ skipping 19 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 BytesTrieTest::TestHasUniqueValue() {
     LocalPointer<BytesTrie> 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 24 matching lines @@
         errln("not unique value 8 after \"au\"");
     }
 }
 
 void BytesTrieTest::TestGetNextBytes() {
     LocalPointer<BytesTrie> trie(buildMonthsTrie(USTRINGTRIE_BUILD_SMALL));
     if(trie.isNull()) {
         return;  // buildTrie() reported an error
     }
     char buffer[40];
-    CheckedArrayByteSink sink(buffer, LENGTHOF(buffer));
+    CheckedArrayByteSink sink(buffer, UPRV_LENGTHOF(buffer));
     int32_t count=trie->getNextBytes(sink);
     if(count!=2 || sink.NumberOfBytesAppended()!=2 || buffer[0]!='a' || buffer[1]!='j') {
         errln("months getNextBytes()!=[aj] at root");
     }
     trie->next('j');
     trie->next('a');
     trie->next('n');
     // getNextBytes() directly after next()
     count=trie->getNextBytes(sink.Reset());
     buffer[count]=0;
@@ skipping 65 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 BytesTrieTest::TestIteratorFromLinearMatch() {
     LocalPointer<BytesTrie> trie(buildMonthsTrie(USTRINGTRIE_BUILD_SMALL));
     if(trie.isNull()) {
         return;  // buildTrie() reported an error
     }
     // Go into a linear-match node.
     trie->next('j');
     trie->next('a');
     trie->next('n');
     trie->next('u');
     trie->next('a');
     IcuTestErrorCode errorCode(*this, "TestIteratorFromLinearMatch()");
     BytesTrie::Iterator iter(*trie, 0, errorCode);
     if(errorCode.logIfFailureAndReset("BytesTrie::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 BytesTrieTest::TestTruncatingIteratorFromRoot() {
     LocalPointer<BytesTrie> trie(buildMonthsTrie(USTRINGTRIE_BUILD_FAST));
     if(trie.isNull()) {
         return;  // buildTrie() reported an error
     }
     IcuTestErrorCode errorCode(*this, "TestTruncatingIteratorFromRoot()");
     BytesTrie::Iterator iter(*trie, 4, errorCode);
     if(errorCode.logIfFailureAndReset("BytesTrie::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 BytesTrieTest::TestTruncatingIteratorFromLinearMatchShort() {
     static const StringAndValue data[]={
         { "abcdef", 10 },
         { "abcdepq", 200 },
         { "abcdeyz", 3000 }
     };
-    LocalPointer<BytesTrie> trie(buildTrie(data, LENGTHOF(data), USTRINGTRIE_BUILD_FAST));
+    LocalPointer<BytesTrie> 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('a');
     trie->next('b');
     IcuTestErrorCode errorCode(*this, "TestTruncatingIteratorFromLinearMatchShort()");
     // Truncate within the linear-match node.
     BytesTrie::Iterator iter(*trie, 2, errorCode);
     if(errorCode.logIfFailureAndReset("BytesTrie::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 BytesTrieTest::TestTruncatingIteratorFromLinearMatchLong() {
     static const StringAndValue data[]={
         { "abcdef", 10 },
         { "abcdepq", 200 },
         { "abcdeyz", 3000 }
     };
-    LocalPointer<BytesTrie> trie(buildTrie(data, LENGTHOF(data), USTRINGTRIE_BUILD_FAST));
+    LocalPointer<BytesTrie> 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('a');
     trie->next('b');
     trie->next('c');
     IcuTestErrorCode errorCode(*this, "TestTruncatingIteratorFromLinearMatchLong()");
     // Truncate after the linear-match node.
     BytesTrie::Iterator iter(*trie, 3, errorCode);
     if(errorCode.logIfFailureAndReset("BytesTrie::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 BytesTrieTest::TestIteratorFromBytes() {
     static const StringAndValue data[]={
         { "mm", 3 },
         { "mmm", 33 },
         { "mmnop", 333 }
     };
     builder_->clear();
     IcuTestErrorCode errorCode(*this, "TestIteratorFromBytes()");
-    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);
     }
     StringPiece trieBytes=builder_->buildStringPiece(USTRINGTRIE_BUILD_FAST, errorCode);
     BytesTrie::Iterator iter(trieBytes.data(), 0, errorCode);
-    checkIterator(iter, data, LENGTHOF(data));
+    checkIterator(iter, data, UPRV_LENGTHOF(data));
 }
 
 void BytesTrieTest::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 BytesTrieTest::checkData(const StringAndValue data[], int32_t dataLength, UStringTrieBuildOption buildOption) {
@@ skipping 274 matching lines @@
     }
     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");
     }
 }