[apple/icu.git] / icuSources / test / intltest / restest.cpp

/********************************************************************
 * COPYRIGHT: 
 * Copyright (c) 1997-2009, International Business Machines Corporation and
 * others. All Rights Reserved.
 ********************************************************************/

#include "unicode/utypes.h"

#include "cstring.h"
#include "unicode/unistr.h"
#include "unicode/uniset.h"
#include "unicode/resbund.h"
#include "restest.h"

#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <limits.h>

//***************************************************************************************

static const UChar kErrorUChars[] = { 0x45, 0x52, 0x52, 0x4f, 0x52, 0 };
static const int32_t kErrorLength = 5;
static const int32_t kERROR_COUNT = -1234567;

//***************************************************************************************

enum E_Where
{
    e_Root,
    e_te,
    e_te_IN,
    e_Where_count
};

//***************************************************************************************

#define CONFIRM_EQ(actual, expected, myAction) if ((expected)==(actual)) { record_pass(myAction); } else { record_fail(myAction + (UnicodeString)" returned " + (actual) + (UnicodeString)" instead of " + (expected) + "\n");}
#define CONFIRM_GE(actual, expected, myAction) if ((actual)>=(expected)) { record_pass(myAction); } else { record_fail(myAction + (UnicodeString)" returned " + (actual) + (UnicodeString)" instead of x >= " + (expected) + "\n");}
#define CONFIRM_NE(actual, expected, myAction) if ((expected)!=(actual)) { record_pass(myAction); } else { record_fail(myAction + (UnicodeString)" returned " + (actual) + (UnicodeString)" instead of x != " + (expected) + "\n");}

#define CONFIRM_UErrorCode(actual, expected, myAction) if ((expected)==(actual)) { record_pass(myAction); } else { record_fail(myAction + (UnicodeString)" returned " + u_errorName(actual) + " instead of " + u_errorName(expected) + "\n"); }

//***************************************************************************************

/**
 * Convert an integer, positive or negative, to a character string radix 10.
 */
char*
itoa(int32_t i, char* buf)
{
    char* result = buf;

    // Handle negative
    if (i < 0)
    {
        *buf++ = '-';
        i = -i;
    }

    // Output digits in reverse order
    char* p = buf;
    do
    {
        *p++ = (char)('0' + (i % 10));
        i /= 10;
    }
    while (i);
    *p-- = 0;

    // Reverse the string
    while (buf < p)
    {
        char c = *buf;
        *buf++ = *p;
        *p-- = c;
    }

    return result;
}


//***************************************************************************************

// Array of our test objects

static struct
{
    const char* name;
    Locale *locale;
    UErrorCode expected_constructor_status;
    E_Where where;
    UBool like[e_Where_count];
    UBool inherits[e_Where_count];
}
param[] =
{
    // "te" means test
    // "IN" means inherits
    // "NE" or "ne" means "does not exist"

    { "root",       NULL,   U_ZERO_ERROR,             e_Root,      { TRUE, FALSE, FALSE }, { TRUE, FALSE, FALSE } },
    { "te",         NULL,   U_ZERO_ERROR,             e_te,        { FALSE, TRUE, FALSE }, { TRUE, TRUE, FALSE } },
    { "te_IN",      NULL,   U_ZERO_ERROR,             e_te_IN,     { FALSE, FALSE, TRUE }, { TRUE, TRUE, TRUE } },
    { "te_NE",      NULL,   U_USING_FALLBACK_WARNING, e_te,        { FALSE, TRUE, FALSE }, { TRUE, TRUE, FALSE } },
    { "te_IN_NE",   NULL,   U_USING_FALLBACK_WARNING, e_te_IN,     { FALSE, FALSE, TRUE }, { TRUE, TRUE, TRUE } },
    { "ne",         NULL,   U_USING_DEFAULT_WARNING,  e_Root,      { TRUE, FALSE, FALSE }, { TRUE, FALSE, FALSE } }
};

static const int32_t bundles_count = sizeof(param) / sizeof(param[0]);

//***************************************************************************************

/**
 * Return a random unsigned long l where 0N <= l <= ULONG_MAX.
 */

uint32_t
randul()
{
    static UBool initialized = FALSE;
    if (!initialized)
    {
        srand((unsigned)time(NULL));
        initialized = TRUE;
    }
    // Assume rand has at least 12 bits of precision
    uint32_t l = 0;
    for (uint32_t i=0; i<sizeof(l); ++i)
        ((char*)&l)[i] = (char)((rand() & 0x0FF0) >> 4);
    return l;
}

/**
 * Return a random double x where 0.0 <= x < 1.0.
 */
double
randd()
{
    return (double)(randul() / ULONG_MAX);
}

/**
 * Return a random integer i where 0 <= i < n.
 */
int32_t randi(int32_t n)
{
    return (int32_t)(randd() * n);
}

//***************************************************************************************

