diff options
Diffstat (limited to 'Build/source/libs/icu/icu-49.1/test/intltest/restest.cpp')
-rw-r--r-- | Build/source/libs/icu/icu-49.1/test/intltest/restest.cpp | 633 |
1 files changed, 633 insertions, 0 deletions
diff --git a/Build/source/libs/icu/icu-49.1/test/intltest/restest.cpp b/Build/source/libs/icu/icu-49.1/test/intltest/restest.cpp new file mode 100644 index 00000000000..49f4de96648 --- /dev/null +++ b/Build/source/libs/icu/icu-49.1/test/intltest/restest.cpp @@ -0,0 +1,633 @@ +/******************************************************************** + * 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 + |