Update ICU to 54.1 step 1

source/test/intltest/regiontst.cpp

 /***********************************************************************
  * COPYRIGHT: 
- * Copyright (c) 2013, International Business Machines Corporation
+ * Copyright (c) 2013-2014, International Business Machines Corporation
  * and others. All Rights Reserved.
  ***********************************************************************/
  
 /***********************************************************************
  * This testcase ported from ICU4J ( RegionTest.java ) to ICU4C        *
  * Try to keep them in sync if at all possible...!                     *
  ***********************************************************************/
 
 #include "unicode/utypes.h"
 #include "cstring.h"
 
 #if !UCONFIG_NO_FORMATTING
 
 #include "unicode/region.h"
 #include "regiontst.h"
 
 typedef struct KnownRegion {
   const char *code;
   int32_t numeric;
   const char *parent;
   URegionType type;
   const char *containingContinent;
 } KnownRegion;
 
-#define LENGTHOF(array) (int32_t)(sizeof(array) / sizeof((array)[0]))
-
 static KnownRegion knownRegions[] = {
     // Code, Num, Parent, Type,             Containing Continent
     { "TP" , 626, "035", URGN_TERRITORY, "142" },
     { "001", 1,  NULL ,  URGN_WORLD,        NULL },
     { "002", 2,  "001",  URGN_CONTINENT,    NULL },
     { "003", 3,  NULL,   URGN_GROUPING,     NULL },
     { "005", 5,  "019",  URGN_SUBCONTINENT, "019" },
     { "009", 9,  "001",  URGN_CONTINENT,    NULL},
     { "011", 11, "002",  URGN_SUBCONTINENT, "002" },
     { "013", 13, "019",  URGN_SUBCONTINENT, "019" },
@@ skipping 317 matching lines @@
    TESTCASE_AUTO(TestGetPreferredValues);
    TESTCASE_AUTO(TestContains);
    TESTCASE_AUTO(TestAvailableTerritories);
    TESTCASE_AUTO(TestNoContainedRegions);
    TESTCASE_AUTO_END;
 }
 
 
 void RegionTest::TestKnownRegions() {
 
-    for (int32_t i = 0 ; i < LENGTHOF(knownRegions) ; i++ ) {
+    for (int32_t i = 0 ; i < UPRV_LENGTHOF(knownRegions) ; i++ ) {
         KnownRegion rd = knownRegions[i];
         UErrorCode status = U_ZERO_ERROR;
         const Region *r = Region::getInstance(rd.code,status);
         if ( r ) {
             int32_t n = r->getNumericCode();
             int32_t e = rd.numeric;
             if ( n != e ) {
                 errln("Numeric code mismatch for region %s.  Expected:%d Got:%d",r->getRegionCode(),e,n);
             }
 
@@ skipping 30 matching lines @@
         { "278", "DE", URGN_TERRITORY }, // Numeric code for East Germany (Deprecated)
         { "SU", "SU", URGN_DEPRECATED }, // Alias to a deprecated region with multiple preferred values
         { "AN", "AN", URGN_DEPRECATED }, // Deprecated region with multiple preferred values
         { "SVK", "SK", URGN_TERRITORY }  // 3-letter code - Slovakia
     };
 
 
     UErrorCode status = U_ZERO_ERROR;
     const Region *r = Region::getInstance((const char *)NULL,status);
     if ( status != U_ILLEGAL_ARGUMENT_ERROR ) {
-        errln("Calling Region::getInstance(NULL) should have triggered an U_ILLEGAL_ARGUMENT_ERROR, but didn't.");
+        errcheckln(status, "Calling Region::getInstance(NULL) should have triggered an U_ILLEGAL_ARGUMENT_ERROR, but didn't. - %s", u_errorName(status));
     }
 
     status = U_ZERO_ERROR;
     r = Region::getInstance("BOGUS",status);
     if ( status != U_ILLEGAL_ARGUMENT_ERROR ) {
-        errln("Calling Region::getInstance(\"BOGUS\") should have triggered an U_ILLEGAL_ARGUMENT_ERROR, but didn't.");
+        errcheckln(status, "Calling Region::getInstance(\"BOGUS\") should have triggered an U_ILLEGAL_ARGUMENT_ERROR, but didn't. - %s", u_errorName(status));
     }
 
 
-    for (int32_t i = 0 ; i < LENGTHOF(testData) ; i++ ) {
+    for (int32_t i = 0 ; i < UPRV_LENGTHOF(testData) ; i++ ) {
         TestData data = testData[i];
         status = U_ZERO_ERROR;
         r = Region::getInstance(data.inputID,status);
         const char *id;
         URegionType type;
         if ( r ) {
             id = r->getRegionCode();
             type = r->getType();
         } else {
             id = "NULL";
@@ skipping 20 matching lines @@
         { 276, "DE",  URGN_TERRITORY }, // Numeric code for Germany
         { 278, "DE",  URGN_TERRITORY }, // Numeric code for East Germany (Deprecated)
         { 419, "419", URGN_GROUPING },  // Latin America
         { 736, "SD",  URGN_TERRITORY }, // Sudan (pre-2011) - changed numeric code after South Sudan split off
         { 729, "SD",  URGN_TERRITORY }, // Sudan (post-2011) - changed numeric code after South Sudan split off
     };
 
     UErrorCode status = U_ZERO_ERROR;
     Region::getInstance(-123,status);
     if ( status != U_ILLEGAL_ARGUMENT_ERROR ) {
-        errln("Calling Region::getInstance(-123) should have triggered an U_ILLEGAL_ARGUMENT_ERROR, but didn't.");
+        errcheckln(status, "Calling Region::getInstance(-123) should have triggered an U_ILLEGAL_ARGUMENT_ERROR, but didn't. - %s", u_errorName(status));
     }
 
-    for (int32_t i = 0 ; i < LENGTHOF(testData) ; i++ ) {
+    for (int32_t i = 0 ; i < UPRV_LENGTHOF(testData) ; i++ ) {
         TestData data = testData[i];
         status = U_ZERO_ERROR;
         const Region *r = Region::getInstance(data.inputID,status);
         const char *id;
         URegionType type;
         if ( r ) {
             id = r->getRegionCode();
             type = r->getType();
         } else {
             id = "NULL";
             type = URGN_UNKNOWN;
         }
         if ( uprv_strcmp(data.expectedID,id)) {
             dataerrln("Unexpected region ID for Region.getInstance(%d)); Expected: %s Got: %s",data.inputID,data.expectedID,id);
         }
         if ( data.expectedType != type) {
             dataerrln("Unexpected region type for Region.getInstance(%d)); Expected: %d Got: %d",data.inputID,data.expectedType,type);
         }
     }
 }
 
 void RegionTest::TestGetContainedRegions() {
-    for (int32_t i = 0 ; i < LENGTHOF(knownRegions) ; i++ ) {
+    for (int32_t i = 0 ; i < UPRV_LENGTHOF(knownRegions) ; i++ ) {
         KnownRegion rd = knownRegions[i];
         UErrorCode status = U_ZERO_ERROR;
 
         const Region *r = Region::getInstance(rd.code,status);
         if (r) {
             if (r->getType() == URGN_GROUPING) {
                 continue;
             }
             StringEnumeration *containedRegions = r->getContainedRegions();
             for ( int32_t i = 0 ; i < containedRegions->count(status); i++ ) {
                 const char *crID = containedRegions->next(NULL,status);
                 const Region *cr = Region::getInstance(crID,status);
                 const Region *containingRegion = cr ? cr->getContainingRegion() : NULL;
                 if ( !containingRegion || *containingRegion != *r ) {
                     errln("Region: %s contains region %s. Expected containing region of this region to be the original region, but got %s",
                         r->getRegionCode(),cr->getRegionCode(),containingRegion?containingRegion->getRegionCode():"NULL"); 
                 }
             }
             delete containedRegions;
         } else {
             dataerrln("Known region %s was not recognized.",rd.code);
         }
     }
 }
 
 void RegionTest::TestGetContainedRegionsWithType() {
-    for (int32_t i = 0 ; i < LENGTHOF(knownRegions) ; i++ ) {
+    for (int32_t i = 0 ; i < UPRV_LENGTHOF(knownRegions) ; i++ ) {
         KnownRegion rd = knownRegions[i];
         UErrorCode status = U_ZERO_ERROR;
 
         const Region *r = Region::getInstance(rd.code,status);
         if (r) {
             if (r->getType() != URGN_CONTINENT) {
                 continue;
             }
             StringEnumeration *containedRegions = r->getContainedRegions(URGN_TERRITORY);
             for ( int32_t j = 0 ; j < containedRegions->count(status); j++ ) {
                 const char *crID = containedRegions->next(NULL,status);
                 const Region *cr = Region::getInstance(crID,status);
                 const Region *containingRegion = cr ? cr->getContainingRegion(URGN_CONTINENT) : NULL;
                 if ( !containingRegion || *containingRegion != *r ) {
                     errln("Continent: %s contains territory %s. Expected containing continent of this region to be the original region, but got %s",
                         r->getRegionCode(),cr->getRegionCode(),containingRegion?containingRegion->getRegionCode():"NULL"); 
                 }
             }
             delete containedRegions;
         } else {
             dataerrln("Known region %s was not recognized.",rd.code);
         }
     }
 }
 
 void RegionTest::TestGetContainingRegion() {        
-    for (int32_t i = 0 ; i < LENGTHOF(knownRegions) ; i++ ) {
+    for (int32_t i = 0 ; i < UPRV_LENGTHOF(knownRegions) ; i++ ) {
         KnownRegion rd = knownRegions[i];
         UErrorCode status = U_ZERO_ERROR;
         const Region *r = Region::getInstance(rd.code,status);
         if (r) {
             const Region *c = r->getContainingRegion();
             if (rd.parent == NULL) {                   
                 if ( c ) {
                     errln("Containing region for %s should have been NULL.  Got: %s",r->getRegionCode(),c->getRegionCode());
                 }
             } else {
                 const Region *p = Region::getInstance(rd.parent,status);                   
                 if ( !c || *p != *c ) {
                     errln("Expected containing continent of region %s to be %s. Got: %s",
                         r->getRegionCode(),p?p->getRegionCode():"NULL",c?c->getRegionCode():"NULL" );
                 }
             }
         } else {
             dataerrln("Known region %s was not recognized.",rd.code);
         }
     }
 }
 
 void RegionTest::TestGetContainingRegionWithType() {        
-    for (int32_t i = 0 ; i < LENGTHOF(knownRegions) ; i++ ) {
+    for (int32_t i = 0 ; i < UPRV_LENGTHOF(knownRegions) ; i++ ) {
         KnownRegion rd = knownRegions[i];
         UErrorCode status = U_ZERO_ERROR;
 
         const Region *r = Region::getInstance(rd.code,status);
         if (r) {
             const Region *c = r->getContainingRegion(URGN_CONTINENT);
             if (rd.containingContinent == NULL) {
                  if ( c != NULL) {
                      errln("Containing continent for %s should have been NULL.  Got: %s",r->getRegionCode(), c->getRegionCode());
                  }
@@ skipping 41 matching lines @@
                 }
             }
             delete preferredValues;
         } else {
             dataerrln("Known region %s was not recognized.",data[0]);
         }
     }
 }
 
 void RegionTest::TestContains() {        
-    for (int32_t i = 0 ; i < LENGTHOF(knownRegions) ; i++ ) {
+    for (int32_t i = 0 ; i < UPRV_LENGTHOF(knownRegions) ; i++ ) {
         KnownRegion rd = knownRegions[i];
         UErrorCode status = U_ZERO_ERROR;
 
         const Region *r = Region::getInstance(rd.code,status);
         if (r) {
             const Region *c = r->getContainingRegion();
             while ( c ) {
                 if ( !c->contains(*r)) {
                     errln("Region \"%s\" should have contained \"%s\" but it didn't.",c->getRegionCode(),r->getRegionCode());
                 }
@@ skipping 59 matching lines @@
     errln("Error, 'BM' should have no subregions, but returned str=%p, err=%s\n", emptyStr, u_errorName(status));
   } else {
     logln("Success - BM has no subregions\n");
   }
   delete containedRegions;
 }
 
 #endif /* #if !UCONFIG_NO_FORMATTING */
 
 //eof