1/******************************************************************** 2 * COPYRIGHT: 3 * Copyright (c) 1997-2013, 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 (void)junk; /* Suppress set but not used warning. */ 442 status = U_ZERO_ERROR; 443 junk = ures_getStringByKey(fr_FR, "LocaleString", &resultLen, &status); 444 status = U_ZERO_ERROR; 445 junk = ures_getStringByKey(fr_FR, "LocaleID", &resultLen, &status); 446 status = U_ZERO_ERROR; 447 448 /* OK first one. This should be a Default value. */ 449 subResource = ures_getByKey(fr_FR, "layout", NULL, &status); 450 if(status != U_USING_DEFAULT_WARNING) 451 { 452 log_data_err("Expected U_USING_DEFAULT_ERROR when trying to get layout from fr_FR, got %s\n", 453 u_errorName(status)); 454 } 455 ures_close(subResource); 456 status = U_ZERO_ERROR; 457 458 /* and this is a Fallback, to fr */ 459 junk = ures_getStringByKey(fr_FR, "ExemplarCharacters", &resultLen, &status); 460 if(status != U_USING_FALLBACK_WARNING) 461 { 462 log_data_err("Expected U_USING_FALLBACK_ERROR when trying to get ExemplarCharacters from fr_FR, got %s\n", 463 u_errorName(status)); 464 } 465 466 status = U_ZERO_ERROR; 467 468 ures_close(fr_FR); 469} 470 471static void 472TestOpenDirect(void) { 473 UResourceBundle *idna_rules, *casing, *te_IN, *ne, *item; 474 UErrorCode errorCode; 475 476 /* 477 * test that ures_openDirect() opens a resource bundle 478 * where one can look up its own items but not fallback items 479 * from root or similar 480 */ 481 errorCode=U_ZERO_ERROR; 482 idna_rules=ures_openDirect(loadTestData(&errorCode), "idna_rules", &errorCode); 483 if(U_FAILURE(errorCode)) { 484 log_data_err("ures_openDirect(\"idna_rules\") failed: %s\n", u_errorName(errorCode)); 485 return; 486 } 487 488 if(0!=uprv_strcmp("idna_rules", ures_getLocale(idna_rules, &errorCode))) { 489 log_err("ures_openDirect(\"idna_rules\").getLocale()!=idna_rules\n"); 490 } 491 errorCode=U_ZERO_ERROR; 492 493 /* try an item in idna_rules, must work */ 494 item=ures_getByKey(idna_rules, "UnassignedSet", NULL, &errorCode); 495 if(U_FAILURE(errorCode)) { 496 log_err("translit_index.getByKey(local key) failed: %s\n", u_errorName(errorCode)); 497 errorCode=U_ZERO_ERROR; 498 } else { 499 ures_close(item); 500 } 501 502 /* try an item in root, must fail */ 503 item=ures_getByKey(idna_rules, "ShortLanguage", NULL, &errorCode); 504 if(U_FAILURE(errorCode)) { 505 errorCode=U_ZERO_ERROR; 506 } else { 507 log_err("idna_rules.getByKey(root key) succeeded!\n"); 508 ures_close(item); 509 } 510 ures_close(idna_rules); 511 512 /* now make sure that "idna_rules" will not work with ures_open() */ 513 errorCode=U_ZERO_ERROR; 514 idna_rules=ures_open("testdata", "idna_rules", &errorCode); 515 if(U_FAILURE(errorCode) || errorCode==U_USING_DEFAULT_WARNING || errorCode==U_USING_FALLBACK_WARNING) { 516 /* falling back to default or root is ok */ 517 errorCode=U_ZERO_ERROR; 518 } else if(0!=uprv_strcmp("idna_rules", ures_getLocale(idna_rules, &errorCode))) { 519 /* Opening this file will work in "files mode" on Windows and the Mac, 520 which have case insensitive file systems */ 521 log_err("ures_open(\"idna_rules\") succeeded, should fail! Got: %s\n", u_errorName(errorCode)); 522 } 523 ures_close(idna_rules); 524 525 /* ures_openDirect("translit_index_WronG") must fail */ 526 idna_rules=ures_openDirect(NULL, "idna_rules_WronG", &errorCode); 527 if(U_FAILURE(errorCode)) { 528 errorCode=U_ZERO_ERROR; 529 } else { 530 log_err("ures_openDirect(\"idna_rules_WronG\") succeeded, should fail!\n"); 531 } 532 ures_close(idna_rules); 533 534 errorCode = U_USING_FALLBACK_WARNING;; 535 idna_rules=ures_openDirect("testdata", "idna_rules", &errorCode); 536 if(U_FAILURE(errorCode)) { 537 log_data_err("ures_openDirect(\"idna_rules\") failed when U_USING_FALLBACK_WARNING was set prior to call: %s\n", u_errorName(errorCode)); 538 return; 539 } 540 ures_close(idna_rules); 541 542 /* 543 * ICU 3.6 has new resource bundle syntax and data for bundles that do not 544 * participate in locale fallback. Now, 545 * - ures_open() works like ures_openDirect() on a bundle with a top-level 546 * type of ":table(nofallback)" _if_ the bundle exists 547 * - ures_open() will continue to find a root bundle if the requested one 548 * does not exist, unlike ures_openDirect() 549 * 550 * Test with a different bundle than above to avoid confusion in the cache. 551 */ 552 553 /* 554 * verify that ures_open("casing"), which now has a nofallback declaration, 555 * does not enable fallbacks 556 */ 557 errorCode=U_ZERO_ERROR; 558 casing=ures_open("testdata", "casing", &errorCode); 559 if(U_FAILURE(errorCode)) { 560 log_data_err("ures_open(\"casing\") failed: %s\n", u_errorName(errorCode)); 561 return; 562 } 563 564 errorCode=U_ZERO_ERROR; 565 item=ures_getByKey(casing, "Info", NULL, &errorCode); 566 if(U_FAILURE(errorCode)) { 567 log_err("casing.getByKey(Info) failed - %s\n", u_errorName(errorCode)); 568 } else { 569 ures_close(item); 570 } 571 572 errorCode=U_ZERO_ERROR; 573 item=ures_getByKey(casing, "ShortLanguage", NULL, &errorCode); 574 if(U_SUCCESS(errorCode)) { 575 log_err("casing.getByKey(root key) succeeded despite nofallback declaration - %s\n", u_errorName(errorCode)); 576 ures_close(item); 577 } 578 ures_close(casing); 579 580 /* 581 * verify that ures_open("ne") finds the root bundle but 582 * ures_openDirect("ne") does not 583 */ 584 errorCode=U_ZERO_ERROR; 585 ne=ures_open("testdata", "ne", &errorCode); 586 if(U_FAILURE(errorCode)) { 587 log_data_err("ures_open(\"ne\") failed (expected to get root): %s\n", u_errorName(errorCode)); 588 } 589 if(errorCode!=U_USING_DEFAULT_WARNING || 0!=uprv_strcmp("root", ures_getLocale(ne, &errorCode))) { 590 log_err("ures_open(\"ne\") found something other than \"root\" - %s\n", u_errorName(errorCode)); 591 } 592 ures_close(ne); 593 594 errorCode=U_ZERO_ERROR; 595 ne=ures_openDirect("testdata", "ne", &errorCode); 596 if(U_SUCCESS(errorCode)) { 597 log_data_err("ures_openDirect(\"ne\") succeeded unexpectedly\n"); 598 ures_close(ne); 599 } 600 601 /* verify that ures_openDirect("te_IN") does not enable fallbacks */ 602 errorCode=U_ZERO_ERROR; 603 te_IN=ures_openDirect("testdata", "te_IN", &errorCode); 604 if(U_FAILURE(errorCode)) { 605 log_data_err("ures_open(\"te_IN\") failed: %s\n", u_errorName(errorCode)); 606 return; 607 } 608 errorCode=U_ZERO_ERROR; 609 item=ures_getByKey(te_IN, "ShortLanguage", NULL, &errorCode); 610 if(U_SUCCESS(errorCode)) { 611 log_err("te_IN.getByKey(root key) succeeded despite use of ures_openDirect() - %s\n", u_errorName(errorCode)); 612 ures_close(item); 613 } 614 ures_close(te_IN); 615} 616 617static int32_t 618parseTable32Key(const char *key) { 619 int32_t number; 620 char c; 621 622 number=0; 623 while((c=*key++)!=0) { 624 number<<=1; 625 if(c=='1') { 626 number|=1; 627 } 628 } 629 return number; 630} 631 632static void 633TestTable32(void) { 634 static const struct { 635 const char *key; 636 int32_t number; 637 } testcases[]={ 638 { "ooooooooooooooooo", 0 }, 639 { "oooooooooooooooo1", 1 }, 640 { "ooooooooooooooo1o", 2 }, 641 { "oo11ooo1ooo11111o", 25150 }, 642 { "oo11ooo1ooo111111", 25151 }, 643 { "o1111111111111111", 65535 }, 644 { "1oooooooooooooooo", 65536 }, 645 { "1ooooooo11o11ooo1", 65969 }, 646 { "1ooooooo11o11oo1o", 65970 }, 647 { "1ooooooo111oo1111", 65999 } 648 }; 649 650 /* ### TODO UResourceBundle staticItem={ 0 }; - need to know the size */ 651 UResourceBundle *res, *item; 652 const UChar *s; 653 const char *key; 654 UErrorCode errorCode; 655 int32_t i, j, number, parsedNumber, length, count; 656 657 errorCode=U_ZERO_ERROR; 658 res=ures_open(loadTestData(&errorCode), "testtable32", &errorCode); 659 if(U_FAILURE(errorCode)) { 660 log_data_err("unable to open testdata/testtable32.res - %s\n", u_errorName(errorCode)); 661 return; 662 } 663 if(ures_getType(res)!=URES_TABLE) { 664 log_data_err("testdata/testtable32.res has type %d instead of URES_TABLE\n", ures_getType(res)); 665 } 666 667 count=ures_getSize(res); 668 if(count!=66000) { 669 log_err("testdata/testtable32.res should have 66000 entries but has %d\n", count); 670 } 671 672 /* get the items by index */ 673 item=NULL; 674 for(i=0; i<count; ++i) { 675 item=ures_getByIndex(res, i, item, &errorCode); 676 if(U_FAILURE(errorCode)) { 677 log_err("unable to get item %d of %d in testdata/testtable32.res - %s\n", 678 i, count, u_errorName(errorCode)); 679 break; 680 } 681 682 key=ures_getKey(item); 683 parsedNumber=parseTable32Key(key); 684 685 switch(ures_getType(item)) { 686 case URES_STRING: 687 s=ures_getString(item, &length, &errorCode); 688 if(U_FAILURE(errorCode) || s==NULL) { 689 log_err("unable to access the string \"%s\" at %d in testdata/testtable32.res - %s\n", 690 key, i, u_errorName(errorCode)); 691 number=-1; 692 } else { 693 j=0; 694 U16_NEXT(s, j, length, number); 695 } 696 break; 697 case URES_INT: 698 number=ures_getInt(item, &errorCode); 699 if(U_FAILURE(errorCode)) { 700 log_err("unable to access the integer \"%s\" at %d in testdata/testtable32.res - %s\n", 701 key, i, u_errorName(errorCode)); 702 number=-1; 703 } 704 break; 705 default: 706 log_err("unexpected resource type %d for \"%s\" at %d in testdata/testtable32.res - %s\n", 707 ures_getType(item), key, i, u_errorName(errorCode)); 708 number=-1; 709 break; 710 } 711 712 if(number>=0 && number!=parsedNumber) { 713 log_err("\"%s\" at %d in testdata/testtable32.res has a string/int value of %d, expected %d\n", 714 key, i, number, parsedNumber); 715 } 716 } 717 718 /* search for some items by key */ 719 for(i=0; i<LENGTHOF(testcases); ++i) { 720 item=ures_getByKey(res, testcases[i].key, item, &errorCode); 721 if(U_FAILURE(errorCode)) { 722 log_err("unable to find the key \"%s\" in testdata/testtable32.res - %s\n", 723 testcases[i].key, u_errorName(errorCode)); 724 continue; 725 } 726 727 switch(ures_getType(item)) { 728 case URES_STRING: 729 s=ures_getString(item, &length, &errorCode); 730 if(U_FAILURE(errorCode) || s==NULL) { 731 log_err("unable to access the string \"%s\" in testdata/testtable32.res - %s\n", 732 testcases[i].key, u_errorName(errorCode)); 733 number=-1; 734 } else { 735 j=0; 736 U16_NEXT(s, j, length, number); 737 } 738 break; 739 case URES_INT: 740 number=ures_getInt(item, &errorCode); 741 if(U_FAILURE(errorCode)) { 742 log_err("unable to access the integer \"%s\" in testdata/testtable32.res - %s\n", 743 testcases[i].key, u_errorName(errorCode)); 744 number=-1; 745 } 746 break; 747 default: 748 log_err("unexpected resource type %d for \"%s\" in testdata/testtable32.res - %s\n", 749 ures_getType(item), testcases[i].key, u_errorName(errorCode)); 750 number=-1; 751 break; 752 } 753 754 if(number>=0 && number!=testcases[i].number) { 755 log_err("\"%s\" in testdata/testtable32.res has a string/int value of %d, expected %d\n", 756 testcases[i].key, number, testcases[i].number); 757 } 758 759 key=ures_getKey(item); 760 if(0!=uprv_strcmp(key, testcases[i].key)) { 761 log_err("\"%s\" in testdata/testtable32.res claims to have the key \"%s\"\n", 762 testcases[i].key, key); 763 } 764 } 765 766 ures_close(item); 767 ures_close(res); 768} 769 770static void TestFileStream(void){ 771 int32_t c = 0; 772 int32_t c1=0; 773 UErrorCode status = U_ZERO_ERROR; 774 const char* testdatapath = loadTestData(&status); 775 char* fileName = (char*) malloc(uprv_strlen(testdatapath) +10); 776 FileStream* stream = NULL; 777 /* these should not be closed */ 778 FileStream* pStdin = T_FileStream_stdin(); 779 FileStream* pStdout = T_FileStream_stdout(); 780 FileStream* pStderr = T_FileStream_stderr(); 781 782 const char* testline = "This is a test line"; 783 int32_t bufLen = (int32_t)strlen(testline)+10; 784 char* buf = (char*) malloc(bufLen); 785 int32_t retLen = 0; 786 787 if(pStdin==NULL){ 788 log_err("failed to get T_FileStream_stdin()"); 789 } 790 if(pStdout==NULL){ 791 log_err("failed to get T_FileStream_stdout()"); 792 } 793 if(pStderr==NULL){ 794 log_err("failed to get T_FileStream_stderr()"); 795 } 796 797 uprv_strcpy(fileName,testdatapath); 798 uprv_strcat(fileName,".dat"); 799 stream = T_FileStream_open(fileName, "r"); 800 if(stream==NULL){ 801 log_data_err("T_FileStream_open failed to open %s\n",fileName); 802 } else { 803 if(!T_FileStream_file_exists(fileName)){ 804 log_data_err("T_FileStream_file_exists failed to verify existence of %s \n",fileName); 805 } 806 807 retLen=T_FileStream_read(stream,&c,1); 808 if(retLen==0){ 809 log_data_err("T_FileStream_read failed to read from %s \n",fileName); 810 } 811 retLen=0; 812 T_FileStream_rewind(stream); 813 T_FileStream_read(stream,&c1,1); 814 if(c!=c1){ 815 log_data_err("T_FileStream_rewind failed to rewind %s \n",fileName); 816 } 817 T_FileStream_rewind(stream); 818 c1 = T_FileStream_peek(stream); 819 if(c!=c1){ 820 log_data_err("T_FileStream_peek failed to peekd %s \n",fileName); 821 } 822 c = T_FileStream_getc(stream); 823 T_FileStream_ungetc(c,stream); 824 if(c!= T_FileStream_getc(stream)){ 825 log_data_err("T_FileStream_ungetc failed to d %s \n",fileName); 826 } 827 828 if(T_FileStream_size(stream)<=0){ 829 log_data_err("T_FileStream_size failed to d %s \n",fileName); 830 } 831 if(T_FileStream_error(stream)){ 832 log_data_err("T_FileStream_error shouldn't have an error %s\n",fileName); 833 } 834 if(!T_FileStream_error(NULL)){ 835 log_err("T_FileStream_error didn't get an error %s\n",fileName); 836 } 837 T_FileStream_putc(stream, 0x20); 838 if(!T_FileStream_error(stream)){ 839 /* 840 Warning 841 writing to a read-only file may not consistently fail on all platforms 842 (e.g. HP-UX, FreeBSD, MacOSX) 843 */ 844 log_verbose("T_FileStream_error didn't get an error when writing to a readonly file %s\n",fileName); 845 } 846 847 T_FileStream_close(stream); 848 } 849 /* test writing function */ 850 stream=NULL; 851 uprv_strcpy(fileName,testdatapath); 852 uprv_strcat(fileName,".tmp"); 853 stream = T_FileStream_open(fileName,"w+"); 854 855 if(stream == NULL){ 856 log_data_err("Could not open %s for writing\n",fileName); 857 } else { 858 c= '$'; 859 T_FileStream_putc(stream,c); 860 T_FileStream_rewind(stream); 861 if(c != T_FileStream_getc(stream)){ 862 log_data_err("T_FileStream_putc failed %s\n",fileName); 863 } 864 865 T_FileStream_rewind(stream); 866 T_FileStream_writeLine(stream,testline); 867 T_FileStream_rewind(stream); 868 T_FileStream_readLine(stream,buf,bufLen); 869 if(uprv_strncmp(testline, buf,uprv_strlen(buf))!=0){ 870 log_data_err("T_FileStream_writeLine failed %s\n",fileName); 871 } 872 873 T_FileStream_rewind(stream); 874 T_FileStream_write(stream,testline,(int32_t)strlen(testline)); 875 T_FileStream_rewind(stream); 876 retLen = T_FileStream_read(stream, buf, bufLen); 877 if(uprv_strncmp(testline, buf,retLen)!=0){ 878 log_data_err("T_FileStream_write failed %s\n",fileName); 879 } 880 881 T_FileStream_close(stream); 882 } 883 if(!T_FileStream_remove(fileName)){ 884 log_data_err("T_FileStream_remove failed to delete %s\n",fileName); 885 } 886 887 888 free(fileName); 889 free(buf); 890 891} 892 893static void TestGetSize(void) { 894 const struct { 895 const char* key; 896 int32_t size; 897 } test[] = { 898 { "zerotest", 1}, 899 { "one", 1}, 900 { "importtest", 1}, 901 { "integerarray", 1}, 902 { "emptyarray", 0}, 903 { "emptytable", 0}, 904 { "emptystring", 1}, /* empty string is still a string */ 905 { "emptyint", 1}, 906 { "emptybin", 1}, 907 { "testinclude", 1}, 908 { "collations", 1}, /* not 2 - there is hidden %%CollationBin */ 909 }; 910 911 UErrorCode status = U_ZERO_ERROR; 912 913 UResourceBundle *rb = NULL; 914 UResourceBundle *res = NULL; 915 UResourceBundle *helper = NULL; 916 const char* testdatapath = loadTestData(&status); 917 int32_t i = 0, j = 0; 918 int32_t size = 0; 919 920 if(U_FAILURE(status)) 921 { 922 log_data_err("Could not load testdata.dat %s\n", u_errorName(status)); 923 return; 924 } 925 926 rb = ures_open(testdatapath, "testtypes", &status); 927 if(U_FAILURE(status)) 928 { 929 log_err("Could not testtypes resource bundle %s\n", u_errorName(status)); 930 return; 931 } 932 933 for(i = 0; i < sizeof(test)/sizeof(test[0]); i++) { 934 res = ures_getByKey(rb, test[i].key, res, &status); 935 if(U_FAILURE(status)) 936 { 937 log_err("Couldn't find the key %s. Error: %s\n", test[i].key, u_errorName(status)); 938 ures_close(rb); 939 return; 940 } 941 size = ures_getSize(res); 942 if(size != test[i].size) { 943 log_err("Expected size %i, got size %i for key %s\n", test[i].size, size, test[i].key); 944 for(j = 0; j < size; j++) { 945 helper = ures_getByIndex(res, j, helper, &status); 946 log_err("%s\n", ures_getKey(helper)); 947 } 948 } 949 } 950 ures_close(helper); 951 ures_close(res); 952 ures_close(rb); 953} 954 955static void TestGetLocaleByType(void) { 956 static const struct { 957 const char *requestedLocale; 958 const char *resourceKey; 959 const char *validLocale; 960 const char *actualLocale; 961 } test[] = { 962 { "te_IN_BLAH", "string_only_in_te_IN", "te_IN", "te_IN" }, 963 { "te_IN_BLAH", "string_only_in_te", "te_IN", "te" }, 964 { "te_IN_BLAH", "string_only_in_Root", "te_IN", "root" }, 965 { "te_IN_BLAH_01234567890_01234567890_01234567890_01234567890_01234567890_01234567890", "array_2d_only_in_Root", "te_IN", "root" }, 966 { "te_IN_BLAH@currency=euro", "array_2d_only_in_te_IN", "te_IN", "te_IN" }, 967 { "te_IN_BLAH@collation=phonebook;calendar=thai", "array_2d_only_in_te", "te_IN", "te" } 968 }; 969 970 UErrorCode status = U_ZERO_ERROR; 971 972 UResourceBundle *rb = NULL; 973 UResourceBundle *res = NULL; 974 const char* testdatapath = loadTestData(&status); 975 int32_t i = 0; 976 const char *locale = NULL; 977 978 if(U_FAILURE(status)) 979 { 980 log_data_err("Could not load testdata.dat %s\n", u_errorName(status)); 981 return; 982 } 983 984 for(i = 0; i < sizeof(test)/sizeof(test[0]); i++) { 985 rb = ures_open(testdatapath, test[i].requestedLocale, &status); 986 if(U_FAILURE(status)) 987 { 988 log_err("Could not open resource bundle %s (error %s)\n", test[i].requestedLocale, u_errorName(status)); 989 status = U_ZERO_ERROR; 990 continue; 991 } 992 993 res = ures_getByKey(rb, test[i].resourceKey, res, &status); 994 if(U_FAILURE(status)) 995 { 996 log_err("Couldn't find the key %s. Error: %s\n", test[i].resourceKey, u_errorName(status)); 997 ures_close(rb); 998 status = U_ZERO_ERROR; 999 continue; 1000 } 1001 1002 locale = ures_getLocaleByType(res, ULOC_REQUESTED_LOCALE, &status); 1003 if(locale) { 1004 log_err("Requested locale should return NULL\n"); 1005 } 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 1019