icuSources/test/intltest/restsnew.cpp

   1 /********************************************************************
   2  * Copyright (c) 1997-2014, International Business Machines
   3  * Corporation and others. All Rights Reserved.
   4  ********************************************************************/
   5
   6 #include "unicode/utypes.h"
   7
   8 #include "cstring.h"
   9 #include "unicode/unistr.h"
  10 #include "unicode/resbund.h"
  11 #include "restsnew.h"
  12
  13 #include <stdlib.h>
  14 #include <time.h>
  15 #include <string.h>
  16 #include <limits.h>
  17
  18 //***************************************************************************************
  19
  20 static const UChar kErrorUChars[] = { 0x45, 0x52, 0x52, 0x4f, 0x52, 0 };
  21 static const int32_t kErrorLength = 5;
  22 static const int32_t kERROR_COUNT = -1234567;
  23
  24 //***************************************************************************************
  25
  26 enum E_Where
  27 {
  28     e_Root,
  29     e_te,
  30     e_te_IN,
  31     e_Where_count
  32 };
  33
  34 //***************************************************************************************
  35
  36 #define CONFIRM_EQ(actual,expected) if ((expected)==(actual)) { record_pass(); } else { record_fail(); errln(action + (UnicodeString)" returned " + (actual) + (UnicodeString)" instead of " + (expected)); }
  37 #define CONFIRM_GE(actual,expected) if ((actual)>=(expected)) { record_pass(); } else { record_fail(); errln(action + (UnicodeString)" returned " + (actual) + (UnicodeString)" instead of x >= " + (expected)); }
  38 #define CONFIRM_NE(actual,expected) if ((expected)!=(actual)) { record_pass(); } else { record_fail(); errln(action + (UnicodeString)" returned " + (actual) + (UnicodeString)" instead of x != " + (expected)); }
  39
  40 #define CONFIRM_UErrorCode(actual,expected) if ((expected)==(actual)) { record_pass(); } else { record_fail(); errln(action + (UnicodeString)" returned " + (UnicodeString)u_errorName(actual) + (UnicodeString)" instead of " + (UnicodeString)u_errorName(expected)); }
  41
  42 //***************************************************************************************
  43
  44 /**
  45  * Convert an integer, positive or negative, to a character string radix 10.
  46  */
  47 static char*
  48 itoa(int32_t i, char* buf)
  49 {
  50     char* result = buf;
  51
  52     // Handle negative
  53     if (i < 0)
  54     {
  55         *buf++ = '-';
  56         i = -i;
  57     }
  58
  59     // Output digits in reverse order
  60     char* p = buf;
  61     do
  62     {
  63         *p++ = (char)('0' + (i % 10));
  64         i /= 10;
  65     }
  66     while (i);
  67     *p-- = 0;
  68
  69     // Reverse the string
  70     while (buf < p)
  71     {
  72         char c = *buf;
  73         *buf++ = *p;
  74         *p-- = c;
  75     }
  76
  77     return result;
  78 }
  79
  80
  81
  82 //***************************************************************************************
  83
  84 // Array of our test objects
  85
  86 static struct
  87 {
  88     const char* name;
  89     Locale *locale;
  90     UErrorCode expected_constructor_status;
  91     E_Where where;
  92     UBool like[e_Where_count];
  93     UBool inherits[e_Where_count];
  94 }
  95 param[] =
  96 {
  97     // "te" means test
  98     // "IN" means inherits
  99     // "NE" or "ne" means "does not exist"
 100
 101     { "root",       0,   U_ZERO_ERROR,             e_Root,      { TRUE, FALSE, FALSE }, { TRUE, FALSE, FALSE } },
 102     { "te",         0,   U_ZERO_ERROR,             e_te,        { FALSE, TRUE, FALSE }, { TRUE, TRUE, FALSE  } },
 103     { "te_IN",      0,   U_ZERO_ERROR,             e_te_IN,     { FALSE, FALSE, TRUE }, { TRUE, TRUE, TRUE   } },
 104     { "te_NE",      0,   U_USING_FALLBACK_WARNING, e_te,        { FALSE, TRUE, FALSE }, { TRUE, TRUE, FALSE  } },
 105     { "te_IN_NE",   0,   U_USING_FALLBACK_WARNING, e_te_IN,     { FALSE, FALSE, TRUE }, { TRUE, TRUE, TRUE   } },
 106     { "ne",         0,   U_USING_DEFAULT_WARNING,  e_Root,      { TRUE, FALSE, FALSE }, { TRUE, FALSE, FALSE } }
 107 };
 108
 109 static int32_t bundles_count = sizeof(param) / sizeof(param[0]);
 110
 111 //***************************************************************************************
 112
 113 /**
 114  * Return a random unsigned long l where 0N <= l <= ULONG_MAX.
 115  */
 116
 117 static uint32_t
 118 randul()
 119 {
 120     static UBool initialized = FALSE;
 121     if (!initialized)
 122     {
 123         srand((unsigned)time(NULL));
 124         initialized = TRUE;
 125     }
 126     // Assume rand has at least 12 bits of precision
 127     uint32_t l = 0;
 128     for (uint32_t i=0; i<sizeof(l); ++i)
 129         ((char*)&l)[i] = (char)((rand() & 0x0FF0) >> 4);
 130     return l;
 131 }
 132
 133 /**
 134  * Return a random double x where 0.0 <= x < 1.0.
 135  */
 136 static double
 137 randd()
 138 {
 139     return (double)(randul() / ULONG_MAX);
 140 }
 141
 142 /**
 143  * Return a random integer i where 0 <= i < n.
 144  */
 145 static int32_t randi(int32_t n)
 146 {
 147     return (int32_t)(randd() * n);
 148 }
 149
 150 //***************************************************************************************
 151
 152 /*
 153  Don't use more than one of these at a time because of the Locale names
 154 */
 155 NewResourceBundleTest::NewResourceBundleTest()
 156 : pass(0),
 157   fail(0)
 158 {
 159     if (param[5].locale == NULL) {
 160         param[0].locale = new Locale("root");
 161         param[1].locale = new Locale("te");
 162         param[2].locale = new Locale("te", "IN");
 163         param[3].locale = new Locale("te", "NE");
 164         param[4].locale = new Locale("te", "IN", "NE");
 165         param[5].locale = new Locale("ne");
 166     }
 167 }
 168
 169 NewResourceBundleTest::~NewResourceBundleTest()
 170 {
 171     if (param[5].locale) {
 172         int idx;
 173         for (idx = 0; idx < (int)(sizeof(param)/sizeof(param[0])); idx++) {
 174             delete param[idx].locale;
 175             param[idx].locale = NULL;
 176         }
 177     }
 178 }
 179
 180 void NewResourceBundleTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
 181 {
 182     if (exec) logln("TestSuite ResourceBundleTest: ");
 183     switch (index) {
 184 #if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION
 185     case 0: name = "TestResourceBundles"; if (exec) TestResourceBundles(); break;
 186     case 1: name = "TestConstruction"; if (exec) TestConstruction(); break;
 187     case 2: name = "TestIteration"; if (exec) TestIteration(); break;
 188     case 3: name = "TestOtherAPI";  if(exec) TestOtherAPI(); break;
 189     case 4: name = "TestNewTypes";  if(exec) TestNewTypes(); break;
 190 #else
 191     case 0: case 1: case 2: case 3: case 4: name = "skip"; break;
 192 #endif
 193
 194     case 5: name = "TestGetByFallback";  if(exec) TestGetByFallback(); break;
 195         default: name = ""; break; //needed to end loop
 196     }
 197 }
 198
 199 //***************************************************************************************
 200
 201 void
 202 NewResourceBundleTest::TestResourceBundles()
 203 {
 204     UErrorCode status = U_ZERO_ERROR;
 205     loadTestData(status);
 206     if(U_FAILURE(status))
 207     {
 208         dataerrln("Could not load testdata.dat %s " + UnicodeString(u_errorName(status)));
 209         return;
 210     }
 211
 212     /* Make sure that users using te_IN for the default locale don't get test failures. */
 213     Locale originalDefault;
 214     if (Locale::getDefault() == Locale("te_IN")) {
 215         Locale::setDefault(Locale("en_US"), status);
 216     }
 217
 218     testTag("only_in_Root", TRUE, FALSE, FALSE);
 219     testTag("only_in_te", FALSE, TRUE, FALSE);
 220     testTag("only_in_te_IN", FALSE, FALSE, TRUE);
 221     testTag("in_Root_te", TRUE, TRUE, FALSE);
 222     testTag("in_Root_te_te_IN", TRUE, TRUE, TRUE);
 223     testTag("in_Root_te_IN", TRUE, FALSE, TRUE);
 224     testTag("in_te_te_IN", FALSE, TRUE, TRUE);
 225     testTag("nonexistent", FALSE, FALSE, FALSE);
 226     logln("Passed: %d\nFailed: %d", pass, fail);
 227
 228     /* Restore the default locale for the other tests. */
 229     Locale::setDefault(originalDefault, status);
 230 }
 231
 232 void
 233 NewResourceBundleTest::TestConstruction()
 234 {
 235     UErrorCode   err = U_ZERO_ERROR;
 236     Locale       locale("te", "IN");
 237
 238     const char* testdatapath;
 239     testdatapath=loadTestData(err);
 240     if(U_FAILURE(err))
 241     {
 242         dataerrln("Could not load testdata.dat %s " + UnicodeString(u_errorName(err)));
 243         return;
 244     }
 245
 246     /* Make sure that users using te_IN for the default locale don't get test failures. */
 247     Locale originalDefault;
 248     if (Locale::getDefault() == Locale("te_IN")) {
 249         Locale::setDefault(Locale("en_US"), err);
 250     }
 251
 252     ResourceBundle  test1((UnicodeString)testdatapath, err);
 253     ResourceBundle  test2(testdatapath, locale, err);
 254
 255     UnicodeString   result1;
 256     UnicodeString   result2;
 257
 258     result1 = test1.getStringEx("string_in_Root_te_te_IN", err);
 259     result2 = test2.getStringEx("string_in_Root_te_te_IN", err);
 260     if (U_FAILURE(err)) {
 261         errln("Something threw an error in TestConstruction()");
 262         return;
 263     }
 264
 265     logln("for string_in_Root_te_te_IN, root.txt had " + result1);
 266     logln("for string_in_Root_te_te_IN, te_IN.txt had " + result2);
 267
 268     if (result1 != "ROOT" || result2 != "TE_IN") {
 269         errln("Construction test failed; run verbose for more information");
 270     }
 271
 272     const char* version1;
 273     const char* version2;
 274
 275     version1 = test1.getVersionNumber();
 276     version2 = test2.getVersionNumber();
 277
 278     char *versionID1 = new char[1 + strlen(U_ICU_VERSION) + strlen(version1)]; // + 1 for zero byte
 279     char *versionID2 = new char[1 + strlen(U_ICU_VERSION) + strlen(version2)]; // + 1 for zero byte
 280
 281     strcpy(versionID1, "44.0");  // hardcoded, please change if the default.txt file or ResourceBundle::kVersionSeparater is changed.
 282
 283     strcpy(versionID2, "55.0");  // hardcoded, please change if the te_IN.txt file or ResourceBundle::kVersionSeparater is changed.
 284
 285     logln(UnicodeString("getVersionNumber on default.txt returned ") + version1 + UnicodeString(" Expect: " ) + versionID1);
 286     logln(UnicodeString("getVersionNumber on te_IN.txt returned ") + version2 + UnicodeString(" Expect: " ) + versionID2);
 287
 288     if (strcmp(version1, versionID1) != 0) {
 289         errln("getVersionNumber(version1) failed. %s != %s", version1, versionID1);
 290     }
 291     if (strcmp(version2, versionID2) != 0) {
 292         errln("getVersionNumber(version2) failed. %s != %s", version2, versionID2);
 293     }
 294     delete[] versionID1;
 295     delete[] versionID2;
 296
 297     /* Restore the default locale for the other tests. */
 298     Locale::setDefault(originalDefault, err);
 299 }
 300
 301 void
 302 NewResourceBundleTest::TestIteration()
 303 {
 304     UErrorCode   err = U_ZERO_ERROR;
 305     const char* testdatapath;
 306     const char* data[]={
 307         "string_in_Root_te_te_IN",   "1",
 308         "array_in_Root_te_te_IN",    "5",
 309         "array_2d_in_Root_te_te_IN", "4",
 310     };
 311
 312     Locale       *locale=new Locale("te_IN");
 313
 314     testdatapath=loadTestData(err);
 315     if(U_FAILURE(err))
 316     {
 317         dataerrln("Could not load testdata.dat %s " + UnicodeString(u_errorName(err)));
 318         return;
 319     }
 320
 321     ResourceBundle  test1(testdatapath, *locale, err);
 322     if(U_FAILURE(err)){
 323         errln("Construction failed");
 324     }
 325     uint32_t i;
 326     int32_t count, row=0, col=0;
 327     char buf[5];
 328     UnicodeString expected;
 329     UnicodeString element("TE_IN");
 330     UnicodeString action;
 331
 332
 333     for(i=0; i<sizeof(data)/sizeof(data[0]); i=i+2){
 334         action = "te_IN";
 335         action +=".get(";
 336         action += data[i];
 337         action +=", err)";
 338         err=U_ZERO_ERROR;
 339         ResourceBundle bundle = test1.get(data[i], err);
 340         if(!U_FAILURE(err)){
 341             action = "te_IN";
 342             action +=".getKey()";
 343
 344             CONFIRM_EQ((UnicodeString)bundle.getKey(), (UnicodeString)data[i]);
 345
 346             count=0;
 347             row=0;
 348             while(bundle.hasNext()){
 349                 action = data[i];
 350                 action +=".getNextString(err)";
 351                 row=count;
 352                 UnicodeString got=bundle.getNextString(err);
 353                 if(U_SUCCESS(err)){
 354                     expected=element;
 355                     if(bundle.getSize() > 1){
 356                         CONFIRM_EQ(bundle.getType(), URES_ARRAY);
 357                         expected+=itoa(row, buf);
 358                         ResourceBundle rowbundle=bundle.get(row, err);
 359                         if(!U_FAILURE(err) && rowbundle.getSize()>1){
 360                             col=0;
 361                             while(rowbundle.hasNext()){
 362                                 expected=element;
 363                                 got=rowbundle.getNextString(err);
 364                                 if(!U_FAILURE(err)){
 365                                     expected+=itoa(row, buf);
 366                                     expected+=itoa(col, buf);
 367                                     col++;
 368                                     CONFIRM_EQ(got, expected);
 369                                 }
 370                             }
 371                             CONFIRM_EQ(col, rowbundle.getSize());
 372                         }
 373                     }
 374                     else{
 375                         CONFIRM_EQ(bundle.getType(), (int32_t)URES_STRING);
 376                     }
 377                 }
 378                 CONFIRM_EQ(got, expected);
 379                 count++;
 380             }
 381             action = data[i];
 382             action +=".getSize()";
 383             CONFIRM_EQ(bundle.getSize(), count);
 384             CONFIRM_EQ(count, atoi(data[i+1]));
 385             //after reaching the end
 386             err=U_ZERO_ERROR;
 387             ResourceBundle errbundle=bundle.getNext(err);
 388             action = "After reaching the end of the Iterator:-  ";
 389             action +=data[i];
 390             action +=".getNext()";
 391             CONFIRM_NE(err, (int32_t)U_ZERO_ERROR);
 392             CONFIRM_EQ(u_errorName(err), u_errorName(U_INDEX_OUTOFBOUNDS_ERROR));
 393             //reset the iterator
 394             err = U_ZERO_ERROR;
 395             bundle.resetIterator();
 396          /*  The following code is causing a crash
 397          ****CRASH******
 398          */
 399
 400             bundle.getNext(err);
 401             if(U_FAILURE(err)){
 402                 errln("ERROR: getNext()  throw an error");
 403             }
 404         }
 405     }
 406     delete locale;
 407 }
 408
 409 // TODO: add operator== and != to ResourceBundle
 410 static UBool
 411 equalRB(ResourceBundle &a, ResourceBundle &b) {
 412     UResType type;
 413     UErrorCode status;
 414
 415     type=a.getType();
 416     status=U_ZERO_ERROR;
 417     return
 418         type==b.getType() &&
 419         a.getLocale()==b.getLocale() &&
 420         0==strcmp(a.getName(), b.getName()) &&
 421         type==URES_STRING ?
 422             a.getString(status)==b.getString(status) :
 423             type==URES_INT ?
 424                 a.getInt(status)==b.getInt(status) :
 425                 TRUE;
 426 }
 427
 428 void
 429 NewResourceBundleTest::TestOtherAPI(){
 430     UErrorCode   err = U_ZERO_ERROR;
 431     const char* testdatapath=loadTestData(err);
 432     UnicodeString tDataPathUS = UnicodeString(testdatapath, "");
 433
 434     if(U_FAILURE(err))
 435     {
 436         dataerrln("Could not load testdata.dat %s " + UnicodeString(u_errorName(err)));
 437         return;
 438     }
 439
 440     /* Make sure that users using te_IN for the default locale don't get test failures. */
 441     Locale originalDefault;
 442     if (Locale::getDefault() == Locale("te_IN")) {
 443         Locale::setDefault(Locale("en_US"), err);
 444     }
 445
 446     Locale       *locale=new Locale("te_IN");
 447
 448     ResourceBundle test0(tDataPathUS, *locale, err);
 449     if(U_FAILURE(err)){
 450         errln("Construction failed");
 451         return;
 452     }
 453
 454     ResourceBundle  test1(testdatapath, *locale, err);
 455     if(U_FAILURE(err)){
 456         errln("Construction failed");
 457         return;
 458     }
 459
 460     logln("Testing getLocale()\n");
 461     if(strcmp(test1.getLocale().getName(), locale->getName()) !=0 ){
 462         errln("FAIL: ResourceBundle::getLocale() failed\n");
 463     }
 464
 465     delete locale;
 466
 467     logln("Testing ResourceBundle(UErrorCode)\n");
 468     ResourceBundle defaultresource(err);
 469     ResourceBundle explicitdefaultresource(NULL, Locale::getDefault(), err);
 470     if(U_FAILURE(err)){
 471         errcheckln(err, "Construction of default resourcebundle failed - %s", u_errorName(err));
 472         return;
 473     }
 474     // You can't compare the default locale to the resolved locale in the
 475     // resource bundle due to aliasing, keywords in the default locale
 476     // or the chance that the machine running these tests is using a locale
 477     // that isn't available in ICU.
 478     if(strcmp(defaultresource.getLocale().getName(), explicitdefaultresource.getLocale().getName()) != 0){
 479         errln("Construction of default resourcebundle didn't take the defaultlocale. Expected %s Got %s err=%s\n",
 480             explicitdefaultresource.getLocale().getName(), defaultresource.getLocale().getName(), u_errorName(err));
 481     }
 482
 483
 484     ResourceBundle copyRes(defaultresource);
 485     if(strcmp(copyRes.getName(), defaultresource.getName() ) !=0  ||
 486         strcmp(test1.getName(), defaultresource.getName() ) ==0 ||
 487         strcmp(copyRes.getLocale().getName(), defaultresource.getLocale().getName() ) !=0  ||
 488         strcmp(test1.getLocale().getName(), defaultresource.getLocale().getName() ) ==0 )
 489     {
 490         errln("copy construction failed\n");
 491     }
 492
 493     ResourceBundle defaultSub = defaultresource.get((int32_t)0, err);
 494     ResourceBundle defSubCopy(defaultSub);
 495     if(strcmp(defSubCopy.getName(), defaultSub.getName() ) !=0  ||
 496         strcmp(defSubCopy.getLocale().getName(), defaultSub.getLocale().getName() ) !=0  ){
 497         errln("copy construction for subresource failed\n");
 498     }
 499
 500     ResourceBundle *p;
 501
 502     p = defaultresource.clone();
 503     if(p == &defaultresource || !equalRB(*p, defaultresource)) {
 504         errln("ResourceBundle.clone() failed");
 505     }
 506     delete p;
 507
 508     p = defaultSub.clone();
 509     if(p == &defaultSub || !equalRB(*p, defaultSub)) {
 510         errln("2nd ResourceBundle.clone() failed");
 511     }
 512     delete p;
 513
 514     UVersionInfo ver;
 515     copyRes.getVersion(ver);
 516
 517     logln("Version returned: [%d.%d.%d.%d]\n", ver[0], ver[1], ver[2], ver[3]);
 518
 519     logln("Testing C like UnicodeString APIs\n");
 520
 521     UResourceBundle *testCAPI = NULL, *bundle = NULL, *rowbundle = NULL, *temp = NULL;
 522     err = U_ZERO_ERROR;
 523     const char* data[]={
 524         "string_in_Root_te_te_IN",   "1",
 525         "array_in_Root_te_te_IN",    "5",
 526         "array_2d_in_Root_te_te_IN", "4",
 527     };
 528
 529
 530     testCAPI = ures_open(testdatapath, "te_IN", &err);
 531
 532     if(U_SUCCESS(err)) {
 533         // Do the testing
 534         // first iteration
 535
 536         uint32_t i;
 537         int32_t count, row=0, col=0;
 538         char buf[5];
 539         UnicodeString expected;
 540         UnicodeString element("TE_IN");
 541         UnicodeString action;
 542
 543
 544         for(i=0; i<sizeof(data)/sizeof(data[0]); i=i+2){
 545             action = "te_IN";
 546             action +=".get(";
 547             action += data[i];
 548             action +=", err)";
 549             err=U_ZERO_ERROR;
 550             bundle = ures_getByKey(testCAPI, data[i], bundle, &err);
 551             if(!U_FAILURE(err)){
 552                 const char* key = NULL;
 553                 action = "te_IN";
 554                 action +=".getKey()";
 555
 556                 CONFIRM_EQ((UnicodeString)ures_getKey(bundle), (UnicodeString)data[i]);
 557
 558                 count=0;
 559                 row=0;
 560                 while(ures_hasNext(bundle)){
 561                     action = data[i];
 562                     action +=".getNextString(err)";
 563                     row=count;
 564                     UnicodeString got=ures_getNextUnicodeString(bundle, &key, &err);
 565                     if(U_SUCCESS(err)){
 566                         expected=element;
 567                         if(ures_getSize(bundle) > 1){
 568                             CONFIRM_EQ(ures_getType(bundle), URES_ARRAY);
 569                             expected+=itoa(row, buf);
 570                             rowbundle=ures_getByIndex(bundle, row, rowbundle, &err);
 571                             if(!U_FAILURE(err) && ures_getSize(rowbundle)>1){
 572                                 col=0;
 573                                 while(ures_hasNext(rowbundle)){
 574                                     expected=element;
 575                                     got=ures_getNextUnicodeString(rowbundle, &key, &err);
 576                                     temp = ures_getByIndex(rowbundle, col, temp, &err);
 577                                     UnicodeString bla = ures_getUnicodeString(temp, &err);
 578                                     UnicodeString bla2 = ures_getUnicodeStringByIndex(rowbundle, col, &err);
 579                                     if(!U_FAILURE(err)){
 580                                         expected+=itoa(row, buf);
 581                                         expected+=itoa(col, buf);
 582                                         col++;
 583                                         CONFIRM_EQ(got, expected);
 584                                         CONFIRM_EQ(bla, expected);
 585                                         CONFIRM_EQ(bla2, expected);
 586                                     }
 587                                 }
 588                                 CONFIRM_EQ(col, ures_getSize(rowbundle));
 589                             }
 590                         }
 591                         else{
 592                             CONFIRM_EQ(ures_getType(bundle), (int32_t)URES_STRING);
 593                         }
 594                     }
 595                     CONFIRM_EQ(got, expected);
 596                     count++;
 597                 }
 598             }
 599         }
 600         ures_close(temp);
 601         ures_close(rowbundle);
 602         ures_close(bundle);
 603         ures_close(testCAPI);
 604     } else {
 605         errln("failed to open a resource bundle\n");
 606     }
 607
 608     /* Restore the default locale for the other tests. */
 609     Locale::setDefault(originalDefault, err);
 610 }
 611
 612
 613
 614
 615 //***************************************************************************************
 616
 617 UBool
 618 NewResourceBundleTest::testTag(const char* frag,
 619                             UBool in_Root,
 620                             UBool in_te,
 621                             UBool in_te_IN)
 622 {
 623     int32_t failOrig = fail;
 624
 625     // Make array from input params
 626
 627     UBool is_in[] = { in_Root, in_te, in_te_IN };
 628
 629     const char* NAME[] = { "ROOT", "TE", "TE_IN" };
 630
 631     // Now try to load the desired items
 632
 633     char tag[100];
 634     UnicodeString action;
 635
 636     int32_t i,j,row,col, actual_bundle;
 637     int32_t index;
 638     const char* testdatapath;
 639
 640     UErrorCode status = U_ZERO_ERROR;
 641     testdatapath=loadTestData(status);
 642     if(U_FAILURE(status))
 643     {
 644         dataerrln("Could not load testdata.dat %s " + UnicodeString(u_errorName(status)));
 645         return FALSE;
 646     }
 647
 648     for (i=0; i<bundles_count; ++i)
 649     {
 650         action = "Constructor for ";
 651         action += param[i].name;
 652
 653         status = U_ZERO_ERROR;
 654         ResourceBundle theBundle( testdatapath, *param[i].locale, status);
 655         //ResourceBundle theBundle( "c:\\icu\\icu\\source\\test\\testdata\\testdata", *param[i].locale, status);
 656         CONFIRM_UErrorCode(status,param[i].expected_constructor_status);
 657
 658         if(i == 5)
 659           actual_bundle = 0; /* ne -> default */
 660         else if(i == 3)
 661           actual_bundle = 1; /* te_NE -> te */
 662         else if(i == 4)
 663           actual_bundle = 2; /* te_IN_NE -> te_IN */
 664         else
 665           actual_bundle = i;
 666
 667
 668         UErrorCode expected_resource_status = U_MISSING_RESOURCE_ERROR;
 669         for (j=e_te_IN; j>=e_Root; --j)
 670         {
 671             if (is_in[j] && param[i].inherits[j])
 672               {
 673                 if(j == actual_bundle) /* it's in the same bundle OR it's a nonexistent=default bundle (5) */
 674                   expected_resource_status = U_ZERO_ERROR;
 675                 else if(j == 0)
 676                   expected_resource_status = U_USING_DEFAULT_WARNING;
 677                 else
 678                   expected_resource_status = U_USING_FALLBACK_WARNING;
 679
 680                 break;
 681             }
 682         }
 683
 684         UErrorCode expected_status;
 685
 686         UnicodeString base;
 687         for (j=param[i].where; j>=0; --j)
 688         {
 689             if (is_in[j])
 690             {
 691                 base = NAME[j];
 692                 break;
 693             }
 694         }
 695
 696         //--------------------------------------------------------------------------
 697         // string
 698
 699         uprv_strcpy(tag, "string_");
 700         uprv_strcat(tag, frag);
 701
 702         action = param[i].name;
 703         action += ".getStringEx(";
 704         action += tag;
 705         action += ")";
 706
 707
 708         status = U_ZERO_ERROR;
 709         UnicodeString string = theBundle.getStringEx(tag, status);
 710         if(U_FAILURE(status)) {
 711             string.setTo(TRUE, kErrorUChars, kErrorLength);
 712         }
 713
 714         CONFIRM_UErrorCode(status, expected_resource_status);
 715
 716         UnicodeString expected_string(kErrorUChars);
 717         if (U_SUCCESS(status)) {
 718             expected_string = base;
 719         }
 720
 721         CONFIRM_EQ(string, expected_string);
 722
 723         //--------------------------------------------------------------------------
 724         // array   ResourceBundle using the key
 725
 726         uprv_strcpy(tag, "array_");
 727         uprv_strcat(tag, frag);
 728
 729         action = param[i].name;
 730         action += ".get(";
 731         action += tag;
 732         action += ")";
 733
 734         int32_t count = kERROR_COUNT;
 735         status = U_ZERO_ERROR;
 736         ResourceBundle array = theBundle.get(tag, status);
 737         CONFIRM_UErrorCode(status,expected_resource_status);
 738
 739
 740         if (U_SUCCESS(status))
 741         {
 742             //confirm the resource type is an array
 743             UResType bundleType=array.getType();
 744             CONFIRM_EQ(bundleType, URES_ARRAY);
 745
 746             count=array.getSize();
 747             CONFIRM_GE(count,1);
 748
 749             for (j=0; j<count; ++j)
 750             {
 751                 char buf[32];
 752                 expected_string = base;
 753                 expected_string += itoa(j,buf);
 754                 CONFIRM_EQ(array.getNextString(status),expected_string);
 755             }
 756
 757         }
 758         else
 759         {
 760             CONFIRM_EQ(count,kERROR_COUNT);
 761             //       CONFIRM_EQ((int32_t)(unsigned long)array,(int32_t)0);
 762             count = 0;
 763         }
 764
 765         //--------------------------------------------------------------------------
 766         // arrayItem ResourceBundle using the index
 767
 768
 769         for (j=0; j<100; ++j)
 770         {
 771             index = count ? (randi(count * 3) - count) : (randi(200) - 100);
 772             status = U_ZERO_ERROR;
 773             string = kErrorUChars;
 774             ResourceBundle array = theBundle.get(tag, status);
 775             if(!U_FAILURE(status)){
 776                 UnicodeString t = array.getStringEx(index, status);
 777                 if(!U_FAILURE(status)) {
 778                    string=t;
 779                 }
 780             }
 781
 782             expected_status = (index >= 0 && index < count) ? expected_resource_status : U_MISSING_RESOURCE_ERROR;
 783             CONFIRM_UErrorCode(status,expected_status);
 784
 785             if (U_SUCCESS(status)){
 786                 char buf[32];
 787                 expected_string = base;
 788                 expected_string += itoa(index,buf);
 789             } else {
 790                 expected_string = kErrorUChars;
 791             }
 792                CONFIRM_EQ(string,expected_string);
 793
 794         }
 795
 796         //--------------------------------------------------------------------------
 797         // 2dArray
 798
 799         uprv_strcpy(tag, "array_2d_");
 800         uprv_strcat(tag, frag);
 801
 802         action = param[i].name;
 803         action += ".get(";
 804         action += tag;
 805         action += ")";
 806
 807
 808         int32_t row_count = kERROR_COUNT, column_count = kERROR_COUNT;
 809         status = U_ZERO_ERROR;
 810         ResourceBundle array2d=theBundle.get(tag, status);
 811
 812         //const UnicodeString** array2d = theBundle.get2dArray(tag, row_count, column_count, status);
 813         CONFIRM_UErrorCode(status,expected_resource_status);
 814
 815         if (U_SUCCESS(status))
 816         {
 817             //confirm the resource type is an 2darray
 818             UResType bundleType=array2d.getType();
 819             CONFIRM_EQ(bundleType, URES_ARRAY);
 820
 821             row_count=array2d.getSize();
 822             CONFIRM_GE(row_count,1);
 823
 824             for(row=0; row<row_count; ++row){
 825                 ResourceBundle tablerow=array2d.get(row, status);
 826                 CONFIRM_UErrorCode(status, expected_resource_status);
 827                 if(U_SUCCESS(status)){
 828                     //confirm the resourcetype of each table row is an array
 829                     UResType rowType=tablerow.getType();
 830                     CONFIRM_EQ(rowType, URES_ARRAY);
 831
 832                     column_count=tablerow.getSize();
 833                     CONFIRM_GE(column_count,1);
 834
 835                     for (col=0; j<column_count; ++j) {
 836                            char buf[32];
 837                            expected_string = base;
 838                            expected_string += itoa(row,buf);
 839                            expected_string += itoa(col,buf);
 840                            CONFIRM_EQ(tablerow.getNextString(status),expected_string);
 841                     }
 842                 }
 843             }
 844         }else{
 845             CONFIRM_EQ(row_count,kERROR_COUNT);
 846             CONFIRM_EQ(column_count,kERROR_COUNT);
 847              row_count=column_count=0;
 848         }
 849
 850
 851
 852
 853        //--------------------------------------------------------------------------
 854        // 2dArrayItem
 855        for (j=0; j<200; ++j)
 856        {
 857            row = row_count ? (randi(row_count * 3) - row_count) : (randi(200) - 100);
 858            col = column_count ? (randi(column_count * 3) - column_count) : (randi(200) - 100);
 859            status = U_ZERO_ERROR;
 860            string = kErrorUChars;
 861            ResourceBundle array2d=theBundle.get(tag, status);
 862            if(U_SUCCESS(status)){
 863                 ResourceBundle tablerow=array2d.get(row, status);
 864                 if(U_SUCCESS(status)) {
 865                     UnicodeString t=tablerow.getStringEx(col, status);
 866                     if(U_SUCCESS(status)){
 867                        string=t;
 868                     }
 869                 }
 870            }
 871            expected_status = (row >= 0 && row < row_count && col >= 0 && col < column_count) ?
 872                                   expected_resource_status: U_MISSING_RESOURCE_ERROR;
 873            CONFIRM_UErrorCode(status,expected_status);
 874
 875            if (U_SUCCESS(status)){
 876                char buf[32];
 877                expected_string = base;
 878                expected_string += itoa(row,buf);
 879                expected_string += itoa(col,buf);
 880            } else {
 881                expected_string = kErrorUChars;
 882            }
 883                CONFIRM_EQ(string,expected_string);
 884
 885         }
 886
 887         //--------------------------------------------------------------------------
 888         // taggedArray
 889
 890         uprv_strcpy(tag, "tagged_array_");
 891         uprv_strcat(tag, frag);
 892
 893         action = param[i].name;
 894         action += ".get(";
 895         action += tag;
 896         action += ")";
 897
 898         int32_t         tag_count;
 899         status = U_ZERO_ERROR;
 900
 901         ResourceBundle tags=theBundle.get(tag, status);
 902         CONFIRM_UErrorCode(status, expected_resource_status);
 903
 904         if (U_SUCCESS(status)) {
 905             UResType bundleType=tags.getType();
 906             CONFIRM_EQ(bundleType, URES_TABLE);
 907
 908             tag_count=tags.getSize();
 909             CONFIRM_GE((int32_t)tag_count, (int32_t)0);
 910
 911             for(index=0; index <tag_count; index++){
 912                 ResourceBundle tagelement=tags.get(index, status);
 913                 UnicodeString key=tagelement.getKey();
 914                 UnicodeString value=tagelement.getNextString(status);
 915                 logln("tag = " + key + ", value = " + value );
 916                 if(key.startsWith("tag") && value.startsWith(base)){
 917                     record_pass();
 918                 }else{
 919                     record_fail();
 920                 }
 921
 922             }
 923
 924             for(index=0; index <tag_count; index++){
 925                 ResourceBundle tagelement=tags.get(index, status);
 926                 const char *tkey=NULL;
 927                 UnicodeString value=tagelement.getNextString(&tkey, status);
 928                 UnicodeString key(tkey);
 929                 logln("tag = " + key + ", value = " + value );
 930                 if(value.startsWith(base)){
 931                     record_pass();
 932                 }else{
 933                     record_fail();
 934                 }
 935             }
 936
 937         }else{
 938             tag_count=0;
 939         }
 940
 941
 942
 943
 944         //--------------------------------------------------------------------------
 945         // taggedArrayItem
 946
 947         action = param[i].name;
 948         action += ".get(";
 949         action += tag;
 950         action += ")";
 951
 952         count = 0;
 953         for (index=-20; index<20; ++index)
 954         {
 955             char buf[32];
 956             status = U_ZERO_ERROR;
 957             string = kErrorUChars;
 958             char item_tag[8];
 959             uprv_strcpy(item_tag, "tag");
 960             uprv_strcat(item_tag, itoa(index,buf));
 961             ResourceBundle tags=theBundle.get(tag, status);
 962             if(U_SUCCESS(status)){
 963                 ResourceBundle tagelement=tags.get(item_tag, status);
 964                 if(!U_FAILURE(status)){
 965                     UResType elementType=tagelement.getType();
 966                     CONFIRM_EQ(elementType, (int32_t)URES_STRING);
 967                     const char* key=tagelement.getKey();
 968                     CONFIRM_EQ((UnicodeString)key, (UnicodeString)item_tag);
 969                     UnicodeString t=tagelement.getString(status);
 970                     if(!U_FAILURE(status)){
 971                         string=t;
 972                     }
 973                 }
 974                 if (index < 0) {
 975                     CONFIRM_UErrorCode(status,U_MISSING_RESOURCE_ERROR);
 976                 }
 977                 else{
 978                    if (status != U_MISSING_RESOURCE_ERROR) {
 979                        count++;
 980                        expected_string = base;
 981                        expected_string += buf;
 982                        CONFIRM_EQ(string,expected_string);
 983                    }
 984                 }
 985             }
 986
 987         }
 988         CONFIRM_EQ(count, tag_count);
 989
 990     }
 991     return (UBool)(failOrig == fail);
 992 }
 993
 994 void
 995 NewResourceBundleTest::record_pass()
 996 {
 997   ++pass;
 998 }
 999 void
