void T_CTEST_EXPORT2
setTestOption ( int32_t testOption, int32_t value) {
if (value == DECREMENT_OPTION_VALUE) {
value = getTestOption(testOption);
--value;
}
switch (testOption) {
case VERBOSITY_OPTION:
VERBOSITY = value;
break;
case WARN_ON_MISSING_DATA_OPTION:
WARN_ON_MISSING_DATA = value;
break;
case QUICK_OPTION:
QUICK = value;
break;
case REPEAT_TESTS_OPTION:
REPEAT_TESTS = value;
break;
case ICU_TRACE_OPTION:
ICU_TRACE = value;
break;
default :
break;
}
}
void TestConstruction1()
{
UResourceBundle *test1 = 0, *test2 = 0;
const UChar *result1, *result2;
int32_t resultLen;
UChar temp[7];
UErrorCode err = U_ZERO_ERROR;
const char* testdatapath ;
const char* locale="te_IN";
log_verbose("Testing ures_open()......\n");
testdatapath=loadTestData(&err);
if(U_FAILURE(err))
{
log_data_err("Could not load testdata.dat %s \n",myErrorName(err));
return;
}
test1=ures_open(testdatapath, NULL, &err);
if(U_FAILURE(err))
{
log_err("construction of %s did not succeed : %s \n",NULL, myErrorName(err));
return;
}
test2=ures_open(testdatapath, locale, &err);
if(U_FAILURE(err))
{
log_err("construction of %s did not succeed : %s \n",locale, myErrorName(err));
return;
}
result1= ures_getStringByKey(test1, "string_in_Root_te_te_IN", &resultLen, &err);
result2= ures_getStringByKey(test2, "string_in_Root_te_te_IN", &resultLen, &err);
if (U_FAILURE(err)) {
log_err("Something threw an error in TestConstruction(): %s\n", myErrorName(err));
return;
}
u_uastrcpy(temp, "TE_IN");
if(u_strcmp(result2, temp)!=0)
{
int n;
log_err("Construction test failed for ures_open();\n");
if(!getTestOption(VERBOSITY_OPTION))
log_info("(run verbose for more information)\n");
log_verbose("\nGot->");
for(n=0;result2[n];n++)
{
log_verbose("%04X ",result2[n]);
}
log_verbose("<\n");
log_verbose("\nWant>");
for(n=0;temp[n];n++)
{
log_verbose("%04X ",temp[n]);
}
log_verbose("<\n");
}
log_verbose("for string_in_Root_te_te_IN, default.txt had %s\n", austrdup(result1));
log_verbose("for string_in_Root_te_te_IN, te_IN.txt had %s\n", austrdup(result2));
/* Test getVersionNumber*/
log_verbose("Testing version number\n");
log_verbose("for getVersionNumber : %s\n", ures_getVersionNumber(test1));
ures_close(test1);
ures_close(test2);
}
static void TestSelector()
{
TestText text;
USet* excluded_sets[3] = { NULL };
int32_t i, testCaseIdx;
if (!getAvailableNames()) {
return;
}
if (!text_open(&text)) {
releaseAvailableNames();;
}
excluded_sets[0] = uset_openEmpty();
for(i = 1 ; i < 3 ; i++) {
excluded_sets[i] = uset_open(i*30, i*30+500);
}
for(testCaseIdx = 0; testCaseIdx < UPRV_LENGTHOF(getEncodingsFns); testCaseIdx++)
{
int32_t excluded_set_id;
int32_t num_encodings;
const char **encodings = getEncodingsFns[testCaseIdx](&num_encodings);
if (getTestOption(QUICK_OPTION) && num_encodings > 25) {
uprv_free((void *)encodings);
continue;
}
/*
* for(excluded_set_id = 0 ; excluded_set_id < 3 ; excluded_set_id++)
*
* This loop was replaced by the following statement because
* the loop made the test run longer without adding to the code coverage.
* The handling of the exclusion set is independent of the
* set of encodings, so there is no need to test every combination.
*/
excluded_set_id = testCaseIdx % UPRV_LENGTHOF(excluded_sets);
{
UConverterSelector *sel_rt, *sel_fb;
char *buffer_fb = NULL;
UErrorCode status = U_ZERO_ERROR;
sel_rt = ucnvsel_open(encodings, num_encodings,
excluded_sets[excluded_set_id],
UCNV_ROUNDTRIP_SET, &status);
if (num_encodings == gCountAvailable) {
/* test the special "all converters" parameter values */
sel_fb = ucnvsel_open(NULL, 0,
excluded_sets[excluded_set_id],
UCNV_ROUNDTRIP_AND_FALLBACK_SET, &status);
} else if (uset_isEmpty(excluded_sets[excluded_set_id])) {
/* test that a NULL set gives the same results as an empty set */
sel_fb = ucnvsel_open(encodings, num_encodings,
NULL,
UCNV_ROUNDTRIP_AND_FALLBACK_SET, &status);
} else {
sel_fb = ucnvsel_open(encodings, num_encodings,
excluded_sets[excluded_set_id],
UCNV_ROUNDTRIP_AND_FALLBACK_SET, &status);
}
if (U_FAILURE(status)) {
log_err("ucnv_sel_open(encodings %ld) failed - %s\n", testCaseIdx, u_errorName(status));
ucnvsel_close(sel_rt);
uprv_free((void *)encodings);
continue;
}
text_reset(&text);
for (;;) {
UBool *manual_rt, *manual_fb;
static UChar utf16[10000];
char *s;
int32_t length8, length16;
s = text_nextString(&text, &length8);
if (s == NULL || (getTestOption(QUICK_OPTION) && text.number > 3)) {
break;
}
manual_rt = getResultsManually(encodings, num_encodings,
s, length8,
excluded_sets[excluded_set_id],
UCNV_ROUNDTRIP_SET);
manual_fb = getResultsManually(encodings, num_encodings,
s, length8,
excluded_sets[excluded_set_id],
UCNV_ROUNDTRIP_AND_FALLBACK_SET);
/* UTF-8 with length */
status = U_ZERO_ERROR;
verifyResult(ucnvsel_selectForUTF8(sel_rt, s, length8, &status), manual_rt);
verifyResult(ucnvsel_selectForUTF8(sel_fb, s, length8, &status), manual_fb);
/* UTF-8 NUL-terminated */
verifyResult(ucnvsel_selectForUTF8(sel_rt, s, -1, &status), manual_rt);
verifyResult(ucnvsel_selectForUTF8(sel_fb, s, -1, &status), manual_fb);
u_strFromUTF8(utf16, UPRV_LENGTHOF(utf16), &length16, s, length8, &status);
if (U_FAILURE(status)) {
log_err("error converting the test text (string %ld) to UTF-16 - %s\n",
(long)text.number, u_errorName(status));
} else {
if (text.number == 0) {
sel_fb = serializeAndUnserialize(sel_fb, &buffer_fb, &status);
}
if (U_SUCCESS(status)) {
/* UTF-16 with length */
verifyResult(ucnvsel_selectForString(sel_rt, utf16, length16, &status), manual_rt);
verifyResult(ucnvsel_selectForString(sel_fb, utf16, length16, &status), manual_fb);
/* UTF-16 NUL-terminated */
verifyResult(ucnvsel_selectForString(sel_rt, utf16, -1, &status), manual_rt);
verifyResult(ucnvsel_selectForString(sel_fb, utf16, -1, &status), manual_fb);
}
}
uprv_free(manual_rt);
uprv_free(manual_fb);
}
ucnvsel_close(sel_rt);
ucnvsel_close(sel_fb);
uprv_free(buffer_fb);
}
uprv_free((void *)encodings);
}
releaseAvailableNames();
text_close(&text);
for(i = 0 ; i < 3 ; i++) {
uset_close(excluded_sets[i]);
}
}
int main(int argc, const char* const argv[])
{
int nerrors = 0;
UBool defaultDataFound;
TestNode *root;
const char *warnOrErr = "Failure";
UDate startTime, endTime;
int32_t diffTime;
/* initial check for the default converter */
UErrorCode errorCode = U_ZERO_ERROR;
UResourceBundle *rb;
UConverter *cnv;
U_MAIN_INIT_ARGS(argc, argv);
startTime = uprv_getRawUTCtime();
gOrigArgc = argc;
gOrigArgv = argv;
if (!initArgs(argc, argv, NULL, NULL)) {
/* Error already displayed. */
return -1;
}
/* Check whether ICU will initialize without forcing the build data directory into
* the ICU_DATA path. Success here means either the data dll contains data, or that
* this test program was run with ICU_DATA set externally. Failure of this check
* is normal when ICU data is not packaged into a shared library.
*
* Whether or not this test succeeds, we want to cleanup and reinitialize
* with a data path so that data loading from individual files can be tested.
*/
defaultDataFound = TRUE;
u_init(&errorCode);
if (U_FAILURE(errorCode)) {
fprintf(stderr,
"#### Note: ICU Init without build-specific setDataDirectory() failed. %s\n", u_errorName(errorCode));
defaultDataFound = FALSE;
}
u_cleanup();
#ifdef URES_DEBUG
fprintf(stderr, "After initial u_cleanup: RB cache %s empty.\n", ures_dumpCacheContents()?"WAS NOT":"was");
#endif
while (getTestOption(REPEAT_TESTS_OPTION) > 0) { /* Loop runs once per complete execution of the tests
* used for -r (repeat) test option. */
if (!initArgs(argc, argv, NULL, NULL)) {
/* Error already displayed. */
return -1;
}
errorCode = U_ZERO_ERROR;
/* Initialize ICU */
if (!defaultDataFound) {
ctest_setICU_DATA(); /* u_setDataDirectory() must happen Before u_init() */
}
u_init(&errorCode);
if (U_FAILURE(errorCode)) {
fprintf(stderr,
"#### ERROR! %s: u_init() failed with status = \"%s\".\n"
"*** Check the ICU_DATA environment variable and \n"
"*** check that the data files are present.\n", argv[0], u_errorName(errorCode));
if(!getTestOption(WARN_ON_MISSING_DATA_OPTION)) {
fprintf(stderr, "*** Exiting. Use the '-w' option if data files were\n*** purposely removed, to continue test anyway.\n");
u_cleanup();
return 1;
}
}
/* try more data */
cnv = ucnv_open(TRY_CNV_2, &errorCode);
if(cnv != 0) {
/* ok */
ucnv_close(cnv);
} else {
fprintf(stderr,
"*** %s! The converter for " TRY_CNV_2 " cannot be opened.\n"
"*** Check the ICU_DATA environment variable and \n"
"*** check that the data files are present.\n", warnOrErr);
if(!getTestOption(WARN_ON_MISSING_DATA_OPTION)) {
fprintf(stderr, "*** Exitting. Use the '-w' option if data files were\n*** purposely removed, to continue test anyway.\n");
u_cleanup();
return 1;
}
}
rb = ures_open(NULL, "en", &errorCode);
if(U_SUCCESS(errorCode)) {
/* ok */
ures_close(rb);
} else {
fprintf(stderr,
"*** %s! The \"en\" locale resource bundle cannot be opened.\n"
"*** Check the ICU_DATA environment variable and \n"
"*** check that the data files are present.\n", warnOrErr);
if(!getTestOption(WARN_ON_MISSING_DATA_OPTION)) {
fprintf(stderr, "*** Exitting. Use the '-w' option if data files were\n*** purposely removed, to continue test anyway.\n");
u_cleanup();
return 1;
}
}
errorCode = U_ZERO_ERROR;
rb = ures_open(NULL, NULL, &errorCode);
if(U_SUCCESS(errorCode)) {
/* ok */
if (errorCode == U_USING_DEFAULT_WARNING || errorCode == U_USING_FALLBACK_WARNING) {
fprintf(stderr,
"#### Note: The default locale %s is not available\n", uloc_getDefault());
}
ures_close(rb);
} else {
fprintf(stderr,
"*** %s! Can not open a resource bundle for the default locale %s\n", warnOrErr, uloc_getDefault());
if(!getTestOption(WARN_ON_MISSING_DATA_OPTION)) {
fprintf(stderr, "*** Exitting. Use the '-w' option if data files were\n"
"*** purposely removed, to continue test anyway.\n");
u_cleanup();
return 1;
}
}
fprintf(stdout, "Default locale for this run is %s\n", uloc_getDefault());
/* Build a tree of all tests.
* Subsequently will be used to find / iterate the tests to run */
root = NULL;
addAllTests(&root);
/* Tests acutally run HERE. TODO: separate command line option parsing & setting from test execution!! */
nerrors = runTestRequest(root, argc, argv);
setTestOption(REPEAT_TESTS_OPTION, DECREMENT_OPTION_VALUE);
if (getTestOption(REPEAT_TESTS_OPTION) > 0) {
printf("Repeating tests %d more time(s)\n", getTestOption(REPEAT_TESTS_OPTION));
}
cleanUpTestTree(root);
#ifdef CTST_LEAK_CHECK
ctst_freeAll();
/* To check for leaks */
u_cleanup(); /* nuke the hashtable.. so that any still-open cnvs are leaked */
if(getTestOption(VERBOSITY_OPTION) && ctst_allocated_total>0) {
fprintf(stderr,"ctst_freeAll(): cleaned up after %d allocations (queue of %d)\n", ctst_allocated_total, CTST_MAX_ALLOC);
}
#ifdef URES_DEBUG
if(ures_dumpCacheContents()) {
fprintf(stderr, "Error: After final u_cleanup, RB cache was not empty.\n");
nerrors++;
} else {
fprintf(stderr,"OK: After final u_cleanup, RB cache was empty.\n");
}
#endif
#endif
} /* End of loop that repeats the entire test, if requested. (Normally doesn't loop) */
#ifdef UNISTR_COUNT_FINAL_STRING_LENGTHS
unistr_printLengths();
#endif
endTime = uprv_getRawUTCtime();
diffTime = (int32_t)(endTime - startTime);
printf("Elapsed Time: %02d:%02d:%02d.%03d\n",
(int)((diffTime%U_MILLIS_PER_DAY)/U_MILLIS_PER_HOUR),
(int)((diffTime%U_MILLIS_PER_HOUR)/U_MILLIS_PER_MINUTE),
(int)((diffTime%U_MILLIS_PER_MINUTE)/U_MILLIS_PER_SECOND),
(int)(diffTime%U_MILLIS_PER_SECOND));
return nerrors ? 1 : 0;
}
static UBool testConvertToUnicode( const uint8_t *source, int sourcelen, const UChar *expect, int expectlen,
const char *codepage, UBool fallback, const int32_t *expectOffsets)
{
UErrorCode status = U_ZERO_ERROR;
UConverter *conv = 0;
UChar junkout[NEW_MAX_BUFFER]; /* FIX */
int32_t junokout[NEW_MAX_BUFFER]; /* FIX */
const char *src;
const char *realSourceEnd;
const char *srcLimit;
UChar *targ;
UChar *end;
int32_t *offs;
int i;
UBool checkOffsets = TRUE;
char junk[9999];
char offset_str[9999];
UChar *p;
UBool action;
int32_t realBufferSize;
UChar *realBufferEnd;
for(i=0;i<NEW_MAX_BUFFER;i++)
junkout[i] = 0xFFFE;
for(i=0;i<NEW_MAX_BUFFER;i++)
junokout[i] = -1;
setNuConvTestName(codepage, "TO");
log_verbose("\n========= %s\n", gNuConvTestName);
conv = my_ucnv_open(codepage, &status);
if(U_FAILURE(status))
{
log_data_err("Couldn't open converter %s\n",gNuConvTestName);
return TRUE; /* because it has been logged */
}
log_verbose("Converter opened..\n");
src = (const char *)source;
targ = junkout;
offs = junokout;
realBufferSize = (sizeof(junkout)/sizeof(junkout[0]));
realBufferEnd = junkout + realBufferSize;
realSourceEnd = src + sourcelen;
/*----setting the fallback routine----*/
ucnv_setFallback (conv, fallback);
action = ucnv_usesFallback(conv);
if(action != fallback){
log_err("FAIL: Error is setting fallback. Errocode=%s\n", myErrorName(status));
}
/*-------------------------------------*/
if ( gOutBufferSize != realBufferSize )
checkOffsets = FALSE;
if( gInBufferSize != NEW_MAX_BUFFER )
checkOffsets = FALSE;
do
{
end = nct_min( targ + gOutBufferSize, realBufferEnd);
srcLimit = nct_min(realSourceEnd, src + gInBufferSize);
if(targ == realBufferEnd)
{
log_err("Error, the end would overflow the real output buffer while about to call toUnicode! tarjey=%08lx %s",targ,gNuConvTestName);
return FALSE;
}
log_verbose("calling toUnicode @ %08lx to %08lx\n", targ,end);
status = U_ZERO_ERROR;
ucnv_toUnicode (conv,
&targ,
end,
(const char **)&src,
(const char *)srcLimit,
checkOffsets ? offs : NULL,
(UBool)(srcLimit == realSourceEnd), /* flush if we're at the end of hte source data */
&status);
} while ( (status == U_BUFFER_OVERFLOW_ERROR) || (srcLimit < realSourceEnd) ); /* while we just need another buffer */
if(U_FAILURE(status))
{
log_err("Problem doing toUnicode, errcode %s %s\n", myErrorName(status), gNuConvTestName);
return FALSE;
}
log_verbose("\nConversion done. %d bytes -> %d chars.\nResult :",
sourcelen, targ-junkout);
if(getTestOption(VERBOSITY_OPTION))
{
junk[0] = 0;
offset_str[0] = 0;
for(p = junkout;p<targ;p++)
{
sprintf(junk + strlen(junk), "0x%04x, ", (0xFFFF) & (unsigned int)*p);
sprintf(offset_str + strlen(offset_str), "0x%04x, ", (0xFFFF) & (unsigned int)junokout[p-junkout]);
}
log_verbose(junk);
printUSeq(expect, expectlen);
if ( checkOffsets )
{
log_verbose("\nOffsets:");
log_verbose(offset_str);
}
log_verbose("\n");
}
ucnv_close(conv);
log_verbose("comparing %d uchars (%d bytes)..\n",expectlen,expectlen*2);
if (checkOffsets && (expectOffsets != 0))
{
if(memcmp(junokout,expectOffsets,(targ-junkout) * sizeof(int32_t)))
{
log_err("\n\ndid not get the expected offsets while %s \n", gNuConvTestName);
log_err("\nGot : ");
for(p=junkout;p<targ;p++)
log_err("%d, ", junokout[p-junkout]);
log_err("\nExpected: ");
for(i=0; i<(targ-junkout); i++)
log_err("%d,", expectOffsets[i]);
log_err("");
for(i=0; i<(targ-junkout); i++)
log_err("0x%04X,", junkout[i]);
log_err("");
for(i=0; i<(src-(const char *)source); i++)
log_err("0x%04X,", (unsigned char)source[i]);
}
}
if(!memcmp(junkout, expect, expectlen*2))
{
log_verbose("Matches!\n");
return TRUE;
}
else
{
log_err("String does not match. %s\n", gNuConvTestName);
log_verbose("String does not match. %s\n", gNuConvTestName);
printUSeqErr(junkout, expectlen);
printf("\n");
printUSeqErr(expect, expectlen);
return FALSE;
}
}
static UBool testConvertFromUnicode(const UChar *source, int sourceLen, const uint8_t *expect, int expectLen,
const char *codepage, UBool fallback, const int32_t *expectOffsets)
{
UErrorCode status = U_ZERO_ERROR;
UConverter *conv = 0;
char junkout[NEW_MAX_BUFFER]; /* FIX */
int32_t junokout[NEW_MAX_BUFFER]; /* FIX */
const UChar *src;
char *end;
char *targ;
int32_t *offs;
int i;
int32_t realBufferSize;
char *realBufferEnd;
const UChar *realSourceEnd;
const UChar *sourceLimit;
UBool checkOffsets = TRUE;
UBool doFlush;
UBool action=FALSE;
char *p;
for(i=0;i<NEW_MAX_BUFFER;i++)
junkout[i] = (char)0xF0;
for(i=0;i<NEW_MAX_BUFFER;i++)
junokout[i] = 0xFF;
setNuConvTestName(codepage, "FROM");
log_verbose("\nTesting========= %s FROM \n inputbuffer= %d outputbuffer= %d\n", codepage, gInBufferSize,
gOutBufferSize);
conv = my_ucnv_open(codepage, &status);
if(U_FAILURE(status))
{
log_data_err("Couldn't open converter %s\n",codepage);
return TRUE;
}
log_verbose("Converter opened..\n");
/*----setting the callback routine----*/
ucnv_setFallback (conv, fallback);
action = ucnv_usesFallback(conv);
if(action != fallback){
log_err("FAIL: Error is setting fallback. Errocode=%s\n", myErrorName(status));
}
/*------------------------*/
src = source;
targ = junkout;
offs = junokout;
realBufferSize = (sizeof(junkout)/sizeof(junkout[0]));
realBufferEnd = junkout + realBufferSize;
realSourceEnd = source + sourceLen;
if ( gOutBufferSize != realBufferSize )
checkOffsets = FALSE;
if( gInBufferSize != NEW_MAX_BUFFER )
checkOffsets = FALSE;
do
{
end = nct_min(targ + gOutBufferSize, realBufferEnd);
sourceLimit = nct_min(src + gInBufferSize, realSourceEnd);
doFlush = (UBool)(sourceLimit == realSourceEnd);
if(targ == realBufferEnd)
{
log_err("Error, overflowed the real buffer while about to call fromUnicode! targ=%08lx %s", targ, gNuConvTestName);
return FALSE;
}
log_verbose("calling fromUnicode @ SOURCE:%08lx to %08lx TARGET: %08lx to %08lx, flush=%s\n", src,sourceLimit, targ,end, doFlush?"TRUE":"FALSE");
status = U_ZERO_ERROR;
ucnv_fromUnicode (conv,
(char **)&targ,
(const char *)end,
&src,
sourceLimit,
checkOffsets ? offs : NULL,
doFlush, /* flush if we're at the end of the input data */
&status);
} while ( (status == U_BUFFER_OVERFLOW_ERROR) || (sourceLimit < realSourceEnd) );
if(U_FAILURE(status))
{
log_err("Problem doing toUnicode, errcode %d %s\n", myErrorName(status), gNuConvTestName);
return FALSE;
}
log_verbose("\nConversion done [%d uchars in -> %d chars out]. \nResult :",
sourceLen, targ-junkout);
if(getTestOption(VERBOSITY_OPTION))
{
char junk[9999];
char offset_str[9999];
junk[0] = 0;
offset_str[0] = 0;
for(p = junkout;p<targ;p++)
{
sprintf(junk + uprv_strlen(junk), "0x%02x, ", (0xFF) & (unsigned int)*p);
sprintf(offset_str + strlen(offset_str), "0x%02x, ", (0xFF) & (unsigned int)junokout[p-junkout]);
}
log_verbose(junk);
printSeq((const unsigned char*)expect, expectLen);
if ( checkOffsets )
{
log_verbose("\nOffsets:");
log_verbose(offset_str);
}
log_verbose("\n");
}
ucnv_close(conv);
if(expectLen != targ-junkout)
{
log_err("Expected %d chars out, got %d %s\n", expectLen, targ-junkout, gNuConvTestName);
log_verbose("Expected %d chars out, got %d %s\n", expectLen, targ-junkout, gNuConvTestName);
printSeqErr((const unsigned char*)junkout, (int32_t)(targ-junkout));
printSeqErr((const unsigned char*)expect, expectLen);
return FALSE;
}
if (checkOffsets && (expectOffsets != 0) )
{
log_verbose("\ncomparing %d offsets..\n", targ-junkout);
if(uprv_memcmp(junokout,expectOffsets,(targ-junkout) * sizeof(int32_t) )){
log_err("\ndid not get the expected offsets while %s \n", gNuConvTestName);
log_err("Got : ");
printSeqErr((const unsigned char*)junkout, (int32_t)(targ-junkout));
for(p=junkout;p<targ;p++)
log_err("%d, ", junokout[p-junkout]);
log_err("\nExpected: ");
for(i=0; i<(targ-junkout); i++)
log_err("%d,", expectOffsets[i]);
}
}
log_verbose("\n\ncomparing..\n");
if(!memcmp(junkout, expect, expectLen))
{
log_verbose("Matches!\n");
return TRUE;
}
else
{
log_err("String does not match. %s\n", gNuConvTestName);
log_verbose("String does not match. %s\n", gNuConvTestName);
printSeqErr((const unsigned char*)junkout, expectLen);
printSeqErr((const unsigned char*)expect, expectLen);
return FALSE;
}
}
static void TestPUtilAPI(void){
double n1=0.0, y1=0.0, expn1, expy1;
double value1 = 0.021;
char *str=0;
UBool isTrue=FALSE;
log_verbose("Testing the API uprv_modf()\n");
y1 = uprv_modf(value1, &n1);
expn1=0;
expy1=0.021;
if(y1 != expy1 || n1 != expn1){
log_err("Error in uprv_modf. Expected IntegralValue=%f, Got=%f, \n Expected FractionalValue=%f, Got=%f\n",
expn1, n1, expy1, y1);
}
if(getTestOption(VERBOSITY_OPTION)){
log_verbose("[float] x = %f n = %f y = %f\n", value1, n1, y1);
}
log_verbose("Testing the API uprv_fmod()\n");
expn1=uprv_fmod(30.50, 15.00);
doAssert(expn1, 0.5, "uprv_fmod(30.50, 15.00) failed.");
log_verbose("Testing the API uprv_ceil()\n");
expn1=uprv_ceil(value1);
doAssert(expn1, 1, "uprv_ceil(0.021) failed.");
log_verbose("Testing the API uprv_floor()\n");
expn1=uprv_floor(value1);
doAssert(expn1, 0, "uprv_floor(0.021) failed.");
log_verbose("Testing the API uprv_fabs()\n");
expn1=uprv_fabs((2.02-1.345));
doAssert(expn1, 0.675, "uprv_fabs(2.02-1.345) failed.");
log_verbose("Testing the API uprv_fmax()\n");
doAssert(uprv_fmax(2.4, 1.2), 2.4, "uprv_fmax(2.4, 1.2) failed.");
log_verbose("Testing the API uprv_fmax() with x value= NaN\n");
expn1=uprv_fmax(uprv_getNaN(), 1.2);
doAssert(expn1, uprv_getNaN(), "uprv_fmax(uprv_getNaN(), 1.2) failed. when one parameter is NaN");
log_verbose("Testing the API uprv_fmin()\n");
doAssert(uprv_fmin(2.4, 1.2), 1.2, "uprv_fmin(2.4, 1.2) failed.");
log_verbose("Testing the API uprv_fmin() with x value= NaN\n");
expn1=uprv_fmin(uprv_getNaN(), 1.2);
doAssert(expn1, uprv_getNaN(), "uprv_fmin(uprv_getNaN(), 1.2) failed. when one parameter is NaN");
log_verbose("Testing the API uprv_max()\n");
doAssert(uprv_max(4, 2), 4, "uprv_max(4, 2) failed.");
log_verbose("Testing the API uprv_min()\n");
doAssert(uprv_min(-4, 2), -4, "uprv_min(-4, 2) failed.");
log_verbose("Testing the API uprv_trunc()\n");
doAssert(uprv_trunc(12.3456), 12, "uprv_trunc(12.3456) failed.");
doAssert(uprv_trunc(12.234E2), 1223, "uprv_trunc(12.234E2) failed.");
doAssert(uprv_trunc(uprv_getNaN()), uprv_getNaN(), "uprv_trunc(uprv_getNaN()) failed. with parameter=NaN");
doAssert(uprv_trunc(uprv_getInfinity()), uprv_getInfinity(), "uprv_trunc(uprv_getInfinity()) failed. with parameter=Infinity");
log_verbose("Testing the API uprv_pow10()\n");
doAssert(uprv_pow10(4), 10000, "uprv_pow10(4) failed.");
log_verbose("Testing the API uprv_isNegativeInfinity()\n");
isTrue=uprv_isNegativeInfinity(uprv_getInfinity() * -1);
if(isTrue != TRUE){
log_err("ERROR: uprv_isNegativeInfinity failed.\n");
}
log_verbose("Testing the API uprv_isPositiveInfinity()\n");
isTrue=uprv_isPositiveInfinity(uprv_getInfinity());
if(isTrue != TRUE){
log_err("ERROR: uprv_isPositiveInfinity failed.\n");
}
log_verbose("Testing the API uprv_isInfinite()\n");
isTrue=uprv_isInfinite(uprv_getInfinity());
if(isTrue != TRUE){
log_err("ERROR: uprv_isInfinite failed.\n");
}
#if 0
log_verbose("Testing the API uprv_digitsAfterDecimal()....\n");
doAssert(uprv_digitsAfterDecimal(value1), 3, "uprv_digitsAfterDecimal() failed.");
doAssert(uprv_digitsAfterDecimal(1.2345E2), 2, "uprv_digitsAfterDecimal(1.2345E2) failed.");
doAssert(uprv_digitsAfterDecimal(1.2345E-2), 6, "uprv_digitsAfterDecimal(1.2345E-2) failed.");
doAssert(uprv_digitsAfterDecimal(1.2345E2), 2, "uprv_digitsAfterDecimal(1.2345E2) failed.");
doAssert(uprv_digitsAfterDecimal(-1.2345E-20), 24, "uprv_digitsAfterDecimal(1.2345E-20) failed.");
doAssert(uprv_digitsAfterDecimal(1.2345E20), 0, "uprv_digitsAfterDecimal(1.2345E20) failed.");
doAssert(uprv_digitsAfterDecimal(-0.021), 3, "uprv_digitsAfterDecimal(-0.021) failed.");
doAssert(uprv_digitsAfterDecimal(23.0), 0, "uprv_digitsAfterDecimal(23.0) failed.");
doAssert(uprv_digitsAfterDecimal(0.022223333321), 9, "uprv_digitsAfterDecimal(0.022223333321) failed.");
#endif
log_verbose("Testing the API u_errorName()...\n");
str=(char*)u_errorName((UErrorCode)0);
if(strcmp(str, "U_ZERO_ERROR") != 0){
log_err("ERROR: u_getVersion() failed. Expected: U_ZERO_ERROR Got=%s\n", str);
}
log_verbose("Testing the API u_errorName()...\n");
str=(char*)u_errorName((UErrorCode)-127);
if(strcmp(str, "U_USING_DEFAULT_WARNING") != 0){
log_err("ERROR: u_getVersion() failed. Expected: U_USING_DEFAULT_WARNING Got=%s\n", str);
}
log_verbose("Testing the API u_errorName().. with BOGUS ERRORCODE...\n");
str=(char*)u_errorName((UErrorCode)200);
if(strcmp(str, "[BOGUS UErrorCode]") != 0){
log_err("ERROR: u_getVersion() failed. Expected: [BOGUS UErrorCode] Got=%s\n", str);
}
{
const char* dataDirectory;
int32_t dataDirectoryLen;
UChar *udataDir=0;
UChar temp[100];
char *charvalue=0;
log_verbose("Testing chars to UChars\n");
/* This cannot really work on a japanese system. u_uastrcpy will have different results than */
/* u_charsToUChars when there is a backslash in the string! */
/*dataDirectory=u_getDataDirectory();*/
dataDirectory="directory1"; /*no backslashes*/
dataDirectoryLen=(int32_t)strlen(dataDirectory);
udataDir=(UChar*)malloc(sizeof(UChar) * (dataDirectoryLen + 1));
u_charsToUChars(dataDirectory, udataDir, (dataDirectoryLen + 1));
u_uastrcpy(temp, dataDirectory);
if(u_strcmp(temp, udataDir) != 0){
log_err("ERROR: u_charsToUChars failed. Expected %s, Got %s\n", austrdup(temp), austrdup(udataDir));
}
log_verbose("Testing UChars to chars\n");
charvalue=(char*)malloc(sizeof(char) * (u_strlen(udataDir) + 1));
u_UCharsToChars(udataDir, charvalue, (u_strlen(udataDir)+1));
if(strcmp(charvalue, dataDirectory) != 0){
log_err("ERROR: u_UCharsToChars failed. Expected %s, Got %s\n", charvalue, dataDirectory);
}
free(charvalue);
free(udataDir);
}
log_verbose("Testing uprv_timezone()....\n");
{
int32_t tzoffset = uprv_timezone();
log_verbose("Value returned from uprv_timezone = %d\n", tzoffset);
if (tzoffset != 28800) {
log_verbose("***** WARNING: If testing in the PST timezone, t_timezone should return 28800! *****");
}
if ((tzoffset % 1800 != 0)) {
log_info("Note: t_timezone offset of %ld (for %s : %s) is not a multiple of 30min.", tzoffset, uprv_tzname(0), uprv_tzname(1));
}
/*tzoffset=uprv_getUTCtime();*/
}
}
static void doTestVariant(UCollator* myCollation, const UChar source[], const UChar target[], UCollationResult result)
{
int32_t sortklen1, sortklen2, sortklenmax, sortklenmin;
int temp=0, gSortklen1=0,gSortklen2=0;
UCollationResult compareResult, compareResulta, keyResult, compareResultIter = result;
uint8_t *sortKey1, *sortKey2, *sortKey1a, *sortKey2a;
uint32_t sLen = u_strlen(source);
uint32_t tLen = u_strlen(target);
char buffer[256];
uint32_t len;
UErrorCode status = U_ZERO_ERROR;
UColAttributeValue norm = ucol_getAttribute(myCollation, UCOL_NORMALIZATION_MODE, &status);
UCharIterator sIter, tIter;
compareResult = ucol_strcoll(myCollation, source, sLen, target, tLen);
if (compareResult != result) {
log_err("ucol_strcoll with explicit length returned wrong result (%i exp. %i): %s, %s\n",
compareResult, result, aescstrdup(source,-1), aescstrdup(target,-1));
}
compareResulta = ucol_strcoll(myCollation, source, -1, target, -1);
if (compareResulta != result) {
log_err("ucol_strcoll with null terminated strings returned wrong result (%i exp. %i): %s, %s\n",
compareResult, result, aescstrdup(source,-1), aescstrdup(target,-1));
}
uiter_setString(&sIter, source, sLen);
uiter_setString(&tIter, target, tLen);
compareResultIter = ucol_strcollIter(myCollation, &sIter, &tIter, &status);
if(compareResultIter != result) {
log_err("different results in iterative comparison for UTF-16 encoded strings. %s, %s\n", aescstrdup(source,-1), aescstrdup(target,-1));
}
/* convert the strings to UTF-8 and do try comparing with char iterator and ucol_strcollUTF8 */
{
char utf8Source[256], utf8Target[256];
int32_t utf8SourceLen = 0, utf8TargetLen = 0;
u_strToUTF8(utf8Source, 256, &utf8SourceLen, source, sLen, &status);
if(U_FAILURE(status)) { /* probably buffer is not big enough */
log_verbose("Src UTF-8 buffer too small! Will not compare!\n");
} else {
u_strToUTF8(utf8Target, 256, &utf8TargetLen, target, tLen, &status);
if(U_SUCCESS(status)) {
{
/* ucol_strcollUTF8 */
compareResulta = ucol_strcollUTF8(myCollation, utf8Source, utf8SourceLen, utf8Target, utf8TargetLen, &status);
if (U_FAILURE(status)) {
log_err("Error in ucol_strcollUTF8 with explicit length\n");
status = U_ZERO_ERROR;
} else if (compareResulta != result) {
log_err("ucol_strcollUTF8 with explicit length returned wrong result (%i exp. %i): %s, %s\n",
compareResulta, result, aescstrdup(source,-1), aescstrdup(target,-1));
}
compareResulta = ucol_strcollUTF8(myCollation, utf8Source, -1, utf8Target, -1, &status);
if (U_FAILURE(status)) {
log_err("Error in ucol_strcollUTF8 with null terminated strings\n");
status = U_ZERO_ERROR;
} else if (compareResulta != result) {
log_err("ucol_strcollUTF8 with null terminated strings returned wrong result (%i exp. %i): %s, %s\n",
compareResulta, result, aescstrdup(source,-1), aescstrdup(target,-1));
}
}
{
/* char iterator over UTF8 */
UCollationResult compareResultUTF8Iter = result, compareResultUTF8IterNorm = result;
uiter_setUTF8(&sIter, utf8Source, utf8SourceLen);
uiter_setUTF8(&tIter, utf8Target, utf8TargetLen);
compareResultUTF8Iter = ucol_strcollIter(myCollation, &sIter, &tIter, &status);
ucol_setAttribute(myCollation, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
sIter.move(&sIter, 0, UITER_START);
tIter.move(&tIter, 0, UITER_START);
compareResultUTF8IterNorm = ucol_strcollIter(myCollation, &sIter, &tIter, &status);
ucol_setAttribute(myCollation, UCOL_NORMALIZATION_MODE, norm, &status);
if(compareResultUTF8Iter != compareResultIter) {
log_err("different results in iterative comparison for UTF-16 and UTF-8 encoded strings. %s, %s\n", aescstrdup(source,-1), aescstrdup(target,-1));
}
if(compareResultUTF8Iter != compareResultUTF8IterNorm) {
log_err("different results in iterative when normalization is turned on with UTF-8 strings. %s, %s\n", aescstrdup(source,-1), aescstrdup(target,-1));
}
}
} else {
log_verbose("Target UTF-8 buffer too small! Did not compare!\n");
}
if(U_FAILURE(status)) {
log_verbose("UTF-8 strcoll failed! Ignoring result\n");
}
}
}
/* testing the partial sortkeys */
if(1) { /*!QUICK*/
int32_t i = 0;
int32_t partialSizes[] = { 3, 1, 2, 4, 8, 20, 80 }; /* just size 3 in the quick mode */
int32_t partialSizesSize = 1;
if(getTestOption(QUICK_OPTION) <= 0) {
partialSizesSize = 7;
}
/*log_verbose("partial sortkey test piecesize=");*/
for(i = 0; i < partialSizesSize; i++) {
UCollationResult partialSKResult = result, partialNormalizedSKResult = result;
/*log_verbose("%i ", partialSizes[i]);*/
partialSKResult = compareUsingPartials(myCollation, source, sLen, target, tLen, partialSizes[i], &status);
if(partialSKResult != result) {
log_err("Partial sortkey comparison returned wrong result (%i exp. %i): %s, %s (size %i)\n",
partialSKResult, result,
aescstrdup(source,-1), aescstrdup(target,-1), partialSizes[i]);
}
if(getTestOption(QUICK_OPTION) <= 0 && norm != UCOL_ON) {
/*log_verbose("N ");*/
ucol_setAttribute(myCollation, UCOL_NORMALIZATION_MODE, UCOL_ON, &status);
partialNormalizedSKResult = compareUsingPartials(myCollation, source, sLen, target, tLen, partialSizes[i], &status);
ucol_setAttribute(myCollation, UCOL_NORMALIZATION_MODE, norm, &status);
if(partialSKResult != partialNormalizedSKResult) {
log_err("Partial sortkey comparison gets different result when normalization is on: %s, %s (size %i)\n",
aescstrdup(source,-1), aescstrdup(target,-1), partialSizes[i]);
}
}
}
/*log_verbose("\n");*/
}
sortklen1=ucol_getSortKey(myCollation, source, sLen, NULL, 0);
sortklen2=ucol_getSortKey(myCollation, target, tLen, NULL, 0);
sortklenmax = (sortklen1>sortklen2?sortklen1:sortklen2);
sortklenmin = (sortklen1<sortklen2?sortklen1:sortklen2);
(void)sortklenmin; /* Suppress set but not used warning. */
sortKey1 =(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
sortKey1a=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
ucol_getSortKey(myCollation, source, sLen, sortKey1, sortklen1+1);
ucol_getSortKey(myCollation, source, -1, sortKey1a, sortklen1+1);
sortKey2 =(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
sortKey2a=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
ucol_getSortKey(myCollation, target, tLen, sortKey2, sortklen2+1);
ucol_getSortKey(myCollation, target, -1, sortKey2a, sortklen2+1);
/* Check that sort key generated with null terminated string is identical */
/* to that generted with a length specified. */
if (uprv_strcmp((const char *)sortKey1, (const char *)sortKey1a) != 0 ||
uprv_strcmp((const char *)sortKey2, (const char *)sortKey2a) != 0 ) {
log_err("Sort Keys from null terminated and explicit length strings differ.\n");
}
/*memcmp(sortKey1, sortKey2,sortklenmax);*/
temp= uprv_strcmp((const char *)sortKey1, (const char *)sortKey2);
gSortklen1 = uprv_strlen((const char *)sortKey1)+1;
gSortklen2 = uprv_strlen((const char *)sortKey2)+1;
if(sortklen1 != gSortklen1){
log_err("SortKey length does not match Expected: %i Got: %i\n",sortklen1, gSortklen1);
log_verbose("Generated sortkey: %s\n", sortKeyToString(myCollation, sortKey1, buffer, &len));
}
if(sortklen2!= gSortklen2){
log_err("SortKey length does not match Expected: %i Got: %i\n", sortklen2, gSortklen2);
log_verbose("Generated sortkey: %s\n", sortKeyToString(myCollation, sortKey2, buffer, &len));
}
if(temp < 0) {
keyResult=UCOL_LESS;
}
else if(temp > 0) {
keyResult= UCOL_GREATER;
}
else {
keyResult = UCOL_EQUAL;
}
reportCResult( source, target, sortKey1, sortKey2, compareResult, keyResult, compareResultIter, result );
free(sortKey1);
free(sortKey2);
free(sortKey1a);
free(sortKey2a);
}
