Update ICU to 54.1 step 1

source/test/intltest/ucdtest.cpp

 /********************************************************************
  * COPYRIGHT: 
- * Copyright (c) 1997-2013, International Business Machines Corporation and
+ * Copyright (c) 1997-2014, International Business Machines Corporation and
  * others. All Rights Reserved.
  ********************************************************************/
 
 #include "unicode/ustring.h"
 #include "unicode/uchar.h"
 #include "unicode/uniset.h"
 #include "unicode/putil.h"
 #include "unicode/uscript.h"
 #include "cstring.h"
 #include "hash.h"
 #include "patternprops.h"
 #include "normalizer2impl.h"
 #include "uparse.h"
 #include "ucdtest.h"
 
-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof(array[0]))
-
 static const char *ignorePropNames[]={
     "FC_NFKC",
     "NFD_QC",
     "NFC_QC",
     "NFKD_QC",
     "NFKC_QC",
     "Expands_On_NFD",
     "Expands_On_NFC",
     "Expands_On_NFKD",
     "Expands_On_NFKC",
     "NFKC_CF"
 };
 
 UnicodeTest::UnicodeTest()
 {
     UErrorCode errorCode=U_ZERO_ERROR;
     unknownPropertyNames=new U_NAMESPACE_QUALIFIER Hashtable(errorCode);
     if(U_FAILURE(errorCode)) {
         delete unknownPropertyNames;
         unknownPropertyNames=NULL;
     }
     // Ignore some property names altogether.
-    for(int32_t i=0; i<LENGTHOF(ignorePropNames); ++i) {
+    for(int32_t i=0; i<UPRV_LENGTHOF(ignorePropNames); ++i) {
         unknownPropertyNames->puti(UnicodeString(ignorePropNames[i], -1, US_INV), 1, errorCode);
     }
 }
 
 UnicodeTest::~UnicodeTest()
 {
     delete unknownPropertyNames;
 }
 
 void UnicodeTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
@@ skipping 89 matching lines @@
     UCHAR_CASED,
     UCHAR_CASE_IGNORABLE,
     UCHAR_CHANGES_WHEN_LOWERCASED,
     UCHAR_CHANGES_WHEN_UPPERCASED,
     UCHAR_CHANGES_WHEN_TITLECASED,
     UCHAR_CHANGES_WHEN_CASEFOLDED,
     UCHAR_CHANGES_WHEN_CASEMAPPED,
     UCHAR_CHANGES_WHEN_NFKC_CASEFOLDED
 };
 
