ICU 56 update step 1

source/test/intltest/regiontst.cpp

 /***********************************************************************
  * COPYRIGHT: 
- * Copyright (c) 2013-2014, International Business Machines Corporation
+ * Copyright (c) 2013-2015, 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"
@@ skipping 478 matching lines @@
 void RegionTest::TestGetContainedRegions() {
     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();
+            StringEnumeration *containedRegions = r->getContainedRegions(status);
+            if (U_FAILURE(status)) {
+              errln("%s->getContainedRegions(status) failed: %s", r->getRegionCode(), u_errorName(status));
+              continue;
+            }
             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 < 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);
+            StringEnumeration *containedRegions = r->getContainedRegions(URGN_TERRITORY, status);
+            if (U_FAILURE(status)) {
+              errln("%s->getContainedRegions(URGN_TERRITORY, status) failed: %s", r->getRegionCode(), u_errorName(status));
+              continue;
+            }
             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;
@@ skipping 61 matching lines @@
         { "NT", "IQ", "SA", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL },     // Neutral Zone
         { "PC", "FM", "MH", "MP", "PW", NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, }, // Pacific Islands Trust Territory
         { "SU", "RU", "AM", "AZ", "BY", "EE", "GE", "KZ", "KG", "LV", "LT", "MD", "TJ", "TM", "UA", "UZ" , NULL}, // Soviet Union
     };
 
     for ( int32_t i = 0 ; i < 6 ; i++ ) {
         const char **data = testData[i];
         UErrorCode status = U_ZERO_ERROR;
         const Region *r = Region::getInstance(data[0],status);
         if (r) {
-            StringEnumeration *preferredValues = r->getPreferredValues();
+            StringEnumeration *preferredValues = r->getPreferredValues(status);
+            if (U_FAILURE(status)) {
+              errln("%s->getPreferredValues(status) failed: %s", r->getRegionCode(), u_errorName(status));
+              continue;
+            }
             for ( int i = 1 ; data[i] ; i++ ) {
                 UBool found = FALSE;
                 preferredValues->reset(status);
                 while ( const char *check = preferredValues->next(NULL,status) ) {
                     if ( !uprv_strcmp(check,data[i]) ) {
                         found = TRUE;
                         break;
                     }
                 }
                 if ( !found ) {
@@ skipping 24 matching lines @@
         } else {
             dataerrln("Known region %s was not recognized.",rd.code);
         }
     }
 }
 
 void RegionTest::TestAvailableTerritories() {
     // Test to make sure that the set of territories contained in World and the set of all available
     // territories are one and the same.
     UErrorCode status = U_ZERO_ERROR;
-    StringEnumeration *availableTerritories = Region::getAvailable(URGN_TERRITORY);
+    StringEnumeration *availableTerritories = Region::getAvailable(URGN_TERRITORY, status);
+    if (U_FAILURE(status)) {
+        dataerrln("Region::getAvailable(URGN_TERRITORY,status) failed: %s", u_errorName(status));
+        return;
+    }
     const Region *world = Region::getInstance("001",status);
     if (U_FAILURE(status)) {
         dataerrln("Region::getInstance(\"001\",status) failed: %s", u_errorName(status));
         return;
     }
-    StringEnumeration *containedInWorld = world->getContainedRegions(URGN_TERRITORY);
+    StringEnumeration *containedInWorld = world->getContainedRegions(URGN_TERRITORY, status);
+    if (U_FAILURE(status)) {
+        errln("world->getContainedRegions(URGN_TERRITORY, status) failed: %s", u_errorName(status));
+        return;
+    }
     if ( !availableTerritories || !containedInWorld || *availableTerritories != *containedInWorld ) {
         char availableTerritoriesString[1024] = "";
         char containedInWorldString[1024] = "";
         if ( availableTerritories ) {
             for (int32_t i = 0 ; i < availableTerritories->count(status) ; i++ ) {
                 if ( i > 0 ) {
                     uprv_strcat(availableTerritoriesString," ");
                 }
                 uprv_strcat(availableTerritoriesString,availableTerritories->next(NULL,status));
             }
@@ skipping 17 matching lines @@
     delete containedInWorld;
 }
 
 void RegionTest::TestNoContainedRegions(void) {
   UErrorCode status = U_ZERO_ERROR;
   const Region *region = Region::getInstance("BM",status);
   if (U_FAILURE(status) || region == NULL) {
       dataerrln("Fail called to Region::getInstance(\"BM\", status) - %s", u_errorName(status));
       return;
   }
-  StringEnumeration *containedRegions = region->getContainedRegions();
+  StringEnumeration *containedRegions = region->getContainedRegions(status);
+  if (U_FAILURE(status)) {
+      errln("%s->getContainedRegions(status) failed: %s", region->getRegionCode(), u_errorName(status));
+      return;
+  }
   const char *emptyStr = containedRegions->next(NULL, status);
   if (U_FAILURE(status)||(emptyStr!=NULL)) {
     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