1/******************************************************************** 2 * COPYRIGHT: 3 * Copyright (c) 1997-2010, International Business Machines Corporation and 4 * others. All Rights Reserved. 5 ********************************************************************/ 6/******************************************************************************* 7* 8* File CRESTST.C 9* 10* Modification History: 11* Name Description 12* Madhu Katragadda Ported for C API 13* 06/14/99 stephen Updated for RB API changes (no suffix). 14******************************************************************************** 15*/ 16 17 18#include "unicode/utypes.h" 19#include "cintltst.h" 20#include "unicode/ustring.h" 21#include "cstring.h" 22#include "filestrm.h" 23#include <stdlib.h> 24 25#define RESTEST_HEAP_CHECK 0 26 27#include "unicode/ures.h" 28#include "crestst.h" 29#include "unicode/ctest.h" 30 31#include "ucol_imp.h" /* collation */ 32 33#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) 34 35static void TestOpenDirect(void); 36static void TestFallback(void); 37static void TestTable32(void); 38static void TestFileStream(void); 39/*****************************************************************************/ 40 41const UChar kERROR[] = { 0x0045 /*E*/, 0x0052 /*'R'*/, 0x0052 /*'R'*/, 42 0x004F /*'O'*/, 0x0052/*'R'*/, 0x0000 /*'\0'*/}; 43 44/*****************************************************************************/ 45 46enum E_Where 47{ 48 e_Root, 49 e_te, 50 e_te_IN, 51 e_Where_count 52}; 53typedef enum E_Where E_Where; 54/*****************************************************************************/ 55 56#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)); } 57 58#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)); } 59 60 61/* Array of our test objects */ 62 63static struct 64{ 65 const char* name; 66 UErrorCode expected_constructor_status; 67 E_Where where; 68 UBool like[e_Where_count]; 69 UBool inherits[e_Where_count]; 70} param[] = 71{ 72 /* "te" means test */ 73 /* "IN" means inherits */ 74 /* "NE" or "ne" means "does not exist" */ 75 76 { "root", U_ZERO_ERROR, e_Root, { TRUE, FALSE, FALSE }, { TRUE, FALSE, FALSE } }, 77 { "te", U_ZERO_ERROR, e_te, { FALSE, TRUE, FALSE }, { TRUE, TRUE, FALSE } }, 78 { "te_IN", U_ZERO_ERROR, e_te_IN, { FALSE, FALSE, TRUE }, { TRUE, TRUE, TRUE } }, 79 { "te_NE", U_USING_FALLBACK_WARNING, e_te, { FALSE, TRUE, FALSE }, { TRUE, TRUE, FALSE } }, 80 { "te_IN_NE", U_USING_FALLBACK_WARNING, e_te_IN, { FALSE, FALSE, TRUE }, { TRUE, TRUE, TRUE } }, 81 { "ne", U_USING_DEFAULT_WARNING, e_Root, { TRUE, FALSE, FALSE }, { TRUE, FALSE, FALSE } } 82}; 83 84static int32_t bundles_count = sizeof(param) / sizeof(param[0]); 85 86 87 88/***************************************************************************************/ 89 90/* Array of our test objects */ 91 92void addResourceBundleTest(TestNode** root); 93 94void addResourceBundleTest(TestNode** root) 95{ 96#if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION 97 addTest(root, &TestConstruction1, "tsutil/crestst/TestConstruction1"); 98 addTest(root, &TestOpenDirect, "tsutil/crestst/TestOpenDirect"); 99 addTest(root, &TestResourceBundles, "tsutil/crestst/TestResourceBundles"); 100 addTest(root, &TestTable32, "tsutil/crestst/TestTable32"); 101 addTest(root, &TestFileStream, "tsutil/crestst/TestFileStream"); 102 addTest(root, &TestGetSize, "tsutil/crestst/TestGetSize"); 103 addTest(root, &TestGetLocaleByType, "tsutil/crestst/TestGetLocaleByType"); 104#endif 105 addTest(root, &TestFallback, "tsutil/crestst/TestFallback"); 106 addTest(root, &TestAliasConflict, "tsutil/crestst/TestAliasConflict"); 107 108} 109 110 111/***************************************************************************************/ 112void TestAliasConflict(void) { 113 UErrorCode status = U_ZERO_ERROR; 114 UResourceBundle *he = NULL; 115 UResourceBundle *iw = NULL; 116 const UChar *result = NULL; 117 int32_t resultLen; 118 119 he = ures_open(NULL, "he", &status); 120 iw = ures_open(NULL, "iw", &status); 121 if(U_FAILURE(status)) { 122 log_err_status(status, "Failed to get resource with %s\n", myErrorName(status)); 123 } 124 ures_close(iw); 125 result = ures_getStringByKey(he, "ExemplarCharacters", &resultLen, &status); 126 if(U_FAILURE(status) || result == NULL) { 127 log_err_status(status, "Failed to get resource with %s\n", myErrorName(status)); 128 } 129 ures_close(he); 130} 131 132 133void TestResourceBundles() 134{ 135 UErrorCode status = U_ZERO_ERROR; 136 loadTestData(&status); 137 if(U_FAILURE(status)) { 138 log_data_err("Could not load testdata.dat, status = %s\n", u_errorName(status)); 139 return; 140 } 141 142 testTag("only_in_Root", TRUE, FALSE, FALSE); 143 testTag("in_Root_te", TRUE, TRUE, FALSE); 144 testTag("in_Root_te_te_IN", TRUE, TRUE, TRUE); 145 testTag("in_Root_te_IN", TRUE, FALSE, TRUE); 146 testTag("only_in_te", FALSE, TRUE, FALSE); 147 testTag("only_in_te_IN", FALSE, FALSE, TRUE); 148 testTag("in_te_te_IN", FALSE, TRUE, TRUE); 149 testTag("nonexistent", FALSE, FALSE, FALSE); 150 151 log_verbose("Passed:= %d Failed= %d \n", pass, fail); 152} 153 154void TestConstruction1() 155{ 156 UResourceBundle *test1 = 0, *test2 = 0; 157 const UChar *result1, *result2; 158 int32_t resultLen; 159 UChar temp[7]; 160 161 UErrorCode err = U_ZERO_ERROR; 162 const char* testdatapath ; 163 const char* locale="te_IN"; 164 165 log_verbose("Testing ures_open()......\n"); 166 167 168 testdatapath=loadTestData(&err); 169 if(U_FAILURE(err)) 170 { 171 log_data_err("Could not load testdata.dat %s \n",myErrorName(err)); 172 return; 173 } 174 175 test1=ures_open(testdatapath, NULL, &err); 176 if(U_FAILURE(err)) 177 { 178 log_err("construction of %s did not succeed : %s \n",NULL, myErrorName(err)); 179 return; 180 } 181 182 183 test2=ures_open(testdatapath, locale, &err); 184 if(U_FAILURE(err)) 185 { 186 log_err("construction of %s did not succeed : %s \n",locale, myErrorName(err)); 187 return; 188 } 189 result1= ures_getStringByKey(test1, "string_in_Root_te_te_IN", &resultLen, &err); 190 result2= ures_getStringByKey(test2, "string_in_Root_te_te_IN", &resultLen, &err); 191 192 193 if (U_FAILURE(err)) { 194 log_err("Something threw an error in TestConstruction(): %s\n", myErrorName(err)); 195 return; 196 } 197 198 u_uastrcpy(temp, "TE_IN"); 199 200 if(u_strcmp(result2, temp)!=0) 201 { 202 int n; 203 204 log_err("Construction test failed for ures_open();\n"); 205 if(!getTestOption(VERBOSITY_OPTION)) 206 log_info("(run verbose for more information)\n"); 207 208 log_verbose("\nGot->"); 209 for(n=0;result2[n];n++) 210 { 211 log_verbose("%04X ",result2[n]); 212 } 213 log_verbose("<\n"); 214 215 log_verbose("\nWant>"); 216 for(n=0;temp[n];n++) 217 { 218 log_verbose("%04X ",temp[n]); 219 } 220 log_verbose("<\n"); 221 222 } 223 224 log_verbose("for string_in_Root_te_te_IN, default.txt had %s\n", austrdup(result1)); 225 log_verbose("for string_in_Root_te_te_IN, te_IN.txt had %s\n", austrdup(result2)); 226 227 /* Test getVersionNumber*/ 228 log_verbose("Testing version number\n"); 229 log_verbose("for getVersionNumber : %s\n", ures_getVersionNumber(test1)); 230 231 ures_close(test1); 232 ures_close(test2); 233} 234 235/*****************************************************************************/ 236/*****************************************************************************/ 237 238UBool testTag(const char* frag, 239 UBool in_Root, 240 UBool in_te, 241 UBool in_te_IN) 242{ 243 int32_t passNum=pass; 244 245 /* Make array from input params */ 246 247 UBool is_in[3]; 248 const char *NAME[] = { "ROOT", "TE", "TE_IN" }; 249 250 /* Now try to load the desired items */ 251 UResourceBundle* theBundle = NULL; 252 char tag[99]; 253 char action[256]; 254 UErrorCode status = U_ZERO_ERROR,expected_resource_status = U_ZERO_ERROR; 255 UChar* base = NULL; 256 UChar* expected_string = NULL; 257 const UChar* string = NULL; 258 char item_tag[10]; 259 int32_t i,j; 260 int32_t actual_bundle; 261 int32_t resultLen; 262 const char *testdatapath = loadTestData(&status); 263 264 is_in[0] = in_Root; 265 is_in[1] = in_te; 266 is_in[2] = in_te_IN; 267 268 strcpy(item_tag, "tag"); 269 270 status = U_ZERO_ERROR; 271 theBundle = ures_open(testdatapath, "root", &status); 272 if(U_FAILURE(status)) 273 { 274 ures_close(theBundle); 275 log_err("Couldn't open root bundle in %s", testdatapath); 276 return FALSE; 277 } 278 ures_close(theBundle); 279 theBundle = NULL; 280 281 282 for (i=0; i<bundles_count; ++i) 283 { 284 strcpy(action,"construction for"); 285 strcat(action, param[i].name); 286 287 288 status = U_ZERO_ERROR; 289 290 theBundle = ures_open(testdatapath, param[i].name, &status); 291 /*theBundle = ures_open("c:\\icu\\icu\\source\\test\\testdata\\testdata", param[i].name, &status);*/ 292 293 CONFIRM_ErrorCode(status,param[i].expected_constructor_status); 294 295 296 297 if(i == 5) 298 actual_bundle = 0; /* ne -> default */ 299 else if(i == 3) 300 actual_bundle = 1; /* te_NE -> te */ 301 else if(i == 4) 302 actual_bundle = 2; /* te_IN_NE -> te_IN */ 303 else 304 actual_bundle = i; 305 306 expected_resource_status = U_MISSING_RESOURCE_ERROR; 307 for (j=e_te_IN; j>=e_Root; --j) 308 { 309 if (is_in[j] && param[i].inherits[j]) 310 { 311 312 if(j == actual_bundle) /* it's in the same bundle OR it's a nonexistent=default bundle (5) */ 313 expected_resource_status = U_ZERO_ERROR; 314 else if(j == 0) 315 expected_resource_status = U_USING_DEFAULT_WARNING; 316 else 317 expected_resource_status = U_USING_FALLBACK_WARNING; 318 319 log_verbose("%s[%d]::%s: in<%d:%s> inherits<%d:%s>. actual_bundle=%s\n", 320 param[i].name, 321 i, 322 frag, 323 j, 324 is_in[j]?"Yes":"No", 325 j, 326 param[i].inherits[j]?"Yes":"No", 327 param[actual_bundle].name); 328 329 break; 330 } 331 } 332 333 for (j=param[i].where; j>=0; --j) 334 { 335 if (is_in[j]) 336 { 337 if(base != NULL) { 338 free(base); 339 base = NULL; 340 } 341 342 base=(UChar*)malloc(sizeof(UChar)*(strlen(NAME[j]) + 1)); 343 u_uastrcpy(base,NAME[j]); 344 345 break; 346 } 347 else { 348 if(base != NULL) { 349 free(base); 350 base = NULL; 351 } 352 base = (UChar*) malloc(sizeof(UChar) * 1); 353 *base = 0x0000; 354 } 355 } 356 357 /*-------------------------------------------------------------------- */ 358 /* string */ 359 360 strcpy(tag,"string_"); 361 strcat(tag,frag); 362 363 strcpy(action,param[i].name); 364 strcat(action, ".ures_get(" ); 365 strcat(action,tag); 366 strcat(action, ")"); 367 368 string= kERROR; 369 370 status = U_ZERO_ERROR; 371 372 ures_getStringByKey(theBundle, tag, &resultLen, &status); 373 if(U_SUCCESS(status)) 374 { 375 status = U_ZERO_ERROR; 376 string=ures_getStringByKey(theBundle, tag, &resultLen, &status); 377 } 378 379 log_verbose("%s got %d, expected %d\n", action, status, expected_resource_status); 380 381 CONFIRM_ErrorCode(status, expected_resource_status); 382 383 384 if(U_SUCCESS(status)){ 385 expected_string=(UChar*)malloc(sizeof(UChar)*(u_strlen(base) + 3)); 386 u_strcpy(expected_string,base); 387 388 } 389 else 390 { 391 expected_string = (UChar*)malloc(sizeof(UChar)*(u_strlen(kERROR) + 1)); 392 u_strcpy(expected_string,kERROR); 393 394 } 395 396 CONFIRM_EQ(string, expected_string); 397 398 free(expected_string); 399 ures_close(theBundle); 400 } 401 free(base); 402 return (UBool)(passNum == pass); 403} 404 405void record_pass() 406{ 407 ++pass; 408} 409 410void record_fail() 411{ 412 ++fail; 413} 414 415/** 416 * Test to make sure that the U_USING_FALLBACK_ERROR and U_USING_DEFAULT_ERROR 417 * are set correctly 418 */ 419 420static void TestFallback() 421{ 422 UErrorCode status = U_ZERO_ERROR; 423 UResourceBundle *fr_FR = NULL; 424 UResourceBundle *subResource = NULL; 425 const UChar *junk; /* ignored */ 426 int32_t resultLen; 427 428 log_verbose("Opening fr_FR.."); 429 fr_FR = ures_open(NULL, "fr_FR", &status); 430 if(U_FAILURE(status)) 431 { 432 log_err_status(status, "Couldn't open fr_FR - %s\n", u_errorName(status)); 433 return; 434 } 435 436 status = U_ZERO_ERROR; 437 438 439 /* clear it out.. just do some calls to get the gears turning */ 440 junk = ures_getStringByKey(fr_FR, "LocaleID", &resultLen, &status); 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, "MeasurementSystem", NULL, &status); 449 if(status != U_USING_DEFAULT_WARNING) 450 { 451 log_data_err("Expected U_USING_DEFAULT_ERROR when trying to get CurrencyMap 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 470static void 471TestOpenDirect(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 616static int32_t 617parseTable32Key(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 631static void 632TestTable32(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<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 769static 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 892static 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 < sizeof(test)/sizeof(test[0]); 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 954static 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 < sizeof(test)/sizeof(test[0]); 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(locale) { 1003 log_err("Requested locale should return NULL\n"); 1004 } 1005 locale = ures_getLocaleByType(res, ULOC_VALID_LOCALE, &status); 1006 if(!locale || strcmp(locale, test[i].validLocale) != 0) { 1007 log_err("Expected valid locale to be %s. Got %s\n", test[i].requestedLocale, locale); 1008 } 1009 locale = ures_getLocaleByType(res, ULOC_ACTUAL_LOCALE, &status); 1010 if(!locale || strcmp(locale, test[i].actualLocale) != 0) { 1011 log_err("Expected actual locale to be %s. Got %s\n", test[i].requestedLocale, locale); 1012 } 1013 ures_close(rb); 1014 } 1015 ures_close(res); 1016} 1017 1018