AuroraMiddleware/scuffed-code
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
26775d7d13
scuffed-code/icu4c/source/test/intltest/restest.cpp
Fredrik Roubert b4b2378931 ICU-20601 Wrap ICU test compound macros in do { } while. 
This does the same for the ICU test code as was done for the
public ICU API in commit 480bec3ea6.
2019-08-15 22:01:42 +02:00

658 lines
20 KiB
C++
Raw Blame History

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/********************************************************************
* COPYRIGHT:
* Copyright (c) 1997-2016, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
#include "unicode/utypes.h"
#include "cmemory.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;
//***************************************************************************************
enum E_Where
{
e_Root,
e_te,
e_te_IN,
e_Where_count
};
//***************************************************************************************
#define CONFIRM_EQ(actual, expected, myAction) UPRV_BLOCK_MACRO_BEGIN { \
if ((expected)==(actual)) { \
record_pass(myAction); \
} else { \
record_fail(myAction + (UnicodeString)" returned " + (actual) + (UnicodeString)" instead of " + (expected) + "\n"); \
} \
} UPRV_BLOCK_MACRO_END
#define CONFIRM_GE(actual, expected, myAction) UPRV_BLOCK_MACRO_BEGIN { \
if ((actual)>=(expected)) { \
record_pass(myAction); \
} else { \
record_fail(myAction + (UnicodeString)" returned " + (actual) + (UnicodeString)" instead of x >= " + (expected) + "\n"); \
} \
} UPRV_BLOCK_MACRO_END
#define CONFIRM_NE(actual, expected, myAction) UPRV_BLOCK_MACRO_BEGIN { \
if ((expected)!=(actual)) { \
record_pass(myAction); \
} else { \
record_fail(myAction + (UnicodeString)" returned " + (actual) + (UnicodeString)" instead of x != " + (expected) + "\n"); \
} \
} UPRV_BLOCK_MACRO_END
#define CONFIRM_UErrorCode(actual, expected, myAction) UPRV_BLOCK_MACRO_BEGIN { \
if ((expected)==(actual)) { \
record_pass(myAction); \
} else { \
record_fail(myAction + (UnicodeString)" returned " + u_errorName(actual) + " instead of " + u_errorName(expected) + "\n"); \
} \
} UPRV_BLOCK_MACRO_END
//***************************************************************************************
/**
* 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 = UPRV_LENGTHOF(param);
//***************************************************************************************
/**
* 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 < UPRV_LENGTHOF(param); 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 < UPRV_LENGTHOF(test); 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", "" },
{ "te_IN_BLAH_01234567890_01234567890_01234567890_01234567890_01234567890_01234567890", "array_2d_only_in_Root", "te_IN", "" },
{ "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 < UPRV_LENGTHOF(test); 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(U_SUCCESS(status) && locale != Locale::getDefault()) {
err("Expected requested locale to be %s. Got %s\n", test[i].requestedLocale, locale.getName());
}
status = U_ZERO_ERROR;
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());
}
}
}
Reference in New Issue View Git Blame Copy Permalink