Update ICU to 54.1 step 1

source/test/intltest/usettest.cpp

 /*
 ********************************************************************************
-*   Copyright (C) 1999-2013 International Business Machines Corporation and
+*   Copyright (C) 1999-2014 International Business Machines Corporation and
 *   others. All Rights Reserved.
 ********************************************************************************
 *   Date        Name        Description
 *   10/20/99    alan        Creation.
 *   03/22/2000  Madhu       Added additional tests
 ********************************************************************************
 */
 
 #include <stdio.h>
 
 #include <string.h>
 #include "unicode/utypes.h"
 #include "usettest.h"
 #include "unicode/ucnv.h"
 #include "unicode/uniset.h"
 #include "unicode/uchar.h"
 #include "unicode/usetiter.h"
 #include "unicode/ustring.h"
 #include "unicode/parsepos.h"
 #include "unicode/symtable.h"
 #include "unicode/uversion.h"
 #include "hash.h"
 
-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
-
 #define TEST_ASSERT_SUCCESS(status) {if (U_FAILURE(status)) { \
     dataerrln("fail in file \"%s\", line %d: \"%s\"", __FILE__, __LINE__, \
     u_errorName(status));}}
 
 #define TEST_ASSERT(expr) {if (!(expr)) { \
     dataerrln("fail in file \"%s\", line %d", __FILE__, __LINE__); }}
 
 UnicodeString operator+(const UnicodeString& left, const UnicodeSet& set) {
     UnicodeString pat;
     set.toPattern(pat);
@@ skipping 1008 matching lines @@
         "\\u0888\\uFDD3\\uFFFE\\U00050005",
 
         // Script_Extensions, new in Unicode 6.0
         "[:scx=Arab:]",
         "\\u061E\\u061F\\u0620\\u0621\\u063F\\u0640\\u0650\\u065E\\uFDF1\\uFDF2\\uFDF3",
         "\\u061D\\uFDEF\\uFDFE",
 
         // U+FDF2 has Script=Arabic and also Arab in its Script_Extensions,
         // so scx-sc is missing U+FDF2.
         "[[:Script_Extensions=Arabic:]-[:Arab:]]",
-        "\\u0640\\u064B\\u0650\\u0655\\uFDFD",
+        "\\u0640\\u064B\\u0650\\u0655",
         "\\uFDF2"
     };
 
     static const int32_t DATA_LEN = sizeof(DATA)/sizeof(DATA[0]);
 
     for (int32_t i=0; i<DATA_LEN; i+=3) {  
         expectContainment(UnicodeString(DATA[i], -1, US_INV), CharsToUnicodeString(DATA[i+1]),
                           CharsToUnicodeString(DATA[i+2]));
     }
 }
