// TODO: add operator== and != to ResourceBundle static UBool equalRB(ResourceBundle &a, ResourceBundle &b) { UResType type; UErrorCode status; type=a.getType(); status=U_ZERO_ERROR; return type==b.getType() && a.getLocale()==b.getLocale() && 0==strcmp(a.getName(), b.getName()) && type==URES_STRING ? a.getString(status)==b.getString(status) : type==URES_INT ? a.getInt(status)==b.getInt(status) : TRUE; }
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::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"); } } }