UBool testTag(const char* frag, UBool in_Root, UBool in_te, UBool in_te_IN) { int32_t passNum=pass; /* Make array from input params */ UBool is_in[3]; const char *NAME[] = { "ROOT", "TE", "TE_IN" }; /* Now try to load the desired items */ UResourceBundle* theBundle = NULL; char tag[99]; char action[256]; UErrorCode status = U_ZERO_ERROR,expected_resource_status = U_ZERO_ERROR; UChar* base = NULL; UChar* expected_string = NULL; const UChar* string = NULL; char item_tag[10]; int32_t i,j; int32_t actual_bundle; int32_t resultLen; const char *testdatapath = loadTestData(&status); is_in[0] = in_Root; is_in[1] = in_te; is_in[2] = in_te_IN; strcpy(item_tag, "tag"); status = U_ZERO_ERROR; theBundle = ures_open(testdatapath, "root", &status); if(U_FAILURE(status)) { ures_close(theBundle); log_err("Couldn't open root bundle in %s", testdatapath); return FALSE; } ures_close(theBundle); theBundle = NULL; for (i=0; i<bundles_count; ++i) { strcpy(action,"construction for"); strcat(action, param[i].name); status = U_ZERO_ERROR; theBundle = ures_open(testdatapath, param[i].name, &status); /*theBundle = ures_open("c:\\icu\\icu\\source\\test\\testdata\\testdata", param[i].name, &status);*/ CONFIRM_ErrorCode(status,param[i].expected_constructor_status); if(i == 5) actual_bundle = 0; /* ne -> default */ else if(i == 3) actual_bundle = 1; /* te_NE -> te */ else if(i == 4) actual_bundle = 2; /* te_IN_NE -> te_IN */ else actual_bundle = i; expected_resource_status = U_MISSING_RESOURCE_ERROR; for (j=e_te_IN; j>=e_Root; --j) { if (is_in[j] && param[i].inherits[j]) { if(j == actual_bundle) /* it's in the same bundle OR it's a nonexistent=default bundle (5) */ expected_resource_status = U_ZERO_ERROR; else if(j == 0) expected_resource_status = U_USING_DEFAULT_WARNING; else expected_resource_status = U_USING_FALLBACK_WARNING; log_verbose("%s[%d]::%s: in<%d:%s> inherits<%d:%s>. actual_bundle=%s\n", param[i].name, i, frag, j, is_in[j]?"Yes":"No", j, param[i].inherits[j]?"Yes":"No", param[actual_bundle].name); break; } } for (j=param[i].where; j>=0; --j) { if (is_in[j]) { if(base != NULL) { free(base); base = NULL; } base=(UChar*)malloc(sizeof(UChar)*(strlen(NAME[j]) + 1)); u_uastrcpy(base,NAME[j]); break; } else { if(base != NULL) { free(base); base = NULL; } base = (UChar*) malloc(sizeof(UChar) * 1); *base = 0x0000; } } /*-------------------------------------------------------------------- */ /* string */ strcpy(tag,"string_"); strcat(tag,frag); strcpy(action,param[i].name); strcat(action, ".ures_get(" ); strcat(action,tag); strcat(action, ")"); string= kERROR; status = U_ZERO_ERROR; ures_getStringByKey(theBundle, tag, &resultLen, &status); if(U_SUCCESS(status)) { status = U_ZERO_ERROR; string=ures_getStringByKey(theBundle, tag, &resultLen, &status); } log_verbose("%s got %d, expected %d\n", action, status, expected_resource_status); CONFIRM_ErrorCode(status, expected_resource_status); if(U_SUCCESS(status)){ expected_string=(UChar*)malloc(sizeof(UChar)*(u_strlen(base) + 3)); u_strcpy(expected_string,base); } else { expected_string = (UChar*)malloc(sizeof(UChar)*(u_strlen(kERROR) + 1)); u_strcpy(expected_string,kERROR); } CONFIRM_EQ(string, expected_string); free(expected_string); ures_close(theBundle); } free(base); return (UBool)(passNum == pass); }
UBool NewResourceBundleTest::testTag(const char* frag, UBool in_Root, UBool in_te, UBool in_te_IN) { int32_t failOrig = fail; // Make array from input params UBool is_in[] = { in_Root, in_te, in_te_IN }; const char* NAME[] = { "ROOT", "TE", "TE_IN" }; // Now try to load the desired items char tag[100]; UnicodeString action; int32_t i,j,row,col, actual_bundle; int32_t index; const char* testdatapath; UErrorCode status = U_ZERO_ERROR; testdatapath=loadTestData(status); if(U_FAILURE(status)) { dataerrln("Could not load testdata.dat %s " + UnicodeString(u_errorName(status))); return FALSE; } for (i=0; i<bundles_count; ++i) { action = "Constructor for "; action += param[i].name; status = U_ZERO_ERROR; ResourceBundle theBundle( testdatapath, *param[i].locale, status); //ResourceBundle theBundle( "c:\\icu\\icu\\source\\test\\testdata\\testdata", *param[i].locale, status); CONFIRM_UErrorCode(status,param[i].expected_constructor_status); if(i == 5) actual_bundle = 0; /* ne -> default */ else if(i == 3) actual_bundle = 1; /* te_NE -> te */ else if(i == 4) actual_bundle = 2; /* te_IN_NE -> te_IN */ else actual_bundle = i; UErrorCode expected_resource_status = U_MISSING_RESOURCE_ERROR; for (j=e_te_IN; j>=e_Root; --j) { if (is_in[j] && param[i].inherits[j]) { if(j == actual_bundle) /* it's in the same bundle OR it's a nonexistent=default bundle (5) */ expected_resource_status = U_ZERO_ERROR; else if(j == 0) expected_resource_status = U_USING_DEFAULT_WARNING; else expected_resource_status = U_USING_FALLBACK_WARNING; break; } } UErrorCode expected_status; UnicodeString base; for (j=param[i].where; j>=0; --j) { if (is_in[j]) { base = NAME[j]; break; } } //-------------------------------------------------------------------------- // string uprv_strcpy(tag, "string_"); uprv_strcat(tag, frag); action = param[i].name; action += ".getStringEx("; action += tag; action += ")"; status = U_ZERO_ERROR; UnicodeString string = theBundle.getStringEx(tag, status); if(U_FAILURE(status)) { string.setTo(TRUE, kErrorUChars, kErrorLength); } CONFIRM_UErrorCode(status, expected_resource_status); UnicodeString expected_string(kErrorUChars); if (U_SUCCESS(status)) { expected_string = base; } CONFIRM_EQ(string, expected_string); //-------------------------------------------------------------------------- // array ResourceBundle using the key uprv_strcpy(tag, "array_"); uprv_strcat(tag, frag); action = param[i].name; action += ".get("; action += tag; action += ")"; int32_t count = kERROR_COUNT; status = U_ZERO_ERROR; ResourceBundle array = theBundle.get(tag, status); CONFIRM_UErrorCode(status,expected_resource_status); if (U_SUCCESS(status)) { //confirm the resource type is an array UResType bundleType=array.getType(); CONFIRM_EQ(bundleType, URES_ARRAY); count=array.getSize(); CONFIRM_GE(count,1); for (j=0; j<count; ++j) { char buf[32]; expected_string = base; expected_string += itoa(j,buf); CONFIRM_EQ(array.getNextString(status),expected_string); } } else { CONFIRM_EQ(count,kERROR_COUNT); // CONFIRM_EQ((int32_t)(unsigned long)array,(int32_t)0); count = 0; } //-------------------------------------------------------------------------- // arrayItem ResourceBundle using the index for (j=0; j<100; ++j) { index = count ? (randi(count * 3) - count) : (randi(200) - 100); status = U_ZERO_ERROR; string = kErrorUChars; ResourceBundle array = theBundle.get(tag, status); if(!U_FAILURE(status)){ UnicodeString t = array.getStringEx(index, status); if(!U_FAILURE(status)) { string=t; } } expected_status = (index >= 0 && index < count) ? expected_resource_status : U_MISSING_RESOURCE_ERROR; CONFIRM_UErrorCode(status,expected_status); if (U_SUCCESS(status)){ char buf[32]; expected_string = base; expected_string += itoa(index,buf); } else { expected_string = kErrorUChars; } CONFIRM_EQ(string,expected_string); } //-------------------------------------------------------------------------- // 2dArray uprv_strcpy(tag, "array_2d_"); uprv_strcat(tag, frag); action = param[i].name; action += ".get("; action += tag; action += ")"; int32_t row_count = kERROR_COUNT, column_count = kERROR_COUNT; status = U_ZERO_ERROR; ResourceBundle array2d=theBundle.get(tag, status); //const UnicodeString** array2d = theBundle.get2dArray(tag, row_count, column_count, status); CONFIRM_UErrorCode(status,expected_resource_status); if (U_SUCCESS(status)) { //confirm the resource type is an 2darray UResType bundleType=array2d.getType(); CONFIRM_EQ(bundleType, URES_ARRAY); row_count=array2d.getSize(); CONFIRM_GE(row_count,1); for(row=0; row<row_count; ++row){ ResourceBundle tablerow=array2d.get(row, status); CONFIRM_UErrorCode(status, expected_resource_status); if(U_SUCCESS(status)){ //confirm the resourcetype of each table row is an array UResType rowType=tablerow.getType(); CONFIRM_EQ(rowType, URES_ARRAY); column_count=tablerow.getSize(); CONFIRM_GE(column_count,1); for (col=0; j<column_count; ++j) { char buf[32]; expected_string = base; expected_string += itoa(row,buf); expected_string += itoa(col,buf); CONFIRM_EQ(tablerow.getNextString(status),expected_string); } } } }else{ CONFIRM_EQ(row_count,kERROR_COUNT); CONFIRM_EQ(column_count,kERROR_COUNT); row_count=column_count=0; } //-------------------------------------------------------------------------- // 2dArrayItem for (j=0; j<200; ++j) { row = row_count ? (randi(row_count * 3) - row_count) : (randi(200) - 100); col = column_count ? (randi(column_count * 3) - column_count) : (randi(200) - 100); status = U_ZERO_ERROR; string = kErrorUChars; ResourceBundle array2d=theBundle.get(tag, status); if(U_SUCCESS(status)){ ResourceBundle tablerow=array2d.get(row, status); if(U_SUCCESS(status)) { UnicodeString t=tablerow.getStringEx(col, status); if(U_SUCCESS(status)){ string=t; } } } expected_status = (row >= 0 && row < row_count && col >= 0 && col < column_count) ? expected_resource_status: U_MISSING_RESOURCE_ERROR; CONFIRM_UErrorCode(status,expected_status); if (U_SUCCESS(status)){ char buf[32]; expected_string = base; expected_string += itoa(row,buf); expected_string += itoa(col,buf); } else { expected_string = kErrorUChars; } CONFIRM_EQ(string,expected_string); } //-------------------------------------------------------------------------- // taggedArray uprv_strcpy(tag, "tagged_array_"); uprv_strcat(tag, frag); action = param[i].name; action += ".get("; action += tag; action += ")"; int32_t tag_count; status = U_ZERO_ERROR; ResourceBundle tags=theBundle.get(tag, status); CONFIRM_UErrorCode(status, expected_resource_status); if (U_SUCCESS(status)) { UResType bundleType=tags.getType(); CONFIRM_EQ(bundleType, URES_TABLE); tag_count=tags.getSize(); CONFIRM_GE((int32_t)tag_count, (int32_t)0); for(index=0; index <tag_count; index++){ ResourceBundle tagelement=tags.get(index, status); UnicodeString key=tagelement.getKey(); UnicodeString value=tagelement.getNextString(status); logln("tag = " + key + ", value = " + value ); if(key.startsWith("tag") && value.startsWith(base)){ record_pass(); }else{ record_fail(); } } for(index=0; index <tag_count; index++){ ResourceBundle tagelement=tags.get(index, status); const char *tkey=NULL; UnicodeString value=tagelement.getNextString(&tkey, status); UnicodeString key(tkey); logln("tag = " + key + ", value = " + value ); if(value.startsWith(base)){ record_pass(); }else{ record_fail(); } } }else{ tag_count=0; } //-------------------------------------------------------------------------- // taggedArrayItem action = param[i].name; action += ".get("; action += tag; action += ")"; count = 0; for (index=-20; index<20; ++index) { char buf[32]; status = U_ZERO_ERROR; string = kErrorUChars; char item_tag[8]; uprv_strcpy(item_tag, "tag"); uprv_strcat(item_tag, itoa(index,buf)); ResourceBundle tags=theBundle.get(tag, status); if(U_SUCCESS(status)){ ResourceBundle tagelement=tags.get(item_tag, status); if(!U_FAILURE(status)){ UResType elementType=tagelement.getType(); CONFIRM_EQ(elementType, (int32_t)URES_STRING); const char* key=tagelement.getKey(); CONFIRM_EQ((UnicodeString)key, (UnicodeString)item_tag); UnicodeString t=tagelement.getString(status); if(!U_FAILURE(status)){ string=t; } } if (index < 0) { CONFIRM_UErrorCode(status,U_MISSING_RESOURCE_ERROR); } else{ if (status != U_MISSING_RESOURCE_ERROR) { count++; expected_string = base; expected_string += buf; CONFIRM_EQ(string,expected_string); } } } } CONFIRM_EQ(count, tag_count); } return (UBool)(failOrig == fail); }
void NewResourceBundleTest::TestOtherAPI(){ UErrorCode err = U_ZERO_ERROR; const char* testdatapath=loadTestData(err); UnicodeString tDataPathUS = UnicodeString(testdatapath, ""); if(U_FAILURE(err)) { dataerrln("Could not load testdata.dat %s " + UnicodeString(u_errorName(err))); return; } /* Make sure that users using te_IN for the default locale don't get test failures. */ Locale originalDefault; if (Locale::getDefault() == Locale("te_IN")) { Locale::setDefault(Locale("en_US"), err); } Locale *locale=new Locale("te_IN"); ResourceBundle test0(tDataPathUS, *locale, err); if(U_FAILURE(err)){ errln("Construction failed"); return; } ResourceBundle test1(testdatapath, *locale, err); if(U_FAILURE(err)){ errln("Construction failed"); return; } logln("Testing getLocale()\n"); if(strcmp(test1.getLocale().getName(), locale->getName()) !=0 ){ errln("FAIL: ResourceBundle::getLocale() failed\n"); } delete locale; logln("Testing ResourceBundle(UErrorCode)\n"); ResourceBundle defaultresource(err); ResourceBundle explicitdefaultresource(NULL, Locale::getDefault(), err); if(U_FAILURE(err)){ errcheckln(err, "Construction of default resourcebundle failed - %s", u_errorName(err)); return; } // You can't compare the default locale to the resolved locale in the // resource bundle due to aliasing, keywords in the default locale // or the chance that the machine running these tests is using a locale // that isn't available in ICU. if(strcmp(defaultresource.getLocale().getName(), explicitdefaultresource.getLocale().getName()) != 0){ errln("Construction of default resourcebundle didn't take the defaultlocale. Expected %s Got %s err=%s\n", explicitdefaultresource.getLocale().getName(), defaultresource.getLocale().getName(), u_errorName(err)); } ResourceBundle copyRes(defaultresource); if(strcmp(copyRes.getName(), defaultresource.getName() ) !=0 || strcmp(test1.getName(), defaultresource.getName() ) ==0 || strcmp(copyRes.getLocale().getName(), defaultresource.getLocale().getName() ) !=0 || strcmp(test1.getLocale().getName(), defaultresource.getLocale().getName() ) ==0 ) { errln("copy construction failed\n"); } ResourceBundle defaultSub = defaultresource.get((int32_t)0, err); ResourceBundle defSubCopy(defaultSub); if(strcmp(defSubCopy.getName(), defaultSub.getName() ) !=0 || strcmp(defSubCopy.getLocale().getName(), defaultSub.getLocale().getName() ) !=0 ){ errln("copy construction for subresource failed\n"); } ResourceBundle *p; p = defaultresource.clone(); if(p == &defaultresource || !equalRB(*p, defaultresource)) { errln("ResourceBundle.clone() failed"); } delete p; p = defaultSub.clone(); if(p == &defaultSub || !equalRB(*p, defaultSub)) { errln("2nd ResourceBundle.clone() failed"); } delete p; UVersionInfo ver; copyRes.getVersion(ver); logln("Version returned: [%d.%d.%d.%d]\n", ver[0], ver[1], ver[2], ver[3]); logln("Testing C like UnicodeString APIs\n"); UResourceBundle *testCAPI = NULL, *bundle = NULL, *rowbundle = NULL, *temp = NULL; err = U_ZERO_ERROR; const char* data[]={ "string_in_Root_te_te_IN", "1", "array_in_Root_te_te_IN", "5", "array_2d_in_Root_te_te_IN", "4", }; testCAPI = ures_open(testdatapath, "te_IN", &err); if(U_SUCCESS(err)) { // Do the testing // first iteration uint32_t i; int32_t count, row=0, col=0; char buf[5]; UnicodeString expected; UnicodeString element("TE_IN"); UnicodeString action; for(i=0; i<UPRV_LENGTHOF(data); i=i+2){ action = "te_IN"; action +=".get("; action += data[i]; action +=", err)"; err=U_ZERO_ERROR; bundle = ures_getByKey(testCAPI, data[i], bundle, &err); if(!U_FAILURE(err)){ const char* key = NULL; action = "te_IN"; action +=".getKey()"; CONFIRM_EQ((UnicodeString)ures_getKey(bundle), (UnicodeString)data[i]); count=0; row=0; while(ures_hasNext(bundle)){ action = data[i]; action +=".getNextString(err)"; row=count; UnicodeString got=ures_getNextUnicodeString(bundle, &key, &err); if(U_SUCCESS(err)){ expected=element; if(ures_getSize(bundle) > 1){ CONFIRM_EQ(ures_getType(bundle), URES_ARRAY); expected+=itoa(row, buf); rowbundle=ures_getByIndex(bundle, row, rowbundle, &err); if(!U_FAILURE(err) && ures_getSize(rowbundle)>1){ col=0; while(ures_hasNext(rowbundle)){ expected=element; got=ures_getNextUnicodeString(rowbundle, &key, &err); temp = ures_getByIndex(rowbundle, col, temp, &err); UnicodeString bla = ures_getUnicodeString(temp, &err); UnicodeString bla2 = ures_getUnicodeStringByIndex(rowbundle, col, &err); if(!U_FAILURE(err)){ expected+=itoa(row, buf); expected+=itoa(col, buf); col++; CONFIRM_EQ(got, expected); CONFIRM_EQ(bla, expected); CONFIRM_EQ(bla2, expected); } } CONFIRM_EQ(col, ures_getSize(rowbundle)); } } else{ CONFIRM_EQ(ures_getType(bundle), (int32_t)URES_STRING); } } CONFIRM_EQ(got, expected); count++; } } } // Check that ures_getUnicodeString() & variants return a bogus string if failure. // Same relevant code path whether the failure code is passed in // or comes from a lookup error. UErrorCode failure = U_INTERNAL_PROGRAM_ERROR; assertTrue("ures_getUnicodeString(failure).isBogus()", ures_getUnicodeString(testCAPI, &failure).isBogus()); assertTrue("ures_getNextUnicodeString(failure).isBogus()", ures_getNextUnicodeString(testCAPI, NULL, &failure).isBogus()); assertTrue("ures_getUnicodeStringByIndex(failure).isBogus()", ures_getUnicodeStringByIndex(testCAPI, 999, &failure).isBogus()); assertTrue("ures_getUnicodeStringByKey(failure).isBogus()", ures_getUnicodeStringByKey(testCAPI, "bogus key", &failure).isBogus()); ures_close(temp); ures_close(rowbundle); ures_close(bundle); ures_close(testCAPI); } else { errln("failed to open a resource bundle\n"); } /* Restore the default locale for the other tests. */ Locale::setDefault(originalDefault, err); }
void NewResourceBundleTest::TestIteration() { UErrorCode err = U_ZERO_ERROR; const char* testdatapath; const char* data[]={ "string_in_Root_te_te_IN", "1", "array_in_Root_te_te_IN", "5", "array_2d_in_Root_te_te_IN", "4", }; Locale *locale=new Locale("te_IN"); testdatapath=loadTestData(err); if(U_FAILURE(err)) { dataerrln("Could not load testdata.dat %s " + UnicodeString(u_errorName(err))); return; } ResourceBundle test1(testdatapath, *locale, err); if(U_FAILURE(err)){ errln("Construction failed"); } uint32_t i; int32_t count, row=0, col=0; char buf[5]; UnicodeString expected; UnicodeString element("TE_IN"); UnicodeString action; for(i=0; i<UPRV_LENGTHOF(data); i=i+2){ action = "te_IN"; action +=".get("; action += data[i]; action +=", err)"; err=U_ZERO_ERROR; ResourceBundle bundle = test1.get(data[i], err); if(!U_FAILURE(err)){ action = "te_IN"; action +=".getKey()"; CONFIRM_EQ((UnicodeString)bundle.getKey(), (UnicodeString)data[i]); count=0; row=0; while(bundle.hasNext()){ action = data[i]; action +=".getNextString(err)"; row=count; UnicodeString got=bundle.getNextString(err); if(U_SUCCESS(err)){ expected=element; if(bundle.getSize() > 1){ CONFIRM_EQ(bundle.getType(), URES_ARRAY); expected+=itoa(row, buf); ResourceBundle rowbundle=bundle.get(row, err); if(!U_FAILURE(err) && rowbundle.getSize()>1){ col=0; while(rowbundle.hasNext()){ expected=element; got=rowbundle.getNextString(err); if(!U_FAILURE(err)){ expected+=itoa(row, buf); expected+=itoa(col, buf); col++; CONFIRM_EQ(got, expected); } } CONFIRM_EQ(col, rowbundle.getSize()); } } else{ CONFIRM_EQ(bundle.getType(), (int32_t)URES_STRING); } } CONFIRM_EQ(got, expected); count++; } action = data[i]; action +=".getSize()"; CONFIRM_EQ(bundle.getSize(), count); CONFIRM_EQ(count, atoi(data[i+1])); //after reaching the end err=U_ZERO_ERROR; ResourceBundle errbundle=bundle.getNext(err); action = "After reaching the end of the Iterator:- "; action +=data[i]; action +=".getNext()"; CONFIRM_NE(err, (int32_t)U_ZERO_ERROR); CONFIRM_EQ(u_errorName(err), u_errorName(U_INDEX_OUTOFBOUNDS_ERROR)); //reset the iterator err = U_ZERO_ERROR; bundle.resetIterator(); /* The following code is causing a crash ****CRASH****** */ bundle.getNext(err); if(U_FAILURE(err)){ errln("ERROR: getNext() throw an error"); } } } delete locale; }
void NewResourceBundleTest::TestNewTypes() { char action[256]; const char* testdatapath; UErrorCode status = U_ZERO_ERROR; uint8_t *binResult = NULL; int32_t len = 0; int32_t i = 0; int32_t intResult = 0; uint32_t uintResult = 0; UChar expected[] = { 'a','b','c','\0','d','e','f' }; const char* expect ="tab:\t cr:\r ff:\f newline:\n backslash:\\\\ quote=\\\' doubleQuote=\\\" singlequoutes=''"; UChar uExpect[200]; testdatapath=loadTestData(status); if(U_FAILURE(status)) { dataerrln("Could not load testdata.dat %s \n",u_errorName(status)); return; } ResourceBundle theBundle(testdatapath, "testtypes", status); ResourceBundle bundle(testdatapath, Locale("te_IN"),status); UnicodeString emptyStr = theBundle.getStringEx("emptystring", status); if(emptyStr.length() != 0) { logln("Empty string returned invalid value\n"); } CONFIRM_UErrorCode(status, U_ZERO_ERROR); /* This test reads the string "abc\u0000def" from the bundle */ /* if everything is working correctly, the size of this string */ /* should be 7. Everything else is a wrong answer, esp. 3 and 6*/ strcpy(action, "getting and testing of string with embeded zero"); ResourceBundle res = theBundle.get("zerotest", status); CONFIRM_UErrorCode(status, U_ZERO_ERROR); CONFIRM_EQ(res.getType(), URES_STRING); UnicodeString zeroString=res.getString(status); len = zeroString.length(); if(U_SUCCESS(status)){ CONFIRM_UErrorCode(status, U_ZERO_ERROR); CONFIRM_EQ(len, 7); CONFIRM_NE(len, 3); } for(i=0;i<len;i++){ if(zeroString[i]!= expected[i]){ logln("Output didnot match Expected: \\u%4X Got: \\u%4X", expected[i], zeroString[i]); } } strcpy(action, "getting and testing of binary type"); res = theBundle.get("binarytest", status); CONFIRM_UErrorCode(status, U_ZERO_ERROR); CONFIRM_EQ(res.getType(), URES_BINARY); binResult=(uint8_t*)res.getBinary(len, status); if(U_SUCCESS(status)){ CONFIRM_UErrorCode(status, U_ZERO_ERROR); CONFIRM_EQ(len, 15); for(i = 0; i<15; i++) { CONFIRM_EQ(binResult[i], i); } } strcpy(action, "getting and testing of imported binary type"); res = theBundle.get("importtest",status); CONFIRM_UErrorCode(status, U_ZERO_ERROR); CONFIRM_EQ(res.getType(), URES_BINARY); binResult=(uint8_t*)res.getBinary(len, status); if(U_SUCCESS(status)){ CONFIRM_UErrorCode(status, U_ZERO_ERROR); CONFIRM_EQ(len, 15); for(i = 0; i<15; i++) { CONFIRM_EQ(binResult[i], i); } } strcpy(action, "getting and testing of integer types"); res = theBundle.get("one", status); CONFIRM_UErrorCode(status, U_ZERO_ERROR); CONFIRM_EQ(res.getType(), URES_INT); intResult=res.getInt(status); uintResult = res.getUInt(status); if(U_SUCCESS(status)){ CONFIRM_UErrorCode(status, U_ZERO_ERROR); CONFIRM_EQ(uintResult, (uint32_t)intResult); CONFIRM_EQ(intResult, 1); } strcpy(action, "getting minusone"); res = theBundle.get((const char*)"minusone", status); CONFIRM_UErrorCode(status, U_ZERO_ERROR); CONFIRM_EQ(res.getType(), URES_INT); intResult=res.getInt(status); uintResult = res.getUInt(status); if(U_SUCCESS(status)){ CONFIRM_UErrorCode(status, U_ZERO_ERROR); CONFIRM_EQ(uintResult, 0x0FFFFFFF); /* a 28 bit integer */ CONFIRM_EQ(intResult, -1); CONFIRM_NE(uintResult, (uint32_t)intResult); } strcpy(action, "getting plusone"); res = theBundle.get("plusone",status); CONFIRM_UErrorCode(status, U_ZERO_ERROR); CONFIRM_EQ(res.getType(), URES_INT); intResult=res.getInt(status); uintResult = res.getUInt(status); if(U_SUCCESS(status)){ CONFIRM_UErrorCode(status, U_ZERO_ERROR); CONFIRM_EQ(uintResult, (uint32_t)intResult); CONFIRM_EQ(intResult, 1); } res = theBundle.get("onehundredtwentythree",status); CONFIRM_UErrorCode(status, U_ZERO_ERROR); CONFIRM_EQ(res.getType(), URES_INT); intResult=res.getInt(status); if(U_SUCCESS(status)){ CONFIRM_UErrorCode(status, U_ZERO_ERROR); CONFIRM_EQ(intResult, 123); } /* this tests if escapes are preserved or not */ { UnicodeString str = theBundle.getStringEx("testescape",status); CONFIRM_UErrorCode(status, U_ZERO_ERROR); if(U_SUCCESS(status)){ u_charsToUChars(expect,uExpect,(int32_t)uprv_strlen(expect)+1); if(str.compare(uExpect)!=0){ errln("Did not get the expected string for testescape expected. Expected : " +UnicodeString(uExpect )+ " Got: " + str); } } } /* test for jitterbug#1435 */ { UnicodeString str = theBundle.getStringEx("test_underscores",status); expect ="test message ...."; CONFIRM_UErrorCode(status, U_ZERO_ERROR); u_charsToUChars(expect,uExpect,(int32_t)uprv_strlen(expect)+1); if(str.compare(uExpect)!=0){ errln("Did not get the expected string for test_underscores.\n"); } } }
UBool ResourceBundleTest::testTag(const char* frag, UBool in_Root, UBool in_te, UBool in_te_IN) { int32_t failOrig = fail; // Make array from input params UBool is_in[] = { in_Root, in_te, in_te_IN }; const char* NAME[] = { "ROOT", "TE", "TE_IN" }; // Now try to load the desired items char tag[100]; UnicodeString action; int32_t i,j,actual_bundle; // int32_t row,col; int32_t index; UErrorCode status = U_ZERO_ERROR; const char* testdatapath; testdatapath=loadTestData(status); if(U_FAILURE(status)) { dataerrln("Could not load testdata.dat %s " + UnicodeString(u_errorName(status))); return FALSE; } for (i=0; i<bundles_count; ++i) { action = "Constructor for "; action += param[i].name; status = U_ZERO_ERROR; ResourceBundle theBundle( testdatapath, *param[i].locale, status); //ResourceBundle theBundle( "c:\\icu\\icu\\source\\test\\testdata\\testdata", *param[i].locale, status); CONFIRM_UErrorCode(status, param[i].expected_constructor_status, action); if(i == 5) actual_bundle = 0; /* ne -> default */ else if(i == 3) actual_bundle = 1; /* te_NE -> te */ else if(i == 4) actual_bundle = 2; /* te_IN_NE -> te_IN */ else actual_bundle = i; UErrorCode expected_resource_status = U_MISSING_RESOURCE_ERROR; for (j=e_te_IN; j>=e_Root; --j) { if (is_in[j] && param[i].inherits[j]) { if(j == actual_bundle) /* it's in the same bundle OR it's a nonexistent=default bundle (5) */ expected_resource_status = U_ZERO_ERROR; else if(j == 0) expected_resource_status = U_USING_DEFAULT_WARNING; else expected_resource_status = U_USING_FALLBACK_WARNING; break; } } UErrorCode expected_status; UnicodeString base; for (j=param[i].where; j>=0; --j) { if (is_in[j]) { base = NAME[j]; break; } } //-------------------------------------------------------------------------- // string uprv_strcpy(tag, "string_"); uprv_strcat(tag, frag); action = param[i].name; action += ".getString("; action += tag; action += ")"; status = U_ZERO_ERROR; UnicodeString string(theBundle.getStringEx(tag, status)); if(U_FAILURE(status)) { string.setTo(TRUE, kErrorUChars, kErrorLength); } CONFIRM_UErrorCode(status, expected_resource_status, action); UnicodeString expected_string(kErrorUChars); if (U_SUCCESS(status)) { expected_string = base; } CONFIRM_EQ(string, expected_string, action); //-------------------------------------------------------------------------- // array uprv_strcpy(tag, "array_"); uprv_strcat(tag, frag); action = param[i].name; action += ".get("; action += tag; action += ")"; status = U_ZERO_ERROR; ResourceBundle arrayBundle(theBundle.get(tag, status)); CONFIRM_UErrorCode(status, expected_resource_status, action); int32_t count = arrayBundle.getSize(); if (U_SUCCESS(status)) { CONFIRM_GE(count, 1, action); for (j=0; j < count; ++j) { char buf[32]; UnicodeString value(arrayBundle.getStringEx(j, status)); expected_string = base; expected_string += itoa(j,buf); CONFIRM_EQ(value, expected_string, action); } action = param[i].name; action += ".getStringEx("; action += tag; action += ")"; for (j=0; j<100; ++j) { index = count ? (randi(count * 3) - count) : (randi(200) - 100); status = U_ZERO_ERROR; string = kErrorUChars; UnicodeString t(arrayBundle.getStringEx(index, status)); expected_status = (index >= 0 && index < count) ? expected_resource_status : U_MISSING_RESOURCE_ERROR; CONFIRM_UErrorCode(status, expected_status, action); if (U_SUCCESS(status)) { char buf[32]; expected_string = base; expected_string += itoa(index,buf); } else { expected_string = kErrorUChars; } CONFIRM_EQ(string, expected_string, action); } } else if (status != expected_resource_status) { record_fail("Error getting " + (UnicodeString)tag); return (UBool)(failOrig != fail); } } return (UBool)(failOrig != fail); }