/*
 Don't use more than one of these at a time because of the Locale names
*/
ResourceBundleTest::ResourceBundleTest()
: pass(0),
  fail(0)
{
    if (param[5].locale == NULL) {
        param[0].locale = new Locale("root");
        param[1].locale = new Locale("te");
        param[2].locale = new Locale("te", "IN");
        param[3].locale = new Locale("te", "NE");
        param[4].locale = new Locale("te", "IN", "NE");
        param[5].locale = new Locale("ne");
    }
}

ResourceBundleTest::~ResourceBundleTest()
{
    if (param[5].locale) {
        int idx;
        for (idx = 0; idx < (int)(sizeof(param)/sizeof(param[0])); idx++) {
            delete param[idx].locale;
            param[idx].locale = NULL;
        }
    }
}

void ResourceBundleTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
{
    if (exec) logln("TestSuite ResourceBundleTest: ");
    switch (index) {
#if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION
    case 0: name = "TestResourceBundles"; if (exec) TestResourceBundles(); break;
    case 1: name = "TestConstruction"; if (exec) TestConstruction(); break;
    case 2: name = "TestGetSize"; if (exec) TestGetSize(); break;
    case 3: name = "TestGetLocaleByType"; if (exec) TestGetLocaleByType(); break;
#else
    case 0: case 1: case 2: case 3: name = "skip"; break;
#endif

    case 4: name = "TestExemplar"; if (exec) TestExemplar(); break;
        default: name = ""; break; //needed to end loop
    }
}

//***************************************************************************************

void
ResourceBundleTest::TestResourceBundles()
{
    UErrorCode status = U_ZERO_ERROR;

    loadTestData(status);
    if(U_FAILURE(status))
    {
        dataerrln("Could not load testdata.dat %s " + UnicodeString(u_errorName(status)));
        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"), status);
    }

    testTag("only_in_Root", TRUE, FALSE, FALSE);
    testTag("only_in_te", FALSE, TRUE, FALSE);
    testTag("only_in_te_IN", FALSE, FALSE, TRUE);
    testTag("in_Root_te", TRUE, TRUE, FALSE);
    testTag("in_Root_te_te_IN", TRUE, TRUE, TRUE);
    testTag("in_Root_te_IN", TRUE, FALSE, TRUE);
    testTag("in_te_te_IN", FALSE, TRUE, TRUE);
    testTag("nonexistent", FALSE, FALSE, FALSE);
    logln("Passed: %d\nFailed: %d", pass, fail);

    /* Restore the default locale for the other tests. */
    Locale::setDefault(originalDefault, status);
}

void
ResourceBundleTest::TestConstruction()
{
    UErrorCode   err = U_ZERO_ERROR;
    Locale       locale("te", "IN");

    const char* testdatapath=loadTestData(err);
    if(U_FAILURE(err))
    {
        dataerrln("Could not load testdata.dat " + UnicodeString(testdatapath) +  ", " + 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);
    }

    ResourceBundle  test1((UnicodeString)testdatapath, err);
    ResourceBundle  test2(testdatapath, locale, err);
    //ResourceBundle  test1("c:\\icu\\icu\\source\\test\\testdata\\testdata", err);
    //ResourceBundle  test2("c:\\icu\\icu\\source\\test\\testdata\\testdata", locale, err);

    UnicodeString   result1(test1.getStringEx("string_in_Root_te_te_IN", err));
    UnicodeString   result2(test2.getStringEx("string_in_Root_te_te_IN", err));

    if (U_FAILURE(err)) {
        errln("Something threw an error in TestConstruction()");
        return;
    }

    logln("for string_in_Root_te_te_IN, default.txt had " + result1);
    logln("for string_in_Root_te_te_IN, te_IN.txt had " + result2);

    if (result1 != "ROOT" || result2 != "TE_IN")
        errln("Construction test failed; run verbose for more information");

    const char* version1;
    const char* version2;

    version1 = test1.getVersionNumber();
    version2 = test2.getVersionNumber();

    char *versionID1 = new char[1+strlen(version1)]; // + 1 for zero byte
    char *versionID2 = new char[1+ strlen(version2)]; // + 1 for zero byte

    strcpy(versionID1, "44.0");  // hardcoded, please change if the default.txt file or ResourceBundle::kVersionSeparater is changed.

    strcpy(versionID2, "55.0");  // hardcoded, please change if the te_IN.txt file or ResourceBundle::kVersionSeparater is changed.

    logln(UnicodeString("getVersionNumber on default.txt returned ") + version1);
    logln(UnicodeString("getVersionNumber on te_IN.txt returned ") + version2);

    if (strcmp(version1, versionID1) != 0 || strcmp(version2, versionID2) != 0)
        errln("getVersionNumber() failed");

    delete[] versionID1;
    delete[] versionID2;

    /* Restore the default locale for the other tests. */
    Locale::setDefault(originalDefault, err);
}

