1 // Copyright (C) 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 /******************************************************************** 4 * COPYRIGHT: 5 * Copyright (c) 1997-2016, International Business Machines Corporation and 6 * others. All Rights Reserved. 7 ********************************************************************/ 8 /******************************************************************************* 9 * 10 * File CRESTST.C 11 * 12 * Modification History: 13 * Name Description 14 * Madhu Katragadda Ported for C API 15 * 06/14/99 stephen Updated for RB API changes (no suffix). 16 ******************************************************************************** 17 */ 18 19 20 #include "unicode/utypes.h" 21 #include "cintltst.h" 22 #include "unicode/ustring.h" 23 #include "cmemory.h" 24 #include "cstring.h" 25 #include "filestrm.h" 26 #include <stdlib.h> 27 28 #define RESTEST_HEAP_CHECK 0 29 30 #include "unicode/ures.h" 31 #include "crestst.h" 32 #include "unicode/ctest.h" 33 34 static void TestOpenDirect(void); 35 static void TestFallback(void); 36 static void TestTable32(void); 37 static void TestFileStream(void); 38 /*****************************************************************************/ 39 40 const UChar kERROR[] = { 0x0045 /*E*/, 0x0052 /*'R'*/, 0x0052 /*'R'*/, 41 0x004F /*'O'*/, 0x0052/*'R'*/, 0x0000 /*'\0'*/}; 42 43 /*****************************************************************************/ 44 45 enum E_Where 46 { 47 e_Root, 48 e_te, 49 e_te_IN, 50 e_Where_count 51 }; 52 typedef enum E_Where E_Where; 53 /*****************************************************************************/ 54 55 #define CONFIRM_EQ(actual,expected) if (u_strcmp(expected,actual)==0){ record_pass(); } else { record_fail(); log_err("%s returned %s instead of %s\n", action, austrdup(actual), austrdup(expected)); } 56 57 #define CONFIRM_ErrorCode(actual,expected) if ((expected)==(actual)) { record_pass(); } else { record_fail(); log_err("%s returned %s instead of %s\n", action, myErrorName(actual), myErrorName(expected)); } 58 59 60 /* Array of our test objects */ 61 62 static struct 63 { 64 const char* name; 65 UErrorCode expected_constructor_status; 66 E_Where where; 67 UBool like[e_Where_count]; 68 UBool inherits[e_Where_count]; 69 } param[] = 70 { 71 /* "te" means test */ 72 /* "IN" means inherits */ 73 /* "NE" or "ne" means "does not exist" */ 74 75 { "root", U_ZERO_ERROR, e_Root, { TRUE, FALSE, FALSE }, { TRUE, FALSE, FALSE } }, 76 { "te", U_ZERO_ERROR, e_te, { FALSE, TRUE, FALSE }, { TRUE, TRUE, FALSE } }, 77 { "te_IN", U_ZERO_ERROR, e_te_IN, { FALSE, FALSE, TRUE }, { TRUE, TRUE, TRUE } }, 78 { "te_NE", U_USING_FALLBACK_WARNING, e_te, { FALSE, TRUE, FALSE }, { TRUE, TRUE, FALSE } }, 79 { "te_IN_NE", U_USING_FALLBACK_WARNING, e_te_IN, { FALSE, FALSE, TRUE }, { TRUE, TRUE, TRUE } }, 80 { "ne", U_USING_DEFAULT_WARNING, e_Root, { TRUE, FALSE, FALSE }, { TRUE, FALSE, FALSE } } 81 }; 82 83 static int32_t bundles_count = UPRV_LENGTHOF(param); 84 85 86 87 /***************************************************************************************/ 88 89 /* Array of our test objects */ 90 91 void addResourceBundleTest(TestNode** root); 92 93 void addResourceBundleTest(TestNode** root) 94 { 95 #if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION 96 addTest(root, &TestConstruction1, "tsutil/crestst/TestConstruction1"); 97 addTest(root, &TestOpenDirect, "tsutil/crestst/TestOpenDirect"); 98 addTest(root, &TestResourceBundles, "tsutil/crestst/TestResourceBundles"); 99 addTest(root, &TestTable32, "tsutil/crestst/TestTable32"); 100 addTest(root, &TestFileStream, "tsutil/crestst/TestFileStream"); 101 addTest(root, &TestGetSize, "tsutil/crestst/TestGetSize"); 102 addTest(root, &TestGetLocaleByType, "tsutil/crestst/TestGetLocaleByType"); 103 #endif 104 addTest(root, &TestFallback, "tsutil/crestst/TestFallback"); 105 addTest(root, &TestAliasConflict, "tsutil/crestst/TestAliasConflict"); 106 107 } 108 109 110 /***************************************************************************************/ 111 void TestAliasConflict(void) { 112 UErrorCode status = U_ZERO_ERROR; 113 UResourceBundle *he = NULL; 114 UResourceBundle *iw = NULL; 115 const UChar *result = NULL; 116 int32_t resultLen; 117 118 he = ures_open(NULL, "he", &status); 119 iw = ures_open(NULL, "iw", &status); 120 if(U_FAILURE(status)) { 121 log_err_status(status, "Failed to get resource with %s\n", myErrorName(status)); 122 } 123 ures_close(iw); 124 result = ures_getStringByKey(he, "ExemplarCharacters", &resultLen, &status); 125 if(U_FAILURE(status) || result == NULL) { 126 log_err_status(status, "Failed to get resource with %s\n", myErrorName(status)); 127 } 128 ures_close(he); 129 } 130 131 132 void TestResourceBundles() 133 { 134 UErrorCode status = U_ZERO_ERROR; 135 loadTestData(&status); 136 if(U_FAILURE(status)) { 137 log_data_err("Could not load testdata.dat, status = %s\n", u_errorName(status)); 138 return; 139 } 140 141 testTag("only_in_Root", TRUE, FALSE, FALSE); 142 testTag("in_Root_te", TRUE, TRUE, FALSE); 143 testTag("in_Root_te_te_IN", TRUE, TRUE, TRUE); 144 testTag("in_Root_te_IN", TRUE, FALSE, TRUE); 145 testTag("only_in_te", FALSE, TRUE, FALSE); 146 testTag("only_in_te_IN", FALSE, FALSE, TRUE); 147 testTag("in_te_te_IN", FALSE, TRUE, TRUE); 148 testTag("nonexistent", FALSE, FALSE, FALSE); 149 150 log_verbose("Passed:= %d Failed= %d \n", pass, fail); 151 } 152 153 void TestConstruction1() 154 { 155 UResourceBundle *test1 = 0, *test2 = 0; 156 const UChar *result1, *result2; 157 int32_t resultLen; 158 UChar temp[7]; 159 160 UErrorCode err = U_ZERO_ERROR; 161 const char* testdatapath ; 162 const char* locale="te_IN"; 163 164 log_verbose("Testing ures_open()......\n"); 165 166 167 testdatapath=loadTestData(&err); 168 if(U_FAILURE(err)) 169 { 170 log_data_err("Could not load testdata.dat %s \n",myErrorName(err)); 171 return; 172 } 173 174 test1=ures_open(testdatapath, NULL, &err); 175 if(U_FAILURE(err)) 176 { 177 log_err("construction of %s did not succeed : %s \n",NULL, myErrorName(err)); 178 return; 179 } 180 181 182 test2=ures_open(testdatapath, locale, &err); 183 if(U_FAILURE(err)) 184 { 185 log_err("construction of %s did not succeed : %s \n",locale, myErrorName(err)); 186 return; 187 } 188 result1= ures_getStringByKey(test1, "string_in_Root_te_te_IN", &resultLen, &err); 189 result2= ures_getStringByKey(test2, "string_in_Root_te_te_IN", &resultLen, &err); 190 191 192 if (U_FAILURE(err)) { 193 log_err("Something threw an error in TestConstruction(): %s\n", myErrorName(err)); 194 return; 195 } 196 197 u_uastrcpy(temp, "TE_IN"); 198 199 if(u_strcmp(result2, temp)!=0) 200 { 201 int n; 202 203 log_err("Construction test failed for ures_open();\n"); 204 if(!getTestOption(VERBOSITY_OPTION)) 205 log_info("(run verbose for more information)\n"); 206 207 log_verbose("\nGot->"); 208 for(n=0;result2[n];n++) 209 { 210 log_verbose("%04X ",result2[n]); 211 } 212 log_verbose("<\n"); 213 214 log_verbose("\nWant>"); 215 for(n=0;temp[n];n++) 216 { 217 log_verbose("%04X ",temp[n]); 218 } 219 log_verbose("<\n"); 220 221 } 222 223 log_verbose("for string_in_Root_te_te_IN, default.txt had %s\n", austrdup(result1)); 224 log_verbose("for string_in_Root_te_te_IN, te_IN.txt had %s\n", austrdup(result2)); 225 226 /* Test getVersionNumber*/ 227 log_verbose("Testing version number\n"); 228 log_verbose("for getVersionNumber : %s\n", ures_getVersionNumber(test1)); 229 230 ures_close(test1); 231 ures_close(test2); 232 } 233 234 /*****************************************************************************/ 235 /*****************************************************************************/ 236 237 UBool testTag(const char* frag, 238 UBool in_Root, 239 UBool in_te, 240 UBool in_te_IN) 241 { 242 int32_t passNum=pass; 243 244 /* Make array from input params */ 245 246 UBool is_in[3]; 247 const char *NAME[] = { "ROOT", "TE", "TE_IN" }; 248 249 /* Now try to load the desired items */ 250 UResourceBundle* theBundle = NULL; 251 char tag[99]; 252 char action[256]; 253 UErrorCode status = U_ZERO_ERROR,expected_resource_status = U_ZERO_ERROR; 254 UChar* base = NULL; 255 UChar* expected_string = NULL; 256 const UChar* string = NULL; 257 char item_tag[10]; 258 int32_t i,j; 259 int32_t actual_bundle; 260 int32_t resultLen; 261 const char *testdatapath = loadTestData(&status); 262 263 is_in[0] = in_Root; 264 is_in[1] = in_te; 265 is_in[2] = in_te_IN; 266 267 strcpy(item_tag, "tag"); 268 269 status = U_ZERO_ERROR; 270 theBundle = ures_open(testdatapath, "root", &status); 271 if(U_FAILURE(status)) 272 { 273 ures_close(theBundle); 274 log_err("Couldn't open root bundle in %s", testdatapath); 275 return FALSE; 276 } 277 ures_close(theBundle); 278 theBundle = NULL; 279 280 281 for (i=0; i<bundles_count; ++i) 282 { 283 strcpy(action,"construction for"); 284 strcat(action, param[i].name); 285 286 287 status = U_ZERO_ERROR; 288 289 theBundle = ures_open(testdatapath, param[i].name, &status); 290 /*theBundle = ures_open("c:\\icu\\icu\\source\\test\\testdata\\testdata", param[i].name, &status);*/ 291 292 CONFIRM_ErrorCode(status,param[i].expected_constructor_status); 293 294 295 296 if(i == 5) 297 actual_bundle = 0; /* ne -> default */ 298 else if(i == 3) 299 actual_bundle = 1; /* te_NE -> te */ 300 else if(i == 4) 301 actual_bundle = 2; /* te_IN_NE -> te_IN */ 302 else 303 actual_bundle = i; 304 305 expected_resource_status = U_MISSING_RESOURCE_ERROR; 306 for (j=e_te_IN; j>=e_Root; --j) 307 { 308 if (is_in[j] && param[i].inherits[j]) 309 { 310 311 if(j == actual_bundle) /* it's in the same bundle OR it's a nonexistent=default bundle (5) */ 312 expected_resource_status = U_ZERO_ERROR; 313 else if(j == 0) 314 expected_resource_status = U_USING_DEFAULT_WARNING; 315 else 316 expected_resource_status = U_USING_FALLBACK_WARNING; 317 318 log_verbose("%s[%d]::%s: in<%d:%s> inherits<%d:%s>. actual_bundle=%s\n", 319 param[i].name, 320 i, 321 frag, 322 j, 323 is_in[j]?"Yes":"No", 324 j, 325 param[i].inherits[j]?"Yes":"No", 326 param[actual_bundle].name); 327 328 break; 329 } 330 } 331 332 for (j=param[i].where; j>=0; --j) 333 { 334 if (is_in[j]) 335 { 336 if(base != NULL) { 337 free(base); 338 base = NULL; 339 } 340 341 base=(UChar*)malloc(sizeof(UChar)*(strlen(NAME[j]) + 1)); 342 u_uastrcpy(base,NAME[j]); 343 344 break; 345 } 346 else { 347 if(base != NULL) { 348 free(base); 349 base = NULL; 350 } 351 base = (UChar*) malloc(sizeof(UChar) * 1); 352 *base = 0x0000; 353 } 354 } 355 356 /*-------------------------------------------------------------------- */ 357 /* string */ 358 359 strcpy(tag,"string_"); 360 strcat(tag,frag); 361 362 strcpy(action,param[i].name); 363 strcat(action, ".ures_get(" ); 364 strcat(action,tag); 365 strcat(action, ")"); 366 367 string= kERROR; 368 369 status = U_ZERO_ERROR; 370 371 ures_getStringByKey(theBundle, tag, &resultLen, &status); 372 if(U_SUCCESS(status)) 373 { 374 status = U_ZERO_ERROR; 375 string=ures_getStringByKey(theBundle, tag, &resultLen, &status); 376 } 377 378 log_verbose("%s got %d, expected %d\n", action, status, expected_resource_status); 379 380 CONFIRM_ErrorCode(status, expected_resource_status); 381 382 383 if(U_SUCCESS(status)){ 384 expected_string=(UChar*)malloc(sizeof(UChar)*(u_strlen(base) + 3)); 385 u_strcpy(expected_string,base); 386 387 } 388 else 389 { 390 expected_string = (UChar*)malloc(sizeof(UChar)*(u_strlen(kERROR) + 1)); 391 u_strcpy(expected_string,kERROR); 392 393 } 394 395 CONFIRM_EQ(string, expected_string); 396 397 free(expected_string); 398 ures_close(theBundle); 399 } 400 free(base); 401 return (UBool)(passNum == pass); 402 } 403 404 void record_pass() 405 { 406 ++pass; 407 } 408 409 void record_fail() 410 { 411 ++fail; 412 } 413 414 /** 415 * Test to make sure that the U_USING_FALLBACK_ERROR and U_USING_DEFAULT_ERROR 416 * are set correctly 417 */ 418 419 static void TestFallback() 420 { 421 UErrorCode status = U_ZERO_ERROR; 422 UResourceBundle *fr_FR = NULL; 423 UResourceBundle *subResource = NULL; 424 const UChar *junk; /* ignored */ 425 int32_t resultLen; 426 427 log_verbose("Opening fr_FR.."); 428 fr_FR = ures_open(NULL, "fr_FR", &status); 429 if(U_FAILURE(status)) 430 { 431 log_err_status(status, "Couldn't open fr_FR - %s\n", u_errorName(status)); 432 return; 433 } 434 435 status = U_ZERO_ERROR; 436 437 438 /* clear it out.. just do some calls to get the gears turning */ 439 junk = ures_getStringByKey(fr_FR, "LocaleID", &resultLen, &status); 440 (void)junk; /* Suppress set but not used warning. */ 441 status = U_ZERO_ERROR; 442 junk = ures_getStringByKey(fr_FR, "LocaleString", &resultLen, &status); 443 status = U_ZERO_ERROR; 444 junk = ures_getStringByKey(fr_FR, "LocaleID", &resultLen, &status); 445 status = U_ZERO_ERROR; 446 447 /* OK first one. This should be a Default value. */ 448 subResource = ures_getByKey(fr_FR, "layout", NULL, &status); 449 if(status != U_USING_DEFAULT_WARNING) 450 { 451 log_data_err("Expected U_USING_DEFAULT_ERROR when trying to get layout from fr_FR, got %s\n", 452 u_errorName(status)); 453 } 454 ures_close(subResource); 455 status = U_ZERO_ERROR; 456 457 /* and this is a Fallback, to fr */ 458 junk = ures_getStringByKey(fr_FR, "ExemplarCharacters", &resultLen, &status); 459 if(status != U_USING_FALLBACK_WARNING) 460 { 461 log_data_err("Expected U_USING_FALLBACK_ERROR when trying to get ExemplarCharacters from fr_FR, got %s\n", 462 u_errorName(status)); 463 } 464 465 status = U_ZERO_ERROR; 466 467 ures_close(fr_FR); 468 } 469 470 static void 471 TestOpenDirect(void) { 472 UResourceBundle *idna_rules, *casing, *te_IN, *ne, *item; 473 UErrorCode errorCode; 474 475 /* 476 * test that ures_openDirect() opens a resource bundle 477 * where one can look up its own items but not fallback items 478 * from root or similar 479 */ 480 errorCode=U_ZERO_ERROR; 481 idna_rules=ures_openDirect(loadTestData(&errorCode), "idna_rules", &errorCode); 482 if(U_FAILURE(errorCode)) { 483 log_data_err("ures_openDirect(\"idna_rules\") failed: %s\n", u_errorName(errorCode)); 484 return; 485 } 486 487 if(0!=uprv_strcmp("idna_rules", ures_getLocale(idna_rules, &errorCode))) { 488 log_err("ures_openDirect(\"idna_rules\").getLocale()!=idna_rules\n"); 489 } 490 errorCode=U_ZERO_ERROR; 491 492 /* try an item in idna_rules, must work */ 493 item=ures_getByKey(idna_rules, "UnassignedSet", NULL, &errorCode); 494 if(U_FAILURE(errorCode)) { 495 log_err("translit_index.getByKey(local key) failed: %s\n", u_errorName(errorCode)); 496 errorCode=U_ZERO_ERROR; 497 } else { 498 ures_close(item); 499 } 500 501 /* try an item in root, must fail */ 502 item=ures_getByKey(idna_rules, "ShortLanguage", NULL, &errorCode); 503 if(U_FAILURE(errorCode)) { 504 errorCode=U_ZERO_ERROR; 505 } else { 506 log_err("idna_rules.getByKey(root key) succeeded!\n"); 507 ures_close(item); 508 } 509 ures_close(idna_rules); 510 511 /* now make sure that "idna_rules" will not work with ures_open() */ 512 errorCode=U_ZERO_ERROR; 513 idna_rules=ures_open("testdata", "idna_rules", &errorCode); 514 if(U_FAILURE(errorCode) || errorCode==U_USING_DEFAULT_WARNING || errorCode==U_USING_FALLBACK_WARNING) { 515 /* falling back to default or root is ok */ 516 errorCode=U_ZERO_ERROR; 517 } else if(0!=uprv_strcmp("idna_rules", ures_getLocale(idna_rules, &errorCode))) { 518 /* Opening this file will work in "files mode" on Windows and the Mac, 519 which have case insensitive file systems */ 520 log_err("ures_open(\"idna_rules\") succeeded, should fail! Got: %s\n", u_errorName(errorCode)); 521 } 522 ures_close(idna_rules); 523 524 /* ures_openDirect("translit_index_WronG") must fail */ 525 idna_rules=ures_openDirect(NULL, "idna_rules_WronG", &errorCode); 526 if(U_FAILURE(errorCode)) { 527 errorCode=U_ZERO_ERROR; 528 } else { 529 log_err("ures_openDirect(\"idna_rules_WronG\") succeeded, should fail!\n"); 530 } 531 ures_close(idna_rules); 532 533 errorCode = U_USING_FALLBACK_WARNING;; 534 idna_rules=ures_openDirect("testdata", "idna_rules", &errorCode); 535 if(U_FAILURE(errorCode)) { 536 log_data_err("ures_openDirect(\"idna_rules\") failed when U_USING_FALLBACK_WARNING was set prior to call: %s\n", u_errorName(errorCode)); 537 return; 538 } 539 ures_close(idna_rules); 540 541 /* 542 * ICU 3.6 has new resource bundle syntax and data for bundles that do not 543 * participate in locale fallback. Now, 544 * - ures_open() works like ures_openDirect() on a bundle with a top-level 545 * type of ":table(nofallback)" _if_ the bundle exists 546 * - ures_open() will continue to find a root bundle if the requested one 547 * does not exist, unlike ures_openDirect() 548 * 549 * Test with a different bundle than above to avoid confusion in the cache. 550 */ 551 552 /* 553 * verify that ures_open("casing"), which now has a nofallback declaration, 554 * does not enable fallbacks 555 */ 556 errorCode=U_ZERO_ERROR; 557 casing=ures_open("testdata", "casing", &errorCode); 558 if(U_FAILURE(errorCode)) { 559 log_data_err("ures_open(\"casing\") failed: %s\n", u_errorName(errorCode)); 560 return; 561 } 562 563 errorCode=U_ZERO_ERROR; 564 item=ures_getByKey(casing, "Info", NULL, &errorCode); 565 if(U_FAILURE(errorCode)) { 566 log_err("casing.getByKey(Info) failed - %s\n", u_errorName(errorCode)); 567 } else { 568 ures_close(item); 569 } 570 571 errorCode=U_ZERO_ERROR; 572 item=ures_getByKey(casing, "ShortLanguage", NULL, &errorCode); 573 if(U_SUCCESS(errorCode)) { 574 log_err("casing.getByKey(root key) succeeded despite nofallback declaration - %s\n", u_errorName(errorCode)); 575 ures_close(item); 576 } 577 ures_close(casing); 578 579 /* 580 * verify that ures_open("ne") finds the root bundle but 581 * ures_openDirect("ne") does not 582 */ 583 errorCode=U_ZERO_ERROR; 584 ne=ures_open("testdata", "ne", &errorCode); 585 if(U_FAILURE(errorCode)) { 586 log_data_err("ures_open(\"ne\") failed (expected to get root): %s\n", u_errorName(errorCode)); 587 } 588 if(errorCode!=U_USING_DEFAULT_WARNING || 0!=uprv_strcmp("root", ures_getLocale(ne, &errorCode))) { 589 log_err("ures_open(\"ne\") found something other than \"root\" - %s\n", u_errorName(errorCode)); 590 } 591 ures_close(ne); 592 593 errorCode=U_ZERO_ERROR; 594 ne=ures_openDirect("testdata", "ne", &errorCode); 595 if(U_SUCCESS(errorCode)) { 596 log_data_err("ures_openDirect(\"ne\") succeeded unexpectedly\n"); 597 ures_close(ne); 598 } 599 600 /* verify that ures_openDirect("te_IN") does not enable fallbacks */ 601 errorCode=U_ZERO_ERROR; 602 te_IN=ures_openDirect("testdata", "te_IN", &errorCode); 603 if(U_FAILURE(errorCode)) { 604 log_data_err("ures_open(\"te_IN\") failed: %s\n", u_errorName(errorCode)); 605 return; 606 } 607 errorCode=U_ZERO_ERROR; 608 item=ures_getByKey(te_IN, "ShortLanguage", NULL, &errorCode); 609 if(U_SUCCESS(errorCode)) { 610 log_err("te_IN.getByKey(root key) succeeded despite use of ures_openDirect() - %s\n", u_errorName(errorCode)); 611 ures_close(item); 612 } 613 ures_close(te_IN); 614 } 615 616 static int32_t 617 parseTable32Key(const char *key) { 618 int32_t number; 619 char c; 620 621 number=0; 622 while((c=*key++)!=0) { 623 number<<=1; 624 if(c=='1') { 625 number|=1; 626 } 627 } 628 return number; 629 } 630 631 static void 632 TestTable32(void) { 633 static const struct { 634 const char *key; 635 int32_t number; 636 } testcases[]={ 637 { "ooooooooooooooooo", 0 }, 638 { "oooooooooooooooo1", 1 }, 639 { "ooooooooooooooo1o", 2 }, 640 { "oo11ooo1ooo11111o", 25150 }, 641 { "oo11ooo1ooo111111", 25151 }, 642 { "o1111111111111111", 65535 }, 643 { "1oooooooooooooooo", 65536 }, 644 { "1ooooooo11o11ooo1", 65969 }, 645 { "1ooooooo11o11oo1o", 65970 }, 646 { "1ooooooo111oo1111", 65999 } 647 }; 648 649 /* ### TODO UResourceBundle staticItem={ 0 }; - need to know the size */ 650 UResourceBundle *res, *item; 651 const UChar *s; 652 const char *key; 653 UErrorCode errorCode; 654 int32_t i, j, number, parsedNumber, length, count; 655 656 errorCode=U_ZERO_ERROR; 657 res=ures_open(loadTestData(&errorCode), "testtable32", &errorCode); 658 if(U_FAILURE(errorCode)) { 659 log_data_err("unable to open testdata/testtable32.res - %s\n", u_errorName(errorCode)); 660 return; 661 } 662 if(ures_getType(res)!=URES_TABLE) { 663 log_data_err("testdata/testtable32.res has type %d instead of URES_TABLE\n", ures_getType(res)); 664 } 665 666 count=ures_getSize(res); 667 if(count!=66000) { 668 log_err("testdata/testtable32.res should have 66000 entries but has %d\n", count); 669 } 670 671 /* get the items by index */ 672 item=NULL; 673 for(i=0; i<count; ++i) { 674 item=ures_getByIndex(res, i, item, &errorCode); 675 if(U_FAILURE(errorCode)) { 676 log_err("unable to get item %d of %d in testdata/testtable32.res - %s\n", 677 i, count, u_errorName(errorCode)); 678 break; 679 } 680 681 key=ures_getKey(item); 682 parsedNumber=parseTable32Key(key); 683 684 switch(ures_getType(item)) { 685 case URES_STRING: 686 s=ures_getString(item, &length, &errorCode); 687 if(U_FAILURE(errorCode) || s==NULL) { 688 log_err("unable to access the string \"%s\" at %d in testdata/testtable32.res - %s\n", 689 key, i, u_errorName(errorCode)); 690 number=-1; 691 } else { 692 j=0; 693 U16_NEXT(s, j, length, number); 694 } 695 break; 696 case URES_INT: 697 number=ures_getInt(item, &errorCode); 698 if(U_FAILURE(errorCode)) { 699 log_err("unable to access the integer \"%s\" at %d in testdata/testtable32.res - %s\n", 700 key, i, u_errorName(errorCode)); 701 number=-1; 702 } 703 break; 704 default: 705 log_err("unexpected resource type %d for \"%s\" at %d in testdata/testtable32.res - %s\n", 706 ures_getType(item), key, i, u_errorName(errorCode)); 707 number=-1; 708 break; 709 } 710 711 if(number>=0 && number!=parsedNumber) { 712 log_err("\"%s\" at %d in testdata/testtable32.res has a string/int value of %d, expected %d\n", 713 key, i, number, parsedNumber); 714 } 715 } 716 717 /* search for some items by key */ 718 for(i=0; i<UPRV_LENGTHOF(testcases); ++i) { 719 item=ures_getByKey(res, testcases[i].key, item, &errorCode); 720 if(U_FAILURE(errorCode)) { 721 log_err("unable to find the key \"%s\" in testdata/testtable32.res - %s\n", 722 testcases[i].key, u_errorName(errorCode)); 723 continue; 724 } 725 726 switch(ures_getType(item)) { 727 case URES_STRING: 728 s=ures_getString(item, &length, &errorCode); 729 if(U_FAILURE(errorCode) || s==NULL) { 730 log_err("unable to access the string \"%s\" in testdata/testtable32.res - %s\n", 731 testcases[i].key, u_errorName(errorCode)); 732 number=-1; 733 } else { 734 j=0; 735 U16_NEXT(s, j, length, number); 736 } 737 break; 738 case URES_INT: 739 number=ures_getInt(item, &errorCode); 740 if(U_FAILURE(errorCode)) { 741 log_err("unable to access the integer \"%s\" in testdata/testtable32.res - %s\n", 742 testcases[i].key, u_errorName(errorCode)); 743 number=-1; 744 } 745 break; 746 default: 747 log_err("unexpected resource type %d for \"%s\" in testdata/testtable32.res - %s\n", 748 ures_getType(item), testcases[i].key, u_errorName(errorCode)); 749 number=-1; 750 break; 751 } 752 753 if(number>=0 && number!=testcases[i].number) { 754 log_err("\"%s\" in testdata/testtable32.res has a string/int value of %d, expected %d\n", 755 testcases[i].key, number, testcases[i].number); 756 } 757 758 key=ures_getKey(item); 759 if(0!=uprv_strcmp(key, testcases[i].key)) { 760 log_err("\"%s\" in testdata/testtable32.res claims to have the key \"%s\"\n", 761 testcases[i].key, key); 762 } 763 } 764 765 ures_close(item); 766 ures_close(res); 767 } 768 769 static void TestFileStream(void){ 770 int32_t c = 0; 771 int32_t c1=0; 772 UErrorCode status = U_ZERO_ERROR; 773 const char* testdatapath = loadTestData(&status); 774 char* fileName = (char*) malloc(uprv_strlen(testdatapath) +10); 775 FileStream* stream = NULL; 776 /* these should not be closed */ 777 FileStream* pStdin = T_FileStream_stdin(); 778 FileStream* pStdout = T_FileStream_stdout(); 779 FileStream* pStderr = T_FileStream_stderr(); 780 781 const char* testline = "This is a test line"; 782 int32_t bufLen = (int32_t)strlen(testline)+10; 783 char* buf = (char*) malloc(bufLen); 784 int32_t retLen = 0; 785 786 if(pStdin==NULL){ 787 log_err("failed to get T_FileStream_stdin()"); 788 } 789 if(pStdout==NULL){ 790 log_err("failed to get T_FileStream_stdout()"); 791 } 792 if(pStderr==NULL){ 793 log_err("failed to get T_FileStream_stderr()"); 794 } 795 796 uprv_strcpy(fileName,testdatapath); 797 uprv_strcat(fileName,".dat"); 798 stream = T_FileStream_open(fileName, "r"); 799 if(stream==NULL){ 800 log_data_err("T_FileStream_open failed to open %s\n",fileName); 801 } else { 802 if(!T_FileStream_file_exists(fileName)){ 803 log_data_err("T_FileStream_file_exists failed to verify existence of %s \n",fileName); 804 } 805 806 retLen=T_FileStream_read(stream,&c,1); 807 if(retLen==0){ 808 log_data_err("T_FileStream_read failed to read from %s \n",fileName); 809 } 810 retLen=0; 811 T_FileStream_rewind(stream); 812 T_FileStream_read(stream,&c1,1); 813 if(c!=c1){ 814 log_data_err("T_FileStream_rewind failed to rewind %s \n",fileName); 815 } 816 T_FileStream_rewind(stream); 817 c1 = T_FileStream_peek(stream); 818 if(c!=c1){ 819 log_data_err("T_FileStream_peek failed to peekd %s \n",fileName); 820 } 821 c = T_FileStream_getc(stream); 822 T_FileStream_ungetc(c,stream); 823 if(c!= T_FileStream_getc(stream)){ 824 log_data_err("T_FileStream_ungetc failed to d %s \n",fileName); 825 } 826 827 if(T_FileStream_size(stream)<=0){ 828 log_data_err("T_FileStream_size failed to d %s \n",fileName); 829 } 830 if(T_FileStream_error(stream)){ 831 log_data_err("T_FileStream_error shouldn't have an error %s\n",fileName); 832 } 833 if(!T_FileStream_error(NULL)){ 834 log_err("T_FileStream_error didn't get an error %s\n",fileName); 835 } 836 T_FileStream_putc(stream, 0x20); 837 if(!T_FileStream_error(stream)){ 838 /* 839 Warning 840 writing to a read-only file may not consistently fail on all platforms 841 (e.g. HP-UX, FreeBSD, MacOSX) 842 */ 843 log_verbose("T_FileStream_error didn't get an error when writing to a readonly file %s\n",fileName); 844 } 845 846 T_FileStream_close(stream); 847 } 848 /* test writing function */ 849 stream=NULL; 850 uprv_strcpy(fileName,testdatapath); 851 uprv_strcat(fileName,".tmp"); 852 stream = T_FileStream_open(fileName,"w+"); 853 854 if(stream == NULL){ 855 log_data_err("Could not open %s for writing\n",fileName); 856 } else { 857 c= '$'; 858 T_FileStream_putc(stream,c); 859 T_FileStream_rewind(stream); 860 if(c != T_FileStream_getc(stream)){ 861 log_data_err("T_FileStream_putc failed %s\n",fileName); 862 } 863 864 T_FileStream_rewind(stream); 865 T_FileStream_writeLine(stream,testline); 866 T_FileStream_rewind(stream); 867 T_FileStream_readLine(stream,buf,bufLen); 868 if(uprv_strncmp(testline, buf,uprv_strlen(buf))!=0){ 869 log_data_err("T_FileStream_writeLine failed %s\n",fileName); 870 } 871 872 T_FileStream_rewind(stream); 873 T_FileStream_write(stream,testline,(int32_t)strlen(testline)); 874 T_FileStream_rewind(stream); 875 retLen = T_FileStream_read(stream, buf, bufLen); 876 if(uprv_strncmp(testline, buf,retLen)!=0){ 877 log_data_err("T_FileStream_write failed %s\n",fileName); 878 } 879 880 T_FileStream_close(stream); 881 } 882 if(!T_FileStream_remove(fileName)){ 883 log_data_err("T_FileStream_remove failed to delete %s\n",fileName); 884 } 885 886 887 free(fileName); 888 free(buf); 889 890 } 891 892 static void TestGetSize(void) { 893 const struct { 894 const char* key; 895 int32_t size; 896 } test[] = { 897 { "zerotest", 1}, 898 { "one", 1}, 899 { "importtest", 1}, 900 { "integerarray", 1}, 901 { "emptyarray", 0}, 902 { "emptytable", 0}, 903 { "emptystring", 1}, /* empty string is still a string */ 904 { "emptyint", 1}, 905 { "emptybin", 1}, 906 { "testinclude", 1}, 907 { "collations", 1}, /* not 2 - there is hidden %%CollationBin */ 908 }; 909 910 UErrorCode status = U_ZERO_ERROR; 911 912 UResourceBundle *rb = NULL; 913 UResourceBundle *res = NULL; 914 UResourceBundle *helper = NULL; 915 const char* testdatapath = loadTestData(&status); 916 int32_t i = 0, j = 0; 917 int32_t size = 0; 918 919 if(U_FAILURE(status)) 920 { 921 log_data_err("Could not load testdata.dat %s\n", u_errorName(status)); 922 return; 923 } 924 925 rb = ures_open(testdatapath, "testtypes", &status); 926 if(U_FAILURE(status)) 927 { 928 log_err("Could not testtypes resource bundle %s\n", u_errorName(status)); 929 return; 930 } 931 932 for(i = 0; i < UPRV_LENGTHOF(test); i++) { 933 res = ures_getByKey(rb, test[i].key, res, &status); 934 if(U_FAILURE(status)) 935 { 936 log_err("Couldn't find the key %s. Error: %s\n", test[i].key, u_errorName(status)); 937 ures_close(rb); 938 return; 939 } 940 size = ures_getSize(res); 941 if(size != test[i].size) { 942 log_err("Expected size %i, got size %i for key %s\n", test[i].size, size, test[i].key); 943 for(j = 0; j < size; j++) { 944 helper = ures_getByIndex(res, j, helper, &status); 945 log_err("%s\n", ures_getKey(helper)); 946 } 947 } 948 } 949 ures_close(helper); 950 ures_close(res); 951 ures_close(rb); 952 } 953 954 static void TestGetLocaleByType(void) { 955 static const struct { 956 const char *requestedLocale; 957 const char *resourceKey; 958 const char *validLocale; 959 const char *actualLocale; 960 } test[] = { 961 { "te_IN_BLAH", "string_only_in_te_IN", "te_IN", "te_IN" }, 962 { "te_IN_BLAH", "string_only_in_te", "te_IN", "te" }, 963 { "te_IN_BLAH", "string_only_in_Root", "te_IN", "root" }, 964 { "te_IN_BLAH_01234567890_01234567890_01234567890_01234567890_01234567890_01234567890", "array_2d_only_in_Root", "te_IN", "root" }, 965 { "te_IN_BLAH@currency=euro", "array_2d_only_in_te_IN", "te_IN", "te_IN" }, 966 { "te_IN_BLAH@collation=phonebook;calendar=thai", "array_2d_only_in_te", "te_IN", "te" } 967 }; 968 969 UErrorCode status = U_ZERO_ERROR; 970 971 UResourceBundle *rb = NULL; 972 UResourceBundle *res = NULL; 973 const char* testdatapath = loadTestData(&status); 974 int32_t i = 0; 975 const char *locale = NULL; 976 977 if(U_FAILURE(status)) 978 { 979 log_data_err("Could not load testdata.dat %s\n", u_errorName(status)); 980 return; 981 } 982 983 for(i = 0; i < UPRV_LENGTHOF(test); i++) { 984 rb = ures_open(testdatapath, test[i].requestedLocale, &status); 985 if(U_FAILURE(status)) 986 { 987 log_err("Could not open resource bundle %s (error %s)\n", test[i].requestedLocale, u_errorName(status)); 988 status = U_ZERO_ERROR; 989 continue; 990 } 991 992 res = ures_getByKey(rb, test[i].resourceKey, res, &status); 993 if(U_FAILURE(status)) 994 { 995 log_err("Couldn't find the key %s. Error: %s\n", test[i].resourceKey, u_errorName(status)); 996 ures_close(rb); 997 status = U_ZERO_ERROR; 998 continue; 999 } 1000 1001 locale = ures_getLocaleByType(res, ULOC_REQUESTED_LOCALE, &status); 1002 if(U_SUCCESS(status) && locale != NULL) { 1003 log_err("Requested locale should return NULL\n"); 1004 } 1005 status = U_ZERO_ERROR; 1006 locale = ures_getLocaleByType(res, ULOC_VALID_LOCALE, &status); 1007 if(!locale || strcmp(locale, test[i].validLocale) != 0) { 1008 log_err("Expected valid locale to be %s. Got %s\n", test[i].requestedLocale, locale); 1009 } 1010 locale = ures_getLocaleByType(res, ULOC_ACTUAL_LOCALE, &status); 1011 if(!locale || strcmp(locale, test[i].actualLocale) != 0) { 1012 log_err("Expected actual locale to be %s. Got %s\n", test[i].requestedLocale, locale); 1013 } 1014 ures_close(rb); 1015 } 1016 ures_close(res); 1017 } 1018