@@ skipping 1247 matching lines @@
             set(normalSet), stringsLength(0), hasSurrogates(FALSE) {
         int32_t size=set.size();
         if(size>0 && set.charAt(size-1)<0) {
             // If a set's last element is not a code point, then it must contain strings.
             // Iterate over the set, skip all code point ranges, and cache the strings.
             // Convert them to UTF-8 for spanUTF8().
             UnicodeSetIterator iter(set);
             const UnicodeString *s;
             char *s8=utf8;
             int32_t length8, utf8Count=0;
-            while(iter.nextRange() && stringsLength<LENGTHOF(strings)) {
+            while(iter.nextRange() && stringsLength<UPRV_LENGTHOF(strings)) {
                 if(iter.isString()) {
                     // Store the pointer to the set's string element
                     // which we happen to know is a stable pointer.
                     strings[stringsLength]=s=&iter.getString();
                     utf8Count+=
                         utf8Lengths[stringsLength]=length8=
                         appendUTF8(s->getBuffer(), s->length(),
                                    s8, (int32_t)(sizeof(utf8)-utf8Count));
                     if(length8==0) {
                         hasSurrogates=TRUE;  // Contains unpaired surrogates.
@@ skipping 733 matching lines @@
             // Odd-numbered sets are complemented.
             if((whichSpans&SPAN_COMPLEMENT)==0) {
                 continue;
             }
         }
         for(type=0;; ++type) {
             limitsCount=getSpans(*sets[i], (UBool)(i&1),
                                  s, length, isUTF16,
                                  whichSpans,
                                  type, typeName,
-                                 limits, LENGTHOF(limits), expectCount);
+                                 limits, UPRV_LENGTHOF(limits), expectCount);
             if(typeName[0]==0) {
                 break; // All types tried.
             }
             if(limitsCount<0) {
                 continue; // Span option filtered out.
             }
             if(expectCount<0) {
                 expectCount=limitsCount;
-                if(limitsCount>LENGTHOF(limits)) {
+                if(limitsCount>UPRV_LENGTHOF(limits)) {
                     errln("FAIL: %s[0x%lx].%s.%s span count=%ld > %ld capacity - too many spans",
-                          testName, (long)index, setNames[i], typeName, (long)limitsCount, (long)LENGTHOF(limits));
+                          testName, (long)index, setNames[i], typeName, (long)limitsCount, (long)UPRV_LENGTHOF(limits));
                     return;
                 }
                 memcpy(expectLimits, limits, limitsCount*4);
             } else if(limitsCount!=expectCount) {
                 errln("FAIL: %s[0x%lx].%s.%s span count=%ld != %ld",
                       testName, (long)index, setNames[i], typeName, (long)limitsCount, (long)expectCount);
             } else {
                 for(j=0; j<limitsCount; ++j) {
                     if(limits[j]!=expectLimits[j]) {
                         errln("FAIL: %s[0x%lx].%s.%s span count=%ld limits[%d]=%ld != %ld",
@@ skipping 172 matching lines @@
                sets[0]->getSet().contains(0xd800, 0xdfff) :
                sets[0]->getSet().containsNone(0xd800, 0xdfff)) ||
              sets[0]->hasStringsWithSurrogates());
 
     UChar s[1000];
     int32_t length=0;
     uint32_t localWhichSpans;
 
     UChar32 c, first;
     for(first=c=0;; c=nextCodePoint(c)) {
-        if(c>0x10ffff || length>(LENGTHOF(s)-U16_MAX_LENGTH)) {
+        if(c>0x10ffff || length>(UPRV_LENGTHOF(s)-U16_MAX_LENGTH)) {
             localWhichSpans=whichSpans;
             if(stringContainsUnpairedSurrogate(s, length) && inconsistentSurrogates) {
                 localWhichSpans&=~SPAN_UTF8;
             }
             testSpanBothUTFs(sets, s, length, localWhichSpans, testName, first);
             if(c>0x10ffff) {
                 break;
             }
             length=0;
             first=c;
@@ skipping 15 matching lines @@
         0xd900, 0xdc05,                         // unassigned supplementary
         0xd840, 0xdfff, 0xd860, 0xdffe,         // Han supplementary
         0xd7a4, 0xdc05, 0xd900, 0x2028,         // unassigned, surrogates in wrong order, LS
         0                                       // NUL
     };
 
     if((whichSpans&SPAN_UTF16)==0) {
         return;
     }
     testSpan(sets, s, -1, TRUE, (whichSpans&~SPAN_UTF8), testName, 0);
-    testSpan(sets, s, LENGTHOF(s)-1, TRUE, (whichSpans&~SPAN_UTF8), testName, 1);
+    testSpan(sets, s, UPRV_LENGTHOF(s)-1, TRUE, (whichSpans&~SPAN_UTF8), testName, 1);
 }
 
 void UnicodeSetTest::testSpanUTF8String(const UnicodeSetWithStrings *sets[4], uint32_t whichSpans, const char *testName) {
     static const char s[]={
         "abc"                                   // Latin
 
         /* trail byte in lead position */
         "\x80"
 
         " "                                     // space
@@ skipping 76 matching lines @@
         /* trail byte in lead position */
         "\x80"
 
         "\xED\x9E\xA4\xE2\x80\xA8"              // unassigned, LS, NUL-terminated
     };
 
     if((whichSpans&SPAN_UTF8)==0) {
         return;
     }
     testSpan(sets, s, -1, FALSE, (whichSpans&~SPAN_UTF16), testName, 0);
-    testSpan(sets, s, LENGTHOF(s)-1, FALSE, (whichSpans&~SPAN_UTF16), testName, 1);
+    testSpan(sets, s, UPRV_LENGTHOF(s)-1, FALSE, (whichSpans&~SPAN_UTF16), testName, 1);
 }
 
 // Take a set of span options and multiply them so that
 // each portion only has one of the options a, b and c.
 // If b==0, then the set of options is just modified with mask and a.
 // If b!=0 and c==0, then the set of options is just modified with mask, a and b.
 static int32_t
 addAlternative(uint32_t whichSpans[], int32_t whichSpansCount,
                uint32_t mask, uint32_t a, uint32_t b, uint32_t c) {
     uint32_t s;
@@ skipping 181 matching lines @@
     uint32_t whichSpans[96]={ SPAN_ALL };
     int32_t whichSpansCount=1;
 
     UnicodeSet *sets[SET_COUNT]={ NULL };
     const UnicodeSetWithStrings *sets_with_str[SET_COUNT]={ NULL };
 
     char testName[1024];
     char *testNameLimit=testName;
 
     int32_t i, j;
-    for(i=0; i<LENGTHOF(testdata); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(testdata); ++i) {
         const char *s=testdata[i];
         if(s[0]=='[') {
             // Create new test sets from this pattern.
             for(j=0; j<SET_COUNT; ++j) {
                 delete sets_with_str[j];
                 delete sets[j];
             }
             UErrorCode errorCode=U_ZERO_ERROR;
             sets[SLOW]=new UnicodeSet(UnicodeString(s, -1, US_INV).unescape(), errorCode);
             if(U_FAILURE(errorCode)) {
@@ skipping 178 matching lines @@
     string16=UNICODE_STRING_SIMPLE("abbcdabcdabd");
     s16=string16.getBuffer();
     length16=string16.length();
     if( set.spanBack(s16, 12, USET_SPAN_CONTAINED)!=0 ||
         set.spanBack(s16, 12, USET_SPAN_SIMPLE)!=6 ||
         set.spanBack(s16, 5, USET_SPAN_SIMPLE)!=0
     ) {
         errln("FAIL: UnicodeSet(%s).spanBack(while longest match) returns the wrong value", pattern);
     }
 }