//***************************************************************************************

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);
}

void
ResourceBundleTest::record_pass(UnicodeString passMessage)
{
    logln(passMessage);
    ++pass;
}
void
ResourceBundleTest::record_fail(UnicodeString errMessage)
{
    err(errMessage);
    ++fail;
}

void
ResourceBundleTest::TestExemplar(){

    int32_t locCount = uloc_countAvailable();
    int32_t locIndex=0;
    int num=0;
    UErrorCode status = U_ZERO_ERROR;
    for(;locIndex<locCount;locIndex++){
        const char* locale = uloc_getAvailable(locIndex);
        UResourceBundle *resb =ures_open(NULL,locale,&status);
        if(U_SUCCESS(status) && status!=U_USING_FALLBACK_WARNING && status!=U_USING_DEFAULT_WARNING){
            int32_t len=0;
            const UChar* strSet = ures_getStringByKey(resb,"ExemplarCharacters",&len,&status);
            UnicodeSet set(strSet,status);
            if(U_FAILURE(status)){
                errln("Could not construct UnicodeSet from pattern for ExemplarCharacters in locale : %s. Error: %s",locale,u_errorName(status));
                status=U_ZERO_ERROR;
            }
            num++;
        }
        ures_close(resb);
    }
    logln("Number of installed locales with exemplar characters that could be tested: %d",num);

}

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());
            }
        }
    }
}

void 
ResourceBundleTest::TestGetLocaleByType(void) 
{
    const struct {
        const char *requestedLocale;
        const char *resourceKey;
        const char *validLocale;
        const char *actualLocale;
    } test[] = {
        { "te_IN_BLAH", "string_only_in_te_IN", "te_IN", "te_IN" },
        { "te_IN_BLAH", "string_only_in_te", "te_IN", "te" },
        { "te_IN_BLAH", "string_only_in_Root", "te_IN", "root" },
        { "te_IN_BLAH_01234567890_01234567890_01234567890_01234567890_01234567890_01234567890", "array_2d_only_in_Root", "te_IN", "root" },
        { "te_IN_BLAH@currency=euro", "array_2d_only_in_te_IN", "te_IN", "te_IN" },
        { "te_IN_BLAH@calendar=thai;collation=phonebook", "array_2d_only_in_te", "te_IN", "te" }
    };
    
    UErrorCode status = U_ZERO_ERROR;
    
    const char* testdatapath = loadTestData(status);
    int32_t i = 0;
    Locale locale;
    
    if(U_FAILURE(status))
    {
        dataerrln("Could not load testdata.dat %s\n", u_errorName(status));
        return;
    }
    
    for(i = 0; i < (int32_t)(sizeof(test)/sizeof(test[0])); i++) {
        ResourceBundle rb(testdatapath, test[i].requestedLocale, status);
        if(U_FAILURE(status))
        {
            err("Could not open resource bundle %s (error %s)\n", test[i].requestedLocale, u_errorName(status));
            status = U_ZERO_ERROR;
            continue;
        }
        
        ResourceBundle res = rb.get(test[i].resourceKey, status);
        if(U_FAILURE(status))
        {
            err("Couldn't find the key %s. Error: %s\n", test[i].resourceKey, u_errorName(status));
            status = U_ZERO_ERROR;
            continue;
        }
        
        locale = res.getLocale(ULOC_REQUESTED_LOCALE, status);
        if(locale != Locale::getDefault()) {
            err("Expected requested locale to be %s. Got %s\n", test[i].requestedLocale, locale.getName());
        }
        locale = res.getLocale(ULOC_VALID_LOCALE, status);
        if(strcmp(locale.getName(), test[i].validLocale) != 0) {
            err("Expected valid locale to be %s. Got %s\n", test[i].requestedLocale, locale.getName());
        }
        locale = res.getLocale(ULOC_ACTUAL_LOCALE, status);
        if(strcmp(locale.getName(), test[i].actualLocale) != 0) {
            err("Expected actual locale to be %s. Got %s\n", test[i].requestedLocale, locale.getName());
        }
    }
}

