Update ICU to 54.1 step 1

source/test/intltest/plurults.cpp

 /*
 *******************************************************************************
-* Copyright (C) 2007-2013, International Business Machines Corporation and
+* Copyright (C) 2007-2014, International Business Machines Corporation and
 * others. All Rights Reserved.
 ********************************************************************************
 
 * File PLURRULTS.cpp
 *
 ********************************************************************************
 */
 
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_FORMATTING
 
 #include <stdlib.h>
 #include <stdarg.h>
 #include <string.h>
 
 #include "unicode/localpointer.h"
 #include "unicode/plurrule.h"
 #include "unicode/stringpiece.h"
 
 #include "cmemory.h"
 #include "digitlst.h"
 #include "plurrule_impl.h"
 #include "plurults.h"
 #include "uhash.h"
 
-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof(array[0]))
-
 void setupResult(const int32_t testSource[], char result[], int32_t* max);
 UBool checkEqual(const PluralRules &test, char *result, int32_t max);
 UBool testEquality(const PluralRules &test);
 
 // This is an API test, not a unit test.  It doesn't test very many cases, and doesn't
 // try to test the full functionality.  It just calls each function in the class and
 // verifies that it works on a basic level.
 
 void PluralRulesTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
 {
@@ skipping 172 matching lines @@
     UnicodeString decimalRule= UNICODE_STRING_SIMPLE("a: n not in 0..100;");
     UnicodeString KEYWORD_A = UNICODE_STRING_SIMPLE("a");
     status = U_ZERO_ERROR;
     newRules.adoptInstead(test->createRules(decimalRule, status));
     if (U_FAILURE(status)) {
         dataerrln("ERROR: Could not create PluralRules for testing fractions - exitting");
         return;
     }
     double fData[] =     {-101, -100, -1,     -0.0,  0,     0.1,  1,     1.999,  2.0,   100,   100.001 };
     UBool isKeywordA[] = {TRUE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE,   FALSE, FALSE, TRUE };
-    for (int32_t i=0; i<LENGTHOF(fData); i++) {
+    for (int32_t i=0; i<UPRV_LENGTHOF(fData); i++) {
         if ((newRules->select(fData[i])== KEYWORD_A) != isKeywordA[i]) {
              errln("File %s, Line %d, ERROR: plural rules for decimal fractions test failed!\n"
-                   "  number = %g, expected %s", __FILE__, __LINE__, fData[i], isKeywordA?"TRUE":"FALSE");
+                   "  number = %g, expected %s", __FILE__, __LINE__, fData[i], isKeywordA[i]?"TRUE":"FALSE");
         }
     }
 
     // ======= Test Equality
     logln("Testing Equality of PluralRules");
 
     if ( !testEquality(*test) ) {
          errln("ERROR:  complex plural rules failed! - exitting");
          return;
      }
@@ skipping 153 matching lines @@
     if (U_FAILURE(status)) {
       break;
     }
     StringEnumeration *keywords = rules->getKeywords(status);
     if (U_FAILURE(status)) {
       delete rules;
       break;
     }
     const UnicodeString* keyword;
     while (NULL != (keyword = keywords->snext(status))) {
-      int32_t count = rules->getSamples(*keyword, values, LENGTHOF(values), status);
+      int32_t count = rules->getSamples(*keyword, values, UPRV_LENGTHOF(values), status);
       if (U_FAILURE(status)) {
         errln(UNICODE_STRING_SIMPLE("getSamples() failed for locale ") +
               locales[i].getName() +
               UNICODE_STRING_SIMPLE(", keyword ") + *keyword);
         continue;
       }
       if (count == 0) {
         // TODO: Lots of these. 
         //   errln(UNICODE_STRING_SIMPLE("no samples for keyword ") + *keyword + UNICODE_STRING_SIMPLE(" in locale ") + locales[i].getName() );
       }
-      if (count > LENGTHOF(values)) {
+      if (count > UPRV_LENGTHOF(values)) {
         errln(UNICODE_STRING_SIMPLE("getSamples()=") + count +
               UNICODE_STRING_SIMPLE(", too many values, for locale ") +
               locales[i].getName() +
               UNICODE_STRING_SIMPLE(", keyword ") + *keyword);
-        count = LENGTHOF(values);
+        count = UPRV_LENGTHOF(values);
       }
       for (int32_t j = 0; j < count; ++j) {
         if (values[j] == UPLRULES_NO_UNIQUE_VALUE) {
           errln("got 'no unique value' among values");
         } else {
           UnicodeString resultKeyword = rules->select(values[j]);
           // if (strcmp(locales[i].getName(), "uk") == 0) {    // Debug only.
           //     std::cout << "  uk " << US(resultKeyword).cstr() << " " << values[j] << std::endl;
           // }
           if (*keyword != resultKeyword) {
@@ skipping 504 matching lines @@
             "a: n is 13, 15,   b: n is 4",
             "a: n is 1, 3, 4.. ",
             "a: n within 5..4",
             "A: n is 13",          // Uppercase keywords not allowed.
             "a: n ! = 3",          // spaces in != operator
             "a: n = not 3",        // '=' not exact equivalent of 'is'
             "a: n ! in 3..4"       // '!' not exact equivalent of 'not'
             "a: n % 37 ! in 3..4"
 
             };
-    for (int i=0; i<LENGTHOF(testCases); i++) {
+    for (int i=0; i<UPRV_LENGTHOF(testCases); i++) {
         const char *rules = testCases[i];
         UErrorCode status = U_ZERO_ERROR;
         PluralRules *pr = PluralRules::createRules(UnicodeString(rules), status);
         if (U_SUCCESS(status)) {
             errln("file %s, line %d, expected failure with \"%s\".", __FILE__, __LINE__, rules);
         }
         if (pr != NULL) {
             errln("file %s, line %d, expected NULL. Rules: \"%s\"", __FILE__, __LINE__, rules);
         }
     }
@@ skipping 21 matching lines @@
         {.1234, 4, 1234},
         {.01234, 5, 1234},
         {.001234, 6, 1234},
         {.0001234, 7, 1234},
         {100.1234, 4, 1234},
         {100.01234, 5, 1234},
         {100.001234, 6, 1234},
         {100.0001234, 7, 1234}
     };
 
-    for (int i=0; i<LENGTHOF(testCases); ++i) {
+    for (int i=0; i<UPRV_LENGTHOF(testCases); ++i) {
         DoubleTestCase &tc = testCases[i];
         int32_t numFractionDigits = FixedDecimal::decimals(tc.n);
         if (numFractionDigits != tc.fractionDigitCount) {
             errln("file %s, line %d: decimals(%g) expected %d, actual %d",
                    __FILE__, __LINE__, tc.n, tc.fractionDigitCount, numFractionDigits);
             continue;
         }
         int64_t actualFractionDigits = FixedDecimal::getFractionalDigits(tc.n, numFractionDigits);
         if (actualFractionDigits != tc.fractionDigits) {
             errln("file %s, line %d: getFractionDigits(%g, %d): expected %ld, got %ld",
                   __FILE__, __LINE__, tc.n, numFractionDigits, tc.fractionDigits, actualFractionDigits);
         }
     }
 }
 
 
 
 #endif /* #if !UCONFIG_NO_FORMATTING */