void
ResourceBundleTest::TestGetSize(void)
{
const struct {
const char* key;
int32_t size;
} test[] = {
{ "zerotest", 1},
{ "one", 1},
{ "importtest", 1},
{ "integerarray", 1},
{ "emptyarray", 0},
{ "emptytable", 0},
{ "emptystring", 1}, /* empty string is still a string */
{ "emptyint", 1},
{ "emptybin", 1},
{ "testinclude", 1},
{ "collations", 1}, /* not 2 - there is hidden %%CollationBin */
};
UErrorCode status = U_ZERO_ERROR;
const char* testdatapath = loadTestData(status);
int32_t i = 0, j = 0;
int32_t size = 0;
if(U_FAILURE(status))
{
dataerrln("Could not load testdata.dat %s\n", u_errorName(status));
return;
}
ResourceBundle rb(testdatapath, "testtypes", status);
if(U_FAILURE(status))
{
err("Could not testtypes resource bundle %s\n", u_errorName(status));
return;
}
for(i = 0; i < (int32_t)(sizeof(test)/sizeof(test[0])); i++) {
ResourceBundle res = rb.get(test[i].key, status);
if(U_FAILURE(status))
{
err("Couldn't find the key %s. Error: %s\n", u_errorName(status));
return;
}
size = res.getSize();
if(size != test[i].size) {
err("Expected size %i, got size %i for key %s\n", test[i].size, size, test[i].key);
for(j = 0; j < size; j++) {
ResourceBundle helper = res.get(j, status);
err("%s\n", helper.getKey());
}
}
}
}
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;
}