-static int32_t numErrors[LENGTHOF(derivedPropsIndex)]={ 0 };
+static int32_t numErrors[UPRV_LENGTHOF(derivedPropsIndex)]={ 0 };
 
 enum { MAX_ERRORS=50 };
 
 U_CFUNC void U_CALLCONV
 derivedPropsLineFn(void *context,
                    char *fields[][2], int32_t /* fieldCount */,
                    UErrorCode *pErrorCode)
 {
     UnicodeTest *me=(UnicodeTest *)context;
     uint32_t start, end;
     int32_t i;
 
     u_parseCodePointRange(fields[0][0], &start, &end, pErrorCode);
     if(U_FAILURE(*pErrorCode)) {
         me->errln("UnicodeTest: syntax error in DerivedCoreProperties.txt or DerivedNormalizationProps.txt field 0 at %s\n", fields[0][0]);
         return;
     }
 
     /* parse derived binary property name, ignore unknown names */
-    i=getTokenIndex(derivedPropsNames, LENGTHOF(derivedPropsNames), fields[1][0]);
+    i=getTokenIndex(derivedPropsNames, UPRV_LENGTHOF(derivedPropsNames), fields[1][0]);
     if(i<0) {
         UnicodeString propName(fields[1][0], (int32_t)(fields[1][1]-fields[1][0]));
         propName.trim();
         if(me->unknownPropertyNames->find(propName)==NULL) {
             UErrorCode errorCode=U_ZERO_ERROR;
             me->unknownPropertyNames->puti(propName, 1, errorCode);
             me->errln("UnicodeTest warning: unknown property name '%s' in DerivedCoreProperties.txt or DerivedNormalizationProps.txt\n", fields[1][0]);
         }
         return;
     }
 
     me->derivedProps[i].add(start, end);
 }
 
 void UnicodeTest::TestAdditionalProperties() {
 #if !UCONFIG_NO_NORMALIZATION
     // test DerivedCoreProperties.txt and DerivedNormalizationProps.txt
-    if(LENGTHOF(derivedProps)<LENGTHOF(derivedPropsNames)) {
+    if(UPRV_LENGTHOF(derivedProps)<UPRV_LENGTHOF(derivedPropsNames)) {
         errln("error: UnicodeTest::derivedProps[] too short, need at least %d UnicodeSets\n",
-              LENGTHOF(derivedPropsNames));
+              UPRV_LENGTHOF(derivedPropsNames));
         return;
     }
-    if(LENGTHOF(derivedPropsIndex)!=LENGTHOF(derivedPropsNames)) {
-        errln("error in ucdtest.cpp: LENGTHOF(derivedPropsIndex)!=LENGTHOF(derivedPropsNames)\n");
+    if(UPRV_LENGTHOF(derivedPropsIndex)!=UPRV_LENGTHOF(derivedPropsNames)) {
+        errln("error in ucdtest.cpp: UPRV_LENGTHOF(derivedPropsIndex)!=UPRV_LENGTHOF(derivedPropsNames)\n");
         return;
     }
 
-    char newPath[256];
-    char backupPath[256];
+    char path[500];
+    if(getUnidataPath(path) == NULL) {
+        errln("unable to find path to source/data/unidata/");
+        return;
+    }
+    char *basename=strchr(path, 0);
+    strcpy(basename, "DerivedCoreProperties.txt");
+
     char *fields[2][2];
     UErrorCode errorCode=U_ZERO_ERROR;
-
-    /* Look inside ICU_DATA first */
-    strcpy(newPath, pathToDataDirectory());
-    strcat(newPath, "unidata" U_FILE_SEP_STRING "DerivedCoreProperties.txt");
-
-    // As a fallback, try to guess where the source data was located
-    // at the time ICU was built, and look there.
-#   ifdef U_TOPSRCDIR
-        strcpy(backupPath, U_TOPSRCDIR  U_FILE_SEP_STRING "data");
-#   else
-        strcpy(backupPath, loadTestData(errorCode));
-        strcat(backupPath, U_FILE_SEP_STRING ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING ".." U_FILE_SEP_STRING "data");
-#   endif
-    strcat(backupPath, U_FILE_SEP_STRING);
-    strcat(backupPath, "unidata" U_FILE_SEP_STRING "DerivedCoreProperties.txt");
-
-    char *path=newPath;
-    u_parseDelimitedFile(newPath, ';', fields, 2, derivedPropsLineFn, this, &errorCode);
-
-    if(errorCode==U_FILE_ACCESS_ERROR) {
-        errorCode=U_ZERO_ERROR;
-        path=backupPath;
-        u_parseDelimitedFile(backupPath, ';', fields, 2, derivedPropsLineFn, this, &errorCode);
-    }
+    u_parseDelimitedFile(path, ';', fields, 2, derivedPropsLineFn, this, &errorCode);
     if(U_FAILURE(errorCode)) {
         errln("error parsing DerivedCoreProperties.txt: %s\n", u_errorName(errorCode));
         return;
     }
-    char *basename=path+strlen(path)-strlen("DerivedCoreProperties.txt");
+
     strcpy(basename, "DerivedNormalizationProps.txt");
     u_parseDelimitedFile(path, ';', fields, 2, derivedPropsLineFn, this, &errorCode);
     if(U_FAILURE(errorCode)) {
         errln("error parsing DerivedNormalizationProps.txt: %s\n", u_errorName(errorCode));
         return;
     }
 
     // now we have all derived core properties in the UnicodeSets
     // run them all through the API
     int32_t rangeCount, range;
     uint32_t i;
     UChar32 start, end;
 
     // test all TRUE properties
-    for(i=0; i<LENGTHOF(derivedPropsNames); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(derivedPropsNames); ++i) {
         rangeCount=derivedProps[i].getRangeCount();
         for(range=0; range<rangeCount && numErrors[i]<MAX_ERRORS; ++range) {
             start=derivedProps[i].getRangeStart(range);
             end=derivedProps[i].getRangeEnd(range);
             for(; start<=end; ++start) {
                 if(!u_hasBinaryProperty(start, derivedPropsIndex[i])) {
                     dataerrln("UnicodeTest error: u_hasBinaryProperty(U+%04lx, %s)==FALSE is wrong", start, derivedPropsNames[i]);
                     if(++numErrors[i]>=MAX_ERRORS) {
                       dataerrln("Too many errors, moving to the next test");
                       break;
                     }
                 }
             }
         }
     }
 
     // invert all properties
-    for(i=0; i<LENGTHOF(derivedPropsNames); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(derivedPropsNames); ++i) {
         derivedProps[i].complement();
     }
 
     // test all FALSE properties
-    for(i=0; i<LENGTHOF(derivedPropsNames); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(derivedPropsNames); ++i) {
         rangeCount=derivedProps[i].getRangeCount();
         for(range=0; range<rangeCount && numErrors[i]<MAX_ERRORS; ++range) {
             start=derivedProps[i].getRangeStart(range);
             end=derivedProps[i].getRangeEnd(range);
             for(; start<=end; ++start) {
                 if(u_hasBinaryProperty(start, derivedPropsIndex[i])) {
                     errln("UnicodeTest error: u_hasBinaryProperty(U+%04lx, %s)==TRUE is wrong\n", start, derivedPropsNames[i]);
                     if(++numErrors[i]>=MAX_ERRORS) {
                       errln("Too many errors, moving to the next test");
                       break;
@@ skipping 13 matching lines @@
     UErrorCode errorCode=U_ZERO_ERROR;
     UnicodeSet alpha(UNICODE_STRING_SIMPLE("[:Alphabetic:]"), errorCode);
     if(U_FAILURE(errorCode)) {
         dataerrln("UnicodeSet([:Alphabetic:]) failed - %s", u_errorName(errorCode));
         return;
     }
 
     static const char *const falseValues[]={ "N", "No", "F", "False" };
     static const char *const trueValues[]={ "Y", "Yes", "T", "True" };
     int32_t i;
-    for(i=0; i<LENGTHOF(falseValues); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(falseValues); ++i) {
         UnicodeString pattern=UNICODE_STRING_SIMPLE("[:Alphabetic=:]");
         pattern.insert(pattern.length()-2, UnicodeString(falseValues[i], -1, US_INV));
         errorCode=U_ZERO_ERROR;
         UnicodeSet set(pattern, errorCode);
         if(U_FAILURE(errorCode)) {
             errln("UnicodeSet([:Alphabetic=%s:]) failed - %s\n", falseValues[i], u_errorName(errorCode));
             continue;
         }
         set.complement();
         if(set!=alpha) {
             errln("UnicodeSet([:Alphabetic=%s:]).complement()!=UnicodeSet([:Alphabetic:])\n", falseValues[i]);
         }
     }
-    for(i=0; i<LENGTHOF(trueValues); ++i) {
+    for(i=0; i<UPRV_LENGTHOF(trueValues); ++i) {
         UnicodeString pattern=UNICODE_STRING_SIMPLE("[:Alphabetic=:]");
         pattern.insert(pattern.length()-2, UnicodeString(trueValues[i], -1, US_INV));
         errorCode=U_ZERO_ERROR;
         UnicodeSet set(pattern, errorCode);
         if(U_FAILURE(errorCode)) {
             errln("UnicodeSet([:Alphabetic=%s:]) failed - %s\n", trueValues[i], u_errorName(errorCode));
             continue;
         }
         if(set!=alpha) {
             errln("UnicodeSet([:Alphabetic=%s:])!=UnicodeSet([:Alphabetic:])\n", trueValues[i]);
@@ skipping 189 matching lines @@
     assertTrue("bpt!=None is a subset of Bidi_M", mirrored.containsAll(bpt));
     assertTrue("bpt!=None is a subset of bc=ON", other_neutral.containsAll(bpt));
     // The following are true at least initially in Unicode 6.3.
     UnicodeSet bpt_open("[:bpt=o:]", errorCode);
     UnicodeSet bpt_close("[:bpt=c:]", errorCode);
     UnicodeSet ps("[:Ps:]", errorCode);
     UnicodeSet pe("[:Pe:]", errorCode);
     assertTrue("bpt=Open is a subset of Ps", ps.containsAll(bpt_open));
     assertTrue("bpt=Close is a subset of Pe", pe.containsAll(bpt_close));
 }