//eof
Commit	Line	Data
b75a7d8f A	1	/********************************************************************
b75a7d8f A	2	* COPYRIGHT:
729e4ab9	3	* Copyright (c) 1997-2009, International Business Machines Corporation and
b75a7d8f A	4	* others. All Rights Reserved.
	5	********************************************************************/
	6
	7	#include "unicode/utypes.h"
	8
	9	#include "cstring.h"
	10	#include "unicode/unistr.h"
	11	#include "unicode/uniset.h"
	12	#include "unicode/resbund.h"
	13	#include "restest.h"
	14
	15	#include <stdlib.h>
	16	#include <time.h>
	17	#include <string.h>
	18	#include <limits.h>
	19
	20	//***************************************************************************************
	21
	22	static const UChar kErrorUChars[] = { 0x45, 0x52, 0x52, 0x4f, 0x52, 0 };
	23	static const int32_t kErrorLength = 5;
	24	static const int32_t kERROR_COUNT = -1234567;
	25
	26	//***************************************************************************************
	27
	28	enum E_Where
	29	{
	30	e_Root,
	31	e_te,
	32	e_te_IN,
	33	e_Where_count
	34	};
	35
	36	//***************************************************************************************
	37
	38	#define CONFIRM_EQ(actual, expected, myAction) if ((expected)==(actual)) { record_pass(myAction); } else { record_fail(myAction + (UnicodeString)" returned " + (actual) + (UnicodeString)" instead of " + (expected) + "\n");}
	39	#define CONFIRM_GE(actual, expected, myAction) if ((actual)>=(expected)) { record_pass(myAction); } else { record_fail(myAction + (UnicodeString)" returned " + (actual) + (UnicodeString)" instead of x >= " + (expected) + "\n");}
	40	#define CONFIRM_NE(actual, expected, myAction) if ((expected)!=(actual)) { record_pass(myAction); } else { record_fail(myAction + (UnicodeString)" returned " + (actual) + (UnicodeString)" instead of x != " + (expected) + "\n");}
	41
	42	#define CONFIRM_UErrorCode(actual, expected, myAction) if ((expected)==(actual)) { record_pass(myAction); } else { record_fail(myAction + (UnicodeString)" returned " + u_errorName(actual) + " instead of " + u_errorName(expected) + "\n"); }
	43
	44	//***************************************************************************************
	45
	46	/**
	47	* Convert an integer, positive or negative, to a character string radix 10.
	48	*/
	49	char*
	50	itoa(int32_t i, char* buf)
	51	{
	52	char* result = buf;
	53
	54	// Handle negative
	55	if (i < 0)
	56	{
	57	*buf++ = '-';
	58	i = -i;
	59	}
	60
	61	// Output digits in reverse order
	62	char* p = buf;
	63	do
	64	{
	65	*p++ = (char)('0' + (i % 10));
	66	i /= 10;
	67	}
68	while (i);
69	*p-- = 0;
70
71	// Reverse the string
72	while (buf < p)
73	{
74	char c = *buf;
75	buf++ = p;
76	*p-- = c;
77	}
78
79	return result;
80	}
81
82
83
84	//***************************************************************************************
85
86	// Array of our test objects
87
4648c0c3	88	static struct
b75a7d8f A	89	{
	90	const char* name;
	91	Locale *locale;
	92	UErrorCode expected_constructor_status;
	93	E_Where where;
	94	UBool like[e_Where_count];
	95	UBool inherits[e_Where_count];
	96	}
	97	param[] =
	98	{
	99	// "te" means test
	100	// "IN" means inherits
	101	// "NE" or "ne" means "does not exist"
	102
	103	{ "root", NULL, U_ZERO_ERROR, e_Root, { TRUE, FALSE, FALSE }, { TRUE, FALSE, FALSE } },
	104	{ "te", NULL, U_ZERO_ERROR, e_te, { FALSE, TRUE, FALSE }, { TRUE, TRUE, FALSE } },
	105	{ "te_IN", NULL, U_ZERO_ERROR, e_te_IN, { FALSE, FALSE, TRUE }, { TRUE, TRUE, TRUE } },
	106	{ "te_NE", NULL, U_USING_FALLBACK_WARNING, e_te, { FALSE, TRUE, FALSE }, { TRUE, TRUE, FALSE } },
	107	{ "te_IN_NE", NULL, U_USING_FALLBACK_WARNING, e_te_IN, { FALSE, FALSE, TRUE }, { TRUE, TRUE, TRUE } },
	108	{ "ne", NULL, U_USING_DEFAULT_WARNING, e_Root, { TRUE, FALSE, FALSE }, { TRUE, FALSE, FALSE } }
	109	};
	110
4648c0c3	111	static const int32_t bundles_count = sizeof(param) / sizeof(param[0]);
b75a7d8f A	112
	113	//***************************************************************************************
	114
	115	/**
	116	* Return a random unsigned long l where 0N <= l <= ULONG_MAX.
	117	*/
	118
	119	uint32_t
	120	randul()
	121	{
	122	static UBool initialized = FALSE;
	123	if (!initialized)
	124	{
	125	srand((unsigned)time(NULL));
	126	initialized = TRUE;
	127	}
	128	// Assume rand has at least 12 bits of precision
	129	uint32_t l = 0;
	130	for (uint32_t i=0; i<sizeof(l); ++i)
	131	((char*)&l)[i] = (char)((rand() & 0x0FF0) >> 4);
	132	return l;
	133	}
	134
	135	/**
	136	* Return a random double x where 0.0 <= x < 1.0.
	137	*/
	138	double
	139	randd()
	140	{
	141	return (double)(randul() / ULONG_MAX);
	142	}
	143
	144	/**
	145	* Return a random integer i where 0 <= i < n.
	146	*/
	147	int32_t randi(int32_t n)
	148	{
	149	return (int32_t)(randd() * n);
	150	}
	151
	152	//***************************************************************************************
	153
	154	/*
	155	Don't use more than one of these at a time because of the Locale names
	156	*/
	157	ResourceBundleTest::ResourceBundleTest()
	158	: pass(0),
