icuSources/test/intltest/restsnew.cpp

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