1000 NewResourceBundleTest::record_fail()
1001 {
1002   err();
1003   ++fail;
1004 }
1005
1006
1007 void
1008 NewResourceBundleTest::TestNewTypes() {
1009     char action[256];
1010     const char* testdatapath;
1011     UErrorCode status = U_ZERO_ERROR;
1012     uint8_t *binResult = NULL;
1013     int32_t len = 0;
1014     int32_t i = 0;
1015     int32_t intResult = 0;
1016     uint32_t uintResult = 0;
1017     UChar expected[] = { 'a','b','c','\0','d','e','f' };
1018     const char* expect ="tab:\t cr:\r ff:\f newline:\n backslash:\\\\ quote=\\\' doubleQuote=\\\" singlequoutes=''";
1019     UChar uExpect[200];
1020
1021     testdatapath=loadTestData(status);
1022
1023     if(U_FAILURE(status))
1024     {
1025         dataerrln("Could not load testdata.dat %s \n",u_errorName(status));
1026         return;
1027     }
1028
1029     ResourceBundle theBundle(testdatapath, "testtypes", status);
1030     ResourceBundle bundle(testdatapath, Locale("te_IN"),status);
1031
1032     UnicodeString emptyStr = theBundle.getStringEx("emptystring", status);
1033     if(emptyStr.length() != 0) {
1034       logln("Empty string returned invalid value\n");
1035     }
1036
1037     CONFIRM_UErrorCode(status, U_ZERO_ERROR);
1038
1039     /* This test reads the string "abc\u0000def" from the bundle   */
1040     /* if everything is working correctly, the size of this string */
1041     /* should be 7. Everything else is a wrong answer, esp. 3 and 6*/
1042
1043     strcpy(action, "getting and testing of string with embeded zero");
1044     ResourceBundle res = theBundle.get("zerotest", status);
1045     CONFIRM_UErrorCode(status, U_ZERO_ERROR);
1046     CONFIRM_EQ(res.getType(), URES_STRING);
1047     UnicodeString zeroString=res.getString(status);
1048     len = zeroString.length();
1049     if(U_SUCCESS(status)){
1050         CONFIRM_UErrorCode(status, U_ZERO_ERROR);
1051         CONFIRM_EQ(len, 7);
1052         CONFIRM_NE(len, 3);
1053     }
1054     for(i=0;i<len;i++){
1055         if(zeroString[i]!= expected[i]){
1056             logln("Output didnot match Expected: \\u%4X Got: \\u%4X", expected[i], zeroString[i]);
1057         }
1058     }
1059
1060     strcpy(action, "getting and testing of binary type");
1061     res = theBundle.get("binarytest", status);
1062     CONFIRM_UErrorCode(status, U_ZERO_ERROR);
1063     CONFIRM_EQ(res.getType(), URES_BINARY);
1064     binResult=(uint8_t*)res.getBinary(len, status);
1065     if(U_SUCCESS(status)){
1066         CONFIRM_UErrorCode(status, U_ZERO_ERROR);
1067         CONFIRM_EQ(len, 15);
1068         for(i = 0; i<15; i++) {
1069             CONFIRM_EQ(binResult[i], i);
1070         }
1071     }
1072
1073     strcpy(action, "getting and testing of imported binary type");
1074     res = theBundle.get("importtest",status);
1075     CONFIRM_UErrorCode(status, U_ZERO_ERROR);
1076     CONFIRM_EQ(res.getType(), URES_BINARY);
1077     binResult=(uint8_t*)res.getBinary(len, status);
1078     if(U_SUCCESS(status)){
1079         CONFIRM_UErrorCode(status, U_ZERO_ERROR);
1080         CONFIRM_EQ(len, 15);
1081         for(i = 0; i<15; i++) {
1082             CONFIRM_EQ(binResult[i], i);
1083         }
1084     }
1085
1086     strcpy(action, "getting and testing of integer types");
1087     res = theBundle.get("one",  status);
1088     CONFIRM_UErrorCode(status, U_ZERO_ERROR);
1089     CONFIRM_EQ(res.getType(), URES_INT);
1090     intResult=res.getInt(status);
1091     uintResult = res.getUInt(status);
1092     if(U_SUCCESS(status)){
1093         CONFIRM_UErrorCode(status, U_ZERO_ERROR);
1094         CONFIRM_EQ(uintResult, (uint32_t)intResult);
1095         CONFIRM_EQ(intResult, 1);
1096     }
1097
1098     strcpy(action, "getting minusone");
1099     res = theBundle.get((const char*)"minusone", status);
1100     CONFIRM_UErrorCode(status, U_ZERO_ERROR);
1101     CONFIRM_EQ(res.getType(), URES_INT);
1102     intResult=res.getInt(status);
1103     uintResult = res.getUInt(status);
1104     if(U_SUCCESS(status)){
1105         CONFIRM_UErrorCode(status, U_ZERO_ERROR);
1106         CONFIRM_EQ(uintResult, 0x0FFFFFFF); /* a 28 bit integer */
1107         CONFIRM_EQ(intResult, -1);
1108         CONFIRM_NE(uintResult, (uint32_t)intResult);
1109     }
1110
1111     strcpy(action, "getting plusone");
1112     res = theBundle.get("plusone",status);
1113     CONFIRM_UErrorCode(status, U_ZERO_ERROR);
1114     CONFIRM_EQ(res.getType(), URES_INT);
1115     intResult=res.getInt(status);
1116     uintResult = res.getUInt(status);
1117     if(U_SUCCESS(status)){
1118         CONFIRM_UErrorCode(status, U_ZERO_ERROR);
1119         CONFIRM_EQ(uintResult, (uint32_t)intResult);
1120         CONFIRM_EQ(intResult, 1);
1121     }
1122
1123     res = theBundle.get("onehundredtwentythree",status);
1124     CONFIRM_UErrorCode(status, U_ZERO_ERROR);
1125     CONFIRM_EQ(res.getType(), URES_INT);
1126     intResult=res.getInt(status);
1127     if(U_SUCCESS(status)){
1128         CONFIRM_UErrorCode(status, U_ZERO_ERROR);
1129         CONFIRM_EQ(intResult, 123);
1130     }
1131
1132     /* this tests if escapes are preserved or not */
1133     {
1134         UnicodeString str = theBundle.getStringEx("testescape",status);
1135         CONFIRM_UErrorCode(status, U_ZERO_ERROR);
1136         if(U_SUCCESS(status)){
1137             u_charsToUChars(expect,uExpect,(int32_t)uprv_strlen(expect)+1);
1138             if(str.compare(uExpect)!=0){
1139                 errln("Did not get the expected string for testescape expected. Expected : "
1140                     +UnicodeString(uExpect )+ " Got: " + str);
1141             }
1142         }
1143     }
1144     /* test for jitterbug#1435 */
1145     {
1146         UnicodeString str = theBundle.getStringEx("test_underscores",status);
1147         expect ="test message ....";
1148         CONFIRM_UErrorCode(status, U_ZERO_ERROR);
1149         u_charsToUChars(expect,uExpect,(int32_t)uprv_strlen(expect)+1);
1150         if(str.compare(uExpect)!=0){
1151             errln("Did not get the expected string for test_underscores.\n");
1152         }
1153     }
1154
1155
1156 }
1157
1158 void
1159 NewResourceBundleTest::TestGetByFallback() {
1160     UErrorCode status = U_ZERO_ERROR;
1161
1162     ResourceBundle heRes(NULL, "he", status);
1163
1164     heRes.getWithFallback("calendar", status).getWithFallback("islamic-civil", status).getWithFallback("DateTime", status);
1165     if(U_SUCCESS(status)) {
1166         errln("he locale's Islamic-civil DateTime resource exists. How did it get here?\n");
1167     }
1168     status = U_ZERO_ERROR;
1169
1170     heRes.getWithFallback("calendar", status).getWithFallback("islamic-civil", status).getWithFallback("eras", status);
1171     if(U_FAILURE(status)) {
1172         dataerrln("Didn't get Islamic Eras. I know they are there! - %s", u_errorName(status));
1173     }
1174     status = U_ZERO_ERROR;
1175
1176     ResourceBundle rootRes(NULL, "root", status);
1177     rootRes.getWithFallback("calendar", status).getWithFallback("islamic-civil", status).getWithFallback("DateTime", status);
1178     if(U_SUCCESS(status)) {
1179         errln("Root's Islamic-civil's DateTime resource exists. How did it get here?\n");
1180     }
1181     status = U_ZERO_ERROR;
1182
1183 }
1184 //eof
1185