374ca955	159	fail(0)
b75a7d8f A	160	{
	161	if (param[5].locale == NULL) {
	162	param[0].locale = new Locale("root");
	163	param[1].locale = new Locale("te");
	164	param[2].locale = new Locale("te", "IN");
	165	param[3].locale = new Locale("te", "NE");
	166	param[4].locale = new Locale("te", "IN", "NE");
	167	param[5].locale = new Locale("ne");
	168	}
	169	}
	170
	171	ResourceBundleTest::~ResourceBundleTest()
	172	{
	173	if (param[5].locale) {
	174	int idx;
	175	for (idx = 0; idx < (int)(sizeof(param)/sizeof(param[0])); idx++) {
	176	delete param[idx].locale;
	177	param[idx].locale = NULL;
	178	}
	179	}
	180	}
	181
	182	void ResourceBundleTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /par/ )
	183	{
	184	if (exec) logln("TestSuite ResourceBundleTest: ");
	185	switch (index) {
729e4ab9	186	#if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION
b75a7d8f A	187	case 0: name = "TestResourceBundles"; if (exec) TestResourceBundles(); break;
b75a7d8f A	188	case 1: name = "TestConstruction"; if (exec) TestConstruction(); break;
729e4ab9 A	189	case 2: name = "TestGetSize"; if (exec) TestGetSize(); break;
	190	case 3: name = "TestGetLocaleByType"; if (exec) TestGetLocaleByType(); break;
	191	#else
	192	case 0: case 1: case 2: case 3: name = "skip"; break;
	193	#endif
	194
	195	case 4: name = "TestExemplar"; if (exec) TestExemplar(); break;
b75a7d8f A	196	default: name = ""; break; //needed to end loop
	197	}
	198	}
	199
	200	//***************************************************************************************
	201
	202	void
	203	ResourceBundleTest::TestResourceBundles()
	204	{
46f4442e A	205	UErrorCode status = U_ZERO_ERROR;
	206
	207	loadTestData(status);
	208	if(U_FAILURE(status))
	209	{
729e4ab9	210	dataerrln("Could not load testdata.dat %s " + UnicodeString(u_errorName(status)));
46f4442e A	211	return;
	212	}
	213
	214	/* Make sure that users using te_IN for the default locale don't get test failures. */
	215	Locale originalDefault;
	216	if (Locale::getDefault() == Locale("te_IN")) {
	217	Locale::setDefault(Locale("en_US"), status);
	218	}
	219
b75a7d8f A	220	testTag("only_in_Root", TRUE, FALSE, FALSE);
	221	testTag("only_in_te", FALSE, TRUE, FALSE);
	222	testTag("only_in_te_IN", FALSE, FALSE, TRUE);
	223	testTag("in_Root_te", TRUE, TRUE, FALSE);
	224	testTag("in_Root_te_te_IN", TRUE, TRUE, TRUE);
	225	testTag("in_Root_te_IN", TRUE, FALSE, TRUE);
	226	testTag("in_te_te_IN", FALSE, TRUE, TRUE);
	227	testTag("nonexistent", FALSE, FALSE, FALSE);
	228	logln("Passed: %d\nFailed: %d", pass, fail);
46f4442e A	229
	230	/* Restore the default locale for the other tests. */
	231	Locale::setDefault(originalDefault, status);
b75a7d8f A	232	}
	233
	234	void
	235	ResourceBundleTest::TestConstruction()
	236	{
46f4442e A	237	UErrorCode err = U_ZERO_ERROR;
	238	Locale locale("te", "IN");
	239
	240	const char* testdatapath=loadTestData(err);
	241	if(U_FAILURE(err))
b75a7d8f	242	{
729e4ab9	243	dataerrln("Could not load testdata.dat " + UnicodeString(testdatapath) + ", " + UnicodeString(u_errorName(err)));
46f4442e A	244	return;
46f4442e A	245	}
b75a7d8f	246
46f4442e A	247	/* Make sure that users using te_IN for the default locale don't get test failures. */
	248	Locale originalDefault;
	249	if (Locale::getDefault() == Locale("te_IN")) {
	250	Locale::setDefault(Locale("en_US"), err);
	251	}
b75a7d8f	252
46f4442e A	253	ResourceBundle test1((UnicodeString)testdatapath, err);
	254	ResourceBundle test2(testdatapath, locale, err);
	255	//ResourceBundle test1("c:\\icu\\icu\\source\\test\\testdata\\testdata", err);
	256	//ResourceBundle test2("c:\\icu\\icu\\source\\test\\testdata\\testdata", locale, err);
b75a7d8f	257
46f4442e A	258	UnicodeString result1(test1.getStringEx("string_in_Root_te_te_IN", err));
	259	UnicodeString result2(test2.getStringEx("string_in_Root_te_te_IN", err));
	260
	261	if (U_FAILURE(err)) {
	262	errln("Something threw an error in TestConstruction()");
	263	return;
	264	}
b75a7d8f	265
46f4442e A	266	logln("for string_in_Root_te_te_IN, default.txt had " + result1);
46f4442e A	267	logln("for string_in_Root_te_te_IN, te_IN.txt had " + result2);
b75a7d8f	268
46f4442e A	269	if (result1 != "ROOT" \|\| result2 != "TE_IN")
46f4442e A	270	errln("Construction test failed; run verbose for more information");
b75a7d8f	271
46f4442e A	272	const char* version1;
46f4442e A	273	const char* version2;
b75a7d8f	274
46f4442e A	275	version1 = test1.getVersionNumber();
46f4442e A	276	version2 = test2.getVersionNumber();
b75a7d8f	277
46f4442e A	278	char *versionID1 = new char[1+strlen(version1)]; // + 1 for zero byte
46f4442e A	279	char *versionID2 = new char[1+ strlen(version2)]; // + 1 for zero byte
b75a7d8f	280
46f4442e	281	strcpy(versionID1, "44.0"); // hardcoded, please change if the default.txt file or ResourceBundle::kVersionSeparater is changed.
b75a7d8f	282
46f4442e	283	strcpy(versionID2, "55.0"); // hardcoded, please change if the te_IN.txt file or ResourceBundle::kVersionSeparater is changed.
b75a7d8f	284
46f4442e A	285	logln(UnicodeString("getVersionNumber on default.txt returned ") + version1);
46f4442e A	286	logln(UnicodeString("getVersionNumber on te_IN.txt returned ") + version2);
b75a7d8f	287
46f4442e A	288	if (strcmp(version1, versionID1) != 0 \|\| strcmp(version2, versionID2) != 0)
46f4442e A	289	errln("getVersionNumber() failed");
b75a7d8f	290
46f4442e A	291	delete[] versionID1;
	292	delete[] versionID2;
	293
	294	/* Restore the default locale for the other tests. */
	295	Locale::setDefault(originalDefault, err);
b75a7d8f A	296	}
	297
	298	//***************************************************************************************
	299
	300	UBool
	301	ResourceBundleTest::testTag(const char* frag,
	302	UBool in_Root,
	303	UBool in_te,
	304	UBool in_te_IN)
	305	{
	306	int32_t failOrig = fail;
	307
	308	// Make array from input params
	309
	310	UBool is_in[] = { in_Root, in_te, in_te_IN };
	311
	312	const char* NAME[] = { "ROOT", "TE", "TE_IN" };
	313
	314	// Now try to load the desired items
	315
	316	char tag[100];
	317	UnicodeString action;
	318
	319	int32_t i,j,actual_bundle;
	320	// int32_t row,col;
	321	int32_t index;
	322	UErrorCode status = U_ZERO_ERROR;
	323	const char* testdatapath;
	324	testdatapath=loadTestData(status);
	325	if(U_FAILURE(status))
	326	{
729e4ab9	327	dataerrln("Could not load testdata.dat %s " + UnicodeString(u_errorName(status)));
b75a7d8f A	328	return FALSE;
	329	}
	330
	331	for (i=0; i<bundles_count; ++i)
	332	{
	333	action = "Constructor for ";
	334	action += param[i].name;
	335
	336	status = U_ZERO_ERROR;
	337	ResourceBundle theBundle( testdatapath, *param[i].locale, status);
	338	//ResourceBundle theBundle( "c:\\icu\\icu\\source\\test\\testdata\\testdata", *param[i].locale, status);
	339	CONFIRM_UErrorCode(status, param[i].expected_constructor_status, action);
	340
	341	if(i == 5)
	342	actual_bundle = 0; /* ne -> default */
	343	else if(i == 3)
	344	actual_bundle = 1; /* te_NE -> te */
	345	else if(i == 4)
	346	actual_bundle = 2; /* te_IN_NE -> te_IN */
	347	else
	348	actual_bundle = i;
	349
	350
	351	UErrorCode expected_resource_status = U_MISSING_RESOURCE_ERROR;
	352	for (j=e_te_IN; j>=e_Root; --j)
	353	{
	354	if (is_in[j] && param[i].inherits[j])
	355	{
	356	if(j == actual_bundle) /* it's in the same bundle OR it's a nonexistent=default bundle (5) */
	357	expected_resource_status = U_ZERO_ERROR;
	358	else if(j == 0)
	359	expected_resource_status = U_USING_DEFAULT_WARNING;
	360	else
	361	expected_resource_status = U_USING_FALLBACK_WARNING;
	362
	363	break;
	364	}
	365	}
	366
	367	UErrorCode expected_status;
	368
	369	UnicodeString base;
	370	for (j=param[i].where; j>=0; --j)
	371	{
	372	if (is_in[j])
	373	{
	374	base = NAME[j];
	375	break;
	376	}
	377	}
	378
	379	//--------------------------------------------------------------------------
	380	// string
	381
	382	uprv_strcpy(tag, "string_");
	383	uprv_strcat(tag, frag);
	384
	385	action = param[i].name;
	386	action += ".getString(";
	387	action += tag;
	388	action += ")";
	389
	390
	391	status = U_ZERO_ERROR;
392
393	UnicodeString string(theBundle.getStringEx(tag, status));
394
395	if(U_FAILURE(status)) {
396	string.setTo(TRUE, kErrorUChars, kErrorLength);
397	}
398
399	CONFIRM_UErrorCode(status, expected_resource_status, action);
400
401	UnicodeString expected_string(kErrorUChars);
402	if (U_SUCCESS(status)) {
403	expected_string = base;
404	}
405
406	CONFIRM_EQ(string, expected_string, action);
407
408	//--------------------------------------------------------------------------
409	// array
410
411	uprv_strcpy(tag, "array_");
412	uprv_strcat(tag, frag);
413
414	action = param[i].name;
415	action += ".get(";
416	action += tag;
417	action += ")";
418
419	status = U_ZERO_ERROR;
420	ResourceBundle arrayBundle(theBundle.get(tag, status));
421	CONFIRM_UErrorCode(status, expected_resource_status, action);
422	int32_t count = arrayBundle.getSize();
423
424	if (U_SUCCESS(status))
425	{
426	CONFIRM_GE(count, 1, action);
427
428	for (j=0; j < count; ++j)
429	{
430	char buf[32];
431	UnicodeString value(arrayBundle.getStringEx(j, status));
432	expected_string = base;
433	expected_string += itoa(j,buf);
434	CONFIRM_EQ(value, expected_string, action);
435	}
436
437	action = param[i].name;
438	action += ".getStringEx(";
439	action += tag;
440	action += ")";
441
442	for (j=0; j<100; ++j)
443	{
444	index = count ? (randi(count * 3) - count) : (randi(200) - 100);
445	status = U_ZERO_ERROR;
446	string = kErrorUChars;
447	UnicodeString t(arrayBundle.getStringEx(index, status));
448	expected_status = (index >= 0 && index < count) ? expected_resource_status : U_MISSING_RESOURCE_ERROR;
449	CONFIRM_UErrorCode(status, expected_status, action);
450
451	if (U_SUCCESS(status))
452	{
453	char buf[32];
454	expected_string = base;
455	expected_string += itoa(index,buf);
456	}
457	else
458	{
459	expected_string = kErrorUChars;
460	}
461	CONFIRM_EQ(string, expected_string, action);
462	}
463	}
464	else if (status != expected_resource_status)
465	{
466	record_fail("Error getting " + (UnicodeString)tag);
467	return (UBool)(failOrig != fail);
468	}
469
470	}
471
472	return (UBool)(failOrig != fail);
473	}
474
475	void
476	ResourceBundleTest::record_pass(UnicodeString passMessage)
477	{
478	logln(passMessage);
479	++pass;
480	}
481	void
482	ResourceBundleTest::record_fail(UnicodeString errMessage)
483	{
484	err(errMessage);
485	++fail;
486	}
487
488	void
489	ResourceBundleTest::TestExemplar(){
490
491	int32_t locCount = uloc_countAvailable();
492	int32_t locIndex=0;
493	int num=0;
494	UErrorCode status = U_ZERO_ERROR;
495	for(;locIndex<locCount;locIndex++){
496	const char* locale = uloc_getAvailable(locIndex);
497	UResourceBundle *resb =ures_open(NULL,locale,&status);
498	if(U_SUCCESS(status) && status!=U_USING_FALLBACK_WARNING && status!=U_USING_DEFAULT_WARNING){
499	int32_t len=0;
500	const UChar* strSet = ures_getStringByKey(resb,"ExemplarCharacters",&len,&status);
501	UnicodeSet set(strSet,status);
502	if(U_FAILURE(status)){
503	errln("Could not construct UnicodeSet from pattern for ExemplarCharacters in locale : %s. Error: %s",locale,u_errorName(status));
504	status=U_ZERO_ERROR;
505	}
506	num++;
507	}
508	ures_close(resb);
509	}
510	logln("Number of installed locales with exemplar characters that could be tested: %d",num);
511
512	}
374ca955 A	513
	514	void
	515	ResourceBundleTest::TestGetSize(void)
	516	{
	517	const struct {
	518	const char* key;
	519	int32_t size;
	520	} test[] = {
	521	{ "zerotest", 1},
	522	{ "one", 1},
	523	{ "importtest", 1},
	524	{ "integerarray", 1},
	525	{ "emptyarray", 0},
	526	{ "emptytable", 0},
	527	{ "emptystring", 1}, /* empty string is still a string */
	528	{ "emptyint", 1},
	529	{ "emptybin", 1},
	530	{ "testinclude", 1},
	531	{ "collations", 1}, /* not 2 - there is hidden %%CollationBin */
	532	};
	533
	534	UErrorCode status = U_ZERO_ERROR;
	535
	536	const char* testdatapath = loadTestData(status);
	537	int32_t i = 0, j = 0;
	538	int32_t size = 0;
	539
	540	if(U_FAILURE(status))
	541	{
729e4ab9	542	dataerrln("Could not load testdata.dat %s\n", u_errorName(status));
374ca955 A	543	return;
	544	}
	545
	546	ResourceBundle rb(testdatapath, "testtypes", status);
	547	if(U_FAILURE(status))
	548	{
	549	err("Could not testtypes resource bundle %s\n", u_errorName(status));
	550	return;
	551	}
	552
	553	for(i = 0; i < (int32_t)(sizeof(test)/sizeof(test[0])); i++) {
	554	ResourceBundle res = rb.get(test[i].key, status);
	555	if(U_FAILURE(status))
	556	{
	557	err("Couldn't find the key %s. Error: %s\n", u_errorName(status));
	558	return;
	559	}
	560	size = res.getSize();
	561	if(size != test[i].size) {
	562	err("Expected size %i, got size %i for key %s\n", test[i].size, size, test[i].key);
	563	for(j = 0; j < size; j++) {
	564	ResourceBundle helper = res.get(j, status);
	565	err("%s\n", helper.getKey());
	566	}
	567	}
	568	}
	569	}
	570
	571	void
	572	ResourceBundleTest::TestGetLocaleByType(void)
	573	{
	574	const struct {
	575	const char *requestedLocale;
	576	const char *resourceKey;
	577	const char *validLocale;
	578	const char *actualLocale;
	579	} test[] = {
	580	{ "te_IN_BLAH", "string_only_in_te_IN", "te_IN", "te_IN" },
	581	{ "te_IN_BLAH", "string_only_in_te", "te_IN", "te" },
	582	{ "te_IN_BLAH", "string_only_in_Root", "te_IN", "root" },
	583	{ "te_IN_BLAH_01234567890_01234567890_01234567890_01234567890_01234567890_01234567890", "array_2d_only_in_Root", "te_IN", "root" },
	584	{ "te_IN_BLAH@currency=euro", "array_2d_only_in_te_IN", "te_IN", "te_IN" },
	585	{ "te_IN_BLAH@calendar=thai;collation=phonebook", "array_2d_only_in_te", "te_IN", "te" }
	586	};
	587
	588	UErrorCode status = U_ZERO_ERROR;
	589
	590	const char* testdatapath = loadTestData(status);
	591	int32_t i = 0;
	592	Locale locale;
	593
	594	if(U_FAILURE(status))
	595	{
729e4ab9	596	dataerrln("Could not load testdata.dat %s\n", u_errorName(status));
374ca955 A	597	return;
	598	}
	599
	600	for(i = 0; i < (int32_t)(sizeof(test)/sizeof(test[0])); i++) {
	601	ResourceBundle rb(testdatapath, test[i].requestedLocale, status);
	602	if(U_FAILURE(status))
	603	{
	604	err("Could not open resource bundle %s (error %s)\n", test[i].requestedLocale, u_errorName(status));
	605	status = U_ZERO_ERROR;
	606	continue;
	607	}
	608
	609	ResourceBundle res = rb.get(test[i].resourceKey, status);
	610	if(U_FAILURE(status))
	611	{
	612	err("Couldn't find the key %s. Error: %s\n", test[i].resourceKey, u_errorName(status));
	613	status = U_ZERO_ERROR;
	614	continue;
	615	}
	616
	617	locale = res.getLocale(ULOC_REQUESTED_LOCALE, status);
	618	if(locale != Locale::getDefault()) {
	619	err("Expected requested locale to be %s. Got %s\n", test[i].requestedLocale, locale.getName());
	620	}
	621	locale = res.getLocale(ULOC_VALID_LOCALE, status);
	622	if(strcmp(locale.getName(), test[i].validLocale) != 0) {
	623	err("Expected valid locale to be %s. Got %s\n", test[i].requestedLocale, locale.getName());
	624	}
	625	locale = res.getLocale(ULOC_ACTUAL_LOCALE, status);
	626	if(strcmp(locale.getName(), test[i].actualLocale) != 0) {
	627	err("Expected actual locale to be %s. Got %s\n", test[i].requestedLocale, locale.getName());
	628	}
	629	}
	630	}
	631
b75a7d8f A	632	//eof
b75a7d8f A	633