void Test714(void)
{
UDate d=978103543000.0;
UChar temp[20];
UErrorCode status = U_ZERO_ERROR;
UDateFormat *fmt;
UChar *result;
const char* expect = "7:25:43 AM";
ctest_setTimeZone(NULL, &status);
fmt= udat_open(UDAT_MEDIUM,UDAT_NONE ,"en_US_CA", NULL, -1, NULL, 0, &status);
if(U_FAILURE(status))
{
log_data_err("FAIL: error in creating the dateformat using medium time style and NO date style: %s (Are you missing data?)\n",
myErrorName(status));
return;
}
result =myFormatit(fmt, d);
if(!result) {
log_data_err("Fail: could not format - exitting test\n");
return;
}
u_uastrcpy(temp, expect);
if (u_strcmp(result, temp)!=0) {
log_err("Fail: %s != %s\n", austrdup(result), expect);
}
else {
log_verbose("Ok: %s == %s\n", austrdup(result), expect );
}
udat_close(fmt);
ctest_resetTimeZone();
}
/**
* @bug 4162071
**/
void Test4162071()
{
int32_t pos;
UDate x;
UErrorCode status = U_ZERO_ERROR;
UDateFormat *df;
UChar datestr[30];
UChar format[50];
u_uastrcpy(datestr, "Thu, 30-Jul-1999 11:51:14 GMT");
u_uastrcpy(format, "EEE', 'dd-MMM-yyyy HH:mm:ss z"); /* RFC 822/1123 */
status = U_ZERO_ERROR;
/* Can't hardcode the result to assume the default locale is "en_US". */
df = udat_open(UDAT_IGNORE,UDAT_IGNORE,"en_US",NULL,0,format, u_strlen(format),&status);
if(U_FAILURE(status)) {
log_data_err("ERROR: couldn't create date format: %s\n", myErrorName(status));
return;
}
pos=0;
x = udat_parse(df, datestr, u_strlen(datestr), &pos, &status);
if(U_FAILURE(status)) {
log_data_err("ERROR : parse format %s fails : %s\n", austrdup(format), myErrorName(status));
}
else {
log_verbose("Parse format \"%s \" ok.\n", austrdup(format) );
}
/*log_verbose("date= %s\n", austrdup(myFormatit(df, x)) );*/
udat_close(df);
}
void aux917( UDateFormat *fmt, UChar* str)
{
int32_t resultlength, resultlengthneeded;
UErrorCode status = U_ZERO_ERROR;
UChar* formatted=NULL;
UChar *pat=NULL;
UDate d1=1000000000.0;
resultlength=0;
resultlengthneeded=udat_toPattern(fmt, TRUE, NULL, resultlength, &status);
if(status==U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
resultlength=resultlengthneeded + 1;
pat=(UChar*)malloc(sizeof(UChar) * (resultlength));
udat_toPattern(fmt, TRUE, pat, resultlength, &status);
}
if(U_FAILURE(status)) {
log_err("failure in retrieving the pattern: %s\n", myErrorName(status));
}
log_verbose("pattern: %s\n", austrdup(pat) );
status = U_ZERO_ERROR;
formatted = myFormatit(fmt, d1);
if( u_strcmp(formatted,str)!=0) {
log_err("Fail: Want %s Got: %s\n", austrdup(str), austrdup(formatted) );
}
free(pat);
}
void TestRunTogetherPattern985()
{
int32_t pos;
UChar *pattern=NULL, *now=NULL, *then=NULL;
UDateFormat *format;
UDate date1, date2;
UErrorCode status = U_ZERO_ERROR;
pattern=(UChar*)malloc(sizeof(UChar) * (strlen("yyyyMMddHHmmssSSS")+1) );
u_uastrcpy(pattern, "yyyyMMddHHmmssSSS");
format = udat_open(UDAT_IGNORE, UDAT_IGNORE, NULL, NULL, 0,pattern, u_strlen(pattern), &status);
if(U_FAILURE(status)){
log_err_status(status, "FAIL: Error in date format construction with pattern: %s\n", myErrorName(status));
return;
}
date1 = ucal_getNow();
now=myDateFormat(format, date1);
log_verbose("%s\n", austrdup(now) );
pos = 0;
date2 = udat_parse(format, now, u_strlen(now), &pos, &status);
if (date2 == 0) log_verbose("Parse stopped at : %d\n", pos);
else then=myDateFormat(format, date2);
log_verbose("%s\n", austrdup(then) );
if (!(date2 == date1)) log_err("FAIL\n");
udat_close(format);
free(pattern);
}
void TestTwoDigitYearDSTParse()
{
UDateFormat *fullFmt, *fmt;
UErrorCode status = U_ZERO_ERROR;
UChar *pattern;
UDate d;
UChar *s;
int32_t pos;
ctest_setTimeZone(NULL, &status);
pattern=(UChar*)malloc(sizeof(UChar) * (strlen("EEE MMM dd HH:mm:ss.SSS zzz yyyy G")+1 ));
u_uastrcpy(pattern, "EEE MMM dd HH:mm:ss.SSS zzz yyyy G");
fullFmt= udat_open(UDAT_IGNORE, UDAT_IGNORE,"en_US",NULL,0,pattern, u_strlen(pattern),&status);
if(U_FAILURE(status)) {
log_err_status(status, "FAIL: Error in creating a date format using udat_openPattern %s\n",
myErrorName(status) );
}
else {
log_verbose("PASS: creating dateformat using udat_openPattern() succesful\n");
u_uastrcpy(pattern, "dd-MMM-yy h:mm:ss 'o''clock' a z");
fmt= udat_open(UDAT_IGNORE,UDAT_IGNORE,"en_US", NULL, 0,pattern, u_strlen(pattern), &status);
s=(UChar*)malloc(sizeof(UChar) * (strlen("03-Apr-04 2:20:47 o'clock AM PST")+1) );
u_uastrcpy(s, "03-Apr-04 2:20:47 o'clock AM PST");
pos=0;
d = udat_parse(fmt, s, u_strlen(s), &pos, &status);
if (U_FAILURE(status)) {
log_err("FAIL: Could not parse \"%s\"\n", austrdup(s));
} else {
UCalendar *cal = ucal_open(NULL, 0, uloc_getDefault(), UCAL_TRADITIONAL, &status);
if (U_FAILURE(status)) {
log_err_status(status, "FAIL: Could not open calendar: %s\n", u_errorName(status));
} else {
int32_t h;
ucal_setMillis(cal, d, &status);
h = ucal_get(cal, UCAL_HOUR_OF_DAY, &status);
if (U_FAILURE(status)) {
log_err("FAIL: Some calendar operations failed");
} else if (h != 2) {
log_err("FAIL: Parse of \"%s\" returned HOUR_OF_DAY %d\n",
austrdup(s), h);
}
ucal_close(cal);
}
}
udat_close(fullFmt);
udat_close(fmt);
free(s);
}
free(pattern);
ctest_resetTimeZone();
}
static void roundingTest(UNumberFormat* nf, double x, int32_t maxFractionDigits, const char* expected)
{
UChar *out = NULL;
UChar *res;
UFieldPosition pos;
UErrorCode status;
int32_t lneed;
status=U_ZERO_ERROR;
unum_setAttribute(nf, UNUM_MAX_FRACTION_DIGITS, maxFractionDigits);
lneed=0;
lneed=unum_formatDouble(nf, x, NULL, lneed, NULL, &status);
if(status==U_BUFFER_OVERFLOW_ERROR){
status=U_ZERO_ERROR;
out=(UChar*)malloc(sizeof(UChar) * (lneed+1) );
pos.field=0;
unum_formatDouble(nf, x, out, lneed+1, &pos, &status);
}
if(U_FAILURE(status)) {
log_err("Error in formatting using unum_formatDouble(.....): %s\n", myErrorName(status) );
}
/*Need to use log_verbose here. Problem with the float*/
/*printf("%f format with %d fraction digits to %s\n", x, maxFractionDigits, austrdup(out) );*/
res=(UChar*)malloc(sizeof(UChar) * (strlen(expected)+1) );
u_uastrcpy(res, expected);
if (u_strcmp(out, res) != 0)
log_err("FAIL: Expected: %s or %s\n", expected, austrdup(res) );
free(res);
if(out != NULL) {
free(out);
}
}
/* N.B.: use idx instead of index to avoid 'shadow' warnings in strict mode. */
static void VerifygetSymbols(UDateFormat* datfor, UDateFormatSymbolType type, int32_t idx, const char* expected)
{
UChar *pattern=NULL;
UErrorCode status = U_ZERO_ERROR;
UChar *result=NULL;
int32_t resultlength, resultlengthout;
pattern=(UChar*)malloc(sizeof(UChar) * (strlen(expected)+1));
u_uastrcpy(pattern, expected);
resultlength=0;
resultlengthout=udat_getSymbols(datfor, type, idx , NULL, resultlength, &status);
if(status==U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
resultlength=resultlengthout+1;
result=(UChar*)malloc(sizeof(UChar) * resultlength);
udat_getSymbols(datfor, type, idx, result, resultlength, &status);
}
if(U_FAILURE(status))
{
log_err("FAIL: Error in udat_getSymbols()... %s\n", myErrorName(status) );
return;
}
if(u_strcmp(result, pattern)==0)
log_verbose("PASS: getSymbols retrieved the right value\n");
else{
log_data_err("FAIL: getSymbols retrieved the wrong value\n Expected %s Got %s\n", austrdup(pattern),
austrdup(result) );
}
free(result);
free(pattern);
}
/* Test u_vformatMessage() with various test patterns. */
static void TestMessageFormatWithValist( void )
{
UChar *str;
UChar* result;
int32_t resultLengthOut,resultlength,i, patternlength;
UErrorCode status = U_ZERO_ERROR;
UDate d1=1000000000.0;
ctest_setTimeZone(NULL, &status);
str=(UChar*)malloc(sizeof(UChar) * 7);
u_uastrcpy(str, "MyDisk");
resultlength=1;
result=(UChar*)malloc(sizeof(UChar) * 1);
log_verbose("Testing u_formatMessage90\n");
InitStrings();
for (i = 0; i < cnt_testCases; i++) {
status=U_ZERO_ERROR;
patternlength=u_strlen(testCasePatterns[i]);
resultLengthOut=CallFormatMessage( "en_US",testCasePatterns[i], patternlength, result, resultlength,
&status, 1, 3456.00, d1);
if(status== U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
resultlength=resultLengthOut+1;
result=(UChar*)realloc(result,sizeof(UChar) * resultlength);
CallFormatMessage( "en_US",testCasePatterns[i], patternlength, result, resultlength,
&status, 1, 3456.00, d1);
}
if(U_FAILURE(status)){
log_data_err("ERROR: failure in message format on testcase %d: %s (Are you missing data?)\n", i, myErrorName(status) );
}
else if(u_strcmp(result, testResultStrings[i])==0){
log_verbose("PASS: MessagFormat successful on testcase : %d\n", i);
}
else{
log_err("FAIL: Error in MessageFormat on testcase : %d\n GOT %s EXPECTED %s\n", i,
austrdup(result), austrdup(testResultStrings[i]) );
}
}
free(result);
free(str);
FreeStrings();
ctest_resetTimeZone();
}
void tryPat994(UDateFormat* format, const char* pattern, const char* s, UDate expected)
{
UChar *f;
UChar *str, *pat;
UDate date;
UDate null=0;
int32_t pos;
UErrorCode status = U_ZERO_ERROR;
str=(UChar*)malloc(sizeof(UChar) * (strlen(s) + 1) );
u_uastrcpy(str, s);
pat=(UChar*)malloc(sizeof(UChar) * (strlen(pattern) + 1) );
u_uastrcpy(pat, pattern);
log_verbose("Pattern : %s ; String : %s\n", austrdup(pat), austrdup(str));
udat_applyPattern(format, FALSE, pat, u_strlen(pat));
pos=0;
date = udat_parse(format, str, u_strlen(str), &pos, &status);
if(U_FAILURE(status) || date == null) {
log_verbose("ParseException: : %s\n", myErrorName(status) );
if (expected != null)
log_err("FAIL: Expected: %s\n", austrdup(myDateFormat(format, expected)) );
}
else {
f=myDateFormat(format, date);
log_verbose(" parse( %s ) -> %s\n", austrdup(str), austrdup(f));
if (expected == null || date != expected)
log_err("FAIL: Expected null for \"%s\"\n", s);
if (u_strcmp(f, str) !=0)
log_err("FAIL: Expected : %s\n", austrdup(str) );
}
free(str);
free(pat);
}
static void VerifygetsetSymbols(UDateFormat* from, UDateFormat* to, UDateFormatSymbolType type, int32_t idx)
{
UChar *result=NULL;
UChar *value=NULL;
int32_t resultlength, resultlengthout;
UErrorCode status = U_ZERO_ERROR;
resultlength=0;
resultlengthout=udat_getSymbols(from, type, idx , NULL, resultlength, &status);
if(status==U_BUFFER_OVERFLOW_ERROR){
status=U_ZERO_ERROR;
resultlength=resultlengthout+1;
result=(UChar*)malloc(sizeof(UChar) * resultlength);
udat_getSymbols(from, type, idx, result, resultlength, &status);
}
if(U_FAILURE(status)){
log_err("FAIL: error in getSymbols() %s\n", myErrorName(status) );
return;
}
resultlength=resultlengthout+1;
udat_setSymbols(to, type, idx, result, resultlength, &status);
if(U_FAILURE(status))
{
log_err("FAIL: Error in udat_setSymbols() : %s\n", myErrorName(status) );
return;
}
resultlength=0;
resultlengthout=udat_getSymbols(to, type, idx, NULL, resultlength, &status);
if(status==U_BUFFER_OVERFLOW_ERROR){
status=U_ZERO_ERROR;
resultlength=resultlengthout+1;
value=(UChar*)malloc(sizeof(UChar) * resultlength);
udat_getSymbols(to, type, idx, value, resultlength, &status);
}
if(U_FAILURE(status)){
log_err("FAIL: error in retrieving the value using getSymbols i.e roundtrip\n %s\n",
myErrorName(status) );
return;
}
if(u_strcmp(result, value)!=0){
log_data_err("FAIL:Error in setting and then getting symbols\n Expected %s Got %s\n", austrdup(result),
austrdup(value) );
}
else
log_verbose("PASS: setSymbols successful\n");
free(value);
free(result);
}
void TestQuotePattern161()
{
UDateFormat *format;
UCalendar *cal;
UDate currentTime_1;
UChar *pattern, *tzID, *exp;
UChar *dateString;
UErrorCode status = U_ZERO_ERROR;
const char* expStr = "04/13/1999 at 10:42:28 AM ";
ctest_setTimeZone(NULL, &status);
pattern=(UChar*)malloc(sizeof(UChar) * (strlen("MM/dd/yyyy 'at' hh:mm:ss a zzz")+1) );
u_uastrcpy(pattern, "MM/dd/yyyy 'at' hh:mm:ss a zzz");
/* this is supposed to open default date format, but later on it treats it like it is "en_US"
- very bad if you try to run the tests on machine where default locale is NOT "en_US" */
/* format= udat_openPattern(pattern, u_strlen(pattern), NULL, &status); */
format= udat_open(UDAT_IGNORE, UDAT_IGNORE,"en_US", NULL, 0,pattern, u_strlen(pattern), &status);
if(U_FAILURE(status)){
log_err_status(status, "error in udat_open: %s\n", myErrorName(status));
return;
}
tzID=(UChar*)malloc(sizeof(UChar) * 4);
u_uastrcpy(tzID, "PST");
/* this is supposed to open default date format, but later on it treats it like it is "en_US"
- very bad if you try to run the tests on machine where default locale is NOT "en_US" */
/* cal=ucal_open(tzID, u_strlen(tzID), NULL, UCAL_TRADITIONAL, &status); */
cal=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_TRADITIONAL, &status);
if(U_FAILURE(status)){ log_err("error in ucal_open cal : %s\n", myErrorName(status)); }
ucal_setDateTime(cal, 1999, UCAL_APRIL, 13, 10, 42, 28, &status);
currentTime_1 = ucal_getMillis(cal, &status);
dateString = myDateFormat(format, currentTime_1);
exp=(UChar*)malloc(sizeof(UChar) * (strlen(expStr) + 1) );
u_uastrcpy(exp, expStr);
log_verbose("%s\n", austrdup(dateString) );
if(u_strncmp(dateString, exp, (int32_t)strlen(expStr)) !=0)
log_err("Error in formatting a pattern with single quotes\n");
udat_close(format);
ucal_close(cal);
free(exp);
free(tzID);
free(pattern);
ctest_resetTimeZone();
}
/**
* @bug 4060212
*/
void Test4060212()
{
int32_t pos;
UCalendar *cal;
UDateFormat *formatter, *fmt;
UErrorCode status = U_ZERO_ERROR;
UDate myDate;
UChar *myString;
UChar dateString[30], pattern[20], tzID[4];
u_uastrcpy(dateString, "1995-040.05:01:29 -8");
u_uastrcpy(pattern, "yyyy-DDD.hh:mm:ss z");
log_verbose( "dateString= %s Using yyyy-DDD.hh:mm:ss\n", austrdup(dateString) );
status = U_ZERO_ERROR;
u_uastrcpy(tzID, "PST");
formatter = udat_open(UDAT_IGNORE,UDAT_IGNORE,"en_US",tzID,-1,pattern, u_strlen(pattern), &status);
pos=0;
myDate = udat_parse(formatter, dateString, u_strlen(dateString), &pos, &status);
fmt = udat_open(UDAT_FULL,UDAT_LONG ,NULL, tzID, -1, NULL, 0, &status);
if(U_FAILURE(status))
{
log_data_err("FAIL: error in creating the dateformat using default date and time style: %s - (Are you missing data?)\n",
myErrorName(status) );
return;
}
myString = myFormatit(fmt, myDate);
cal=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_GREGORIAN, &status);
if(U_FAILURE(status)) {
log_err("FAIL: error in ucal_open caldef : %s\n", myErrorName(status));
}
ucal_setMillis(cal, myDate, &status);
if ((ucal_get(cal, UCAL_DAY_OF_YEAR, &status) != 40)) {
log_err("Fail: Got %d Expected 40\n", ucal_get(cal, UCAL_DAY_OF_YEAR, &status));
}
udat_close(formatter);
ucal_close(cal);
udat_close(fmt);
}
static void VerifysetSymbols(UDateFormat* datfor, UDateFormatSymbolType type, int32_t idx, const char* expected)
{
UChar *result=NULL;
UChar *value=NULL;
int32_t resultlength, resultlengthout;
UErrorCode status = U_ZERO_ERROR;
value=(UChar*)malloc(sizeof(UChar) * (strlen(expected) + 1));
u_uastrcpy(value, expected);
udat_setSymbols(datfor, type, idx, value, u_strlen(value), &status);
if(U_FAILURE(status))
{
log_err("FAIL: Error in udat_setSymbols() %s\n", myErrorName(status) );
return;
}
resultlength=0;
resultlengthout=udat_getSymbols(datfor, type, idx, NULL, resultlength, &status);
if(status==U_BUFFER_OVERFLOW_ERROR){
status=U_ZERO_ERROR;
resultlength=resultlengthout+1;
result=(UChar*)malloc(sizeof(UChar) * resultlength);
udat_getSymbols(datfor, type, idx, result, resultlength, &status);
}
if(U_FAILURE(status)){
log_err("FAIL: error in retrieving the value using getSymbols after setting it previously\n %s\n",
myErrorName(status) );
return;
}
if(u_strcmp(result, value)!=0){
log_err("FAIL:Error in setting and then getting symbols\n Expected %s Got %s\n", austrdup(value),
austrdup(result) );
}
else
log_verbose("PASS: setSymbols successful\n");
free(value);
free(result);
}
/**
* SimpleDateFormat does not properly parse date strings without delimiters
* @bug 4059917
*/
void Test4059917()
{
UDateFormat* def;
UChar *myDate;
UErrorCode status = U_ZERO_ERROR;
UChar pattern[11];
UChar tzID[4];
log_verbose("Testing apply pattern and to pattern regressively\n");
u_uastrcpy(tzID, "PST");
u_uastrcpy(pattern, "yyyy/MM/dd");
log_verbose("%s\n", austrdup(pattern) );
def = udat_open(UDAT_IGNORE,UDAT_IGNORE,NULL,tzID,-1,pattern, u_strlen(pattern),&status);
if(U_FAILURE(status))
{
log_data_err("FAIL: error in creating the dateformat using openPattern: %s - (Are you missing data?)\n", myErrorName(status));
return;
}
myDate=(UChar*)malloc(sizeof(UChar) * 11);
u_uastrcpy(myDate, "1970/01/12");
aux917( def, myDate );
udat_close(def);
u_uastrcpy(pattern, "yyyyMMdd");
def = udat_open(UDAT_IGNORE,UDAT_IGNORE,NULL,tzID,-1,pattern, u_strlen(pattern),&status);
if(U_FAILURE(status))
{
log_err("FAIL: error in creating the dateformat using openPattern: %s\n", myErrorName(status));
return;
}
u_uastrcpy(myDate, "19700112");
aux917( def, myDate );
udat_close(def);
free(myDate);
}
/**
* Test the functioning of the secondary grouping value.
*/
static void TestSecondaryGrouping(void) {
UErrorCode status = U_ZERO_ERROR;
UNumberFormat *f = NULL, *g= NULL;
UNumberFormat *us = unum_open(UNUM_DECIMAL,NULL,0, "en_US", NULL,&status);
UFieldPosition pos;
UChar resultBuffer[512];
int32_t l = 1876543210L;
UBool ok = TRUE;
UChar buffer[512];
int32_t i;
UBool expectGroup = FALSE, isGroup = FALSE;
u_uastrcpy(buffer, "#,##,###");
f = unum_open(UNUM_IGNORE,buffer, -1, "en_US",NULL, &status);
if (U_FAILURE(status)) {
log_data_err("Error DecimalFormat ct -> %s (Are you missing data?)\n", u_errorName(status));
return;
}
pos.field = 0;
unum_format(f, (int32_t)123456789L, resultBuffer, 512 , &pos, &status);
u_uastrcpy(buffer, "12,34,56,789");
if ((u_strcmp(resultBuffer, buffer) != 0) || U_FAILURE(status))
{
log_err("Fail: Formatting \"#,##,###\" pattern with 123456789 got %s, expected %s\n", austrdup(resultBuffer), "12,34,56,789");
}
if (pos.beginIndex != 0 && pos.endIndex != 12) {
log_err("Fail: Formatting \"#,##,###\" pattern pos = (%d, %d) expected pos = (0, 12)\n", pos.beginIndex, pos.endIndex);
}
memset(resultBuffer,0, sizeof(UChar)*512);
unum_toPattern(f, FALSE, resultBuffer, 512, &status);
u_uastrcpy(buffer, "#,##,##0");
if ((u_strcmp(resultBuffer, buffer) != 0) || U_FAILURE(status))
{
log_err("Fail: toPattern() got %s, expected %s\n", austrdup(resultBuffer), "#,##,##0");
}
memset(resultBuffer,0, sizeof(UChar)*512);
u_uastrcpy(buffer, "#,###");
unum_applyPattern(f, FALSE, buffer, -1,NULL,NULL);
if (U_FAILURE(status))
{
log_err("Fail: applyPattern call failed\n");
}
unum_setAttribute(f, UNUM_SECONDARY_GROUPING_SIZE, 4);
unum_format(f, (int32_t)123456789L, resultBuffer, 512 , &pos, &status);
u_uastrcpy(buffer, "12,3456,789");
if ((u_strcmp(resultBuffer, buffer) != 0) || U_FAILURE(status))
{
log_err("Fail: Formatting \"#,###\" pattern with 123456789 got %s, expected %s\n", austrdup(resultBuffer), "12,3456,789");
}
memset(resultBuffer,0, sizeof(UChar)*512);
unum_toPattern(f, FALSE, resultBuffer, 512, &status);
u_uastrcpy(buffer, "#,####,##0");
if ((u_strcmp(resultBuffer, buffer) != 0) || U_FAILURE(status))
{
log_err("Fail: toPattern() got %s, expected %s\n", austrdup(resultBuffer), "#,####,##0");
}
memset(resultBuffer,0, sizeof(UChar)*512);
g = unum_open(UNUM_DECIMAL, NULL,0,"hi_IN",NULL, &status);
if (U_FAILURE(status))
{
log_err("Fail: Cannot create UNumberFormat for \"hi_IN\" locale.\n");
}
unum_format(g, l, resultBuffer, 512, &pos, &status);
unum_close(g);
/* expect "1,87,65,43,210", but with Hindi digits */
/* 01234567890123 */
if (u_strlen(resultBuffer) != 14) {
ok = FALSE;
} else {
for (i=0; i<u_strlen(resultBuffer); ++i) {
expectGroup = FALSE;
switch (i) {
case 1:
case 4:
case 7:
case 10:
expectGroup = TRUE;
break;
}
/* Later -- fix this to get the actual grouping */
/* character from the resource bundle. */
isGroup = (UBool)(resultBuffer[i] == 0x002C);
if (isGroup != expectGroup) {
ok = FALSE;
break;
}
}
}
if (!ok) {
log_err("FAIL Expected %s x hi_IN -> \"1,87,65,43,210\" (with Hindi digits), got %s\n", "1876543210L", resultBuffer);
}
unum_close(f);
unum_close(us);
}
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);
}
/* Test u_formatMessage() with various test patterns() */
static void MessageFormatTest( void )
{
UChar *str;
UChar* result;
int32_t resultLengthOut,resultlength,i, patternlength;
UErrorCode status = U_ZERO_ERROR;
UDate d1=1000000000.0;
ctest_setTimeZone(NULL, &status);
str=(UChar*)malloc(sizeof(UChar) * 7);
u_uastrncpy(str, "MyDisk", 7);
resultlength=1;
result=(UChar*)malloc(sizeof(UChar) * 1);
log_verbose("Testing u_formatMessage()\n");
InitStrings();
for (i = 0; i < cnt_testCases; i++) {
status=U_ZERO_ERROR;
patternlength=u_strlen(testCasePatterns[i]);
resultLengthOut=u_formatMessage( "en_US",testCasePatterns[i], patternlength, result, resultlength,
&status, 1, 3456.00, d1);
if(status== U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
resultlength=resultLengthOut+1;
result=(UChar*)realloc(result,sizeof(UChar) * resultlength);
u_formatMessage( "en_US",testCasePatterns[i], patternlength, result, resultlength,
&status, 1, 3456.00, d1);
}
if(U_FAILURE(status)){
log_data_err("ERROR: failure in message format on testcase %d: %s (Are you missing data?)\n", i, myErrorName(status) );
continue;
}
if(u_strcmp(result, testResultStrings[i])==0){
log_verbose("PASS: MessagFormat successful on testcase : %d\n", i);
}
else{
log_err("FAIL: Error in MessageFormat on testcase : %d\n GOT %s EXPECTED %s\n", i,
austrdup(result), austrdup(testResultStrings[i]) );
}
}
free(result);
result = NULL;
free(str);
{
for (i = 0; i < cnt_testCases; i++) {
UParseError parseError;
status=U_ZERO_ERROR;
patternlength=u_strlen(testCasePatterns[i]);
resultlength=0;
resultLengthOut=u_formatMessageWithError( "en_US",testCasePatterns[i], patternlength, result, resultlength,
&parseError,&status, 1, 3456.00, d1);
if(status== U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
resultlength=resultLengthOut+1;
result=(UChar*)malloc(sizeof(UChar) * resultlength);
u_formatMessage( "en_US",testCasePatterns[i], patternlength, result, resultlength,
&status, 1, 3456.00, d1);
}
if(U_FAILURE(status)){
log_data_err("ERROR: failure in message format on testcase %d: %s (Are you missing data?)\n", i, myErrorName(status) );
continue;
}
if(u_strcmp(result, testResultStrings[i])==0){
log_verbose("PASS: MessagFormat successful on testcase : %d\n", i);
}
else{
log_err("FAIL: Error in MessageFormat on testcase : %d\n GOT %s EXPECTED %s\n", i,
austrdup(result), austrdup(testResultStrings[i]) );
}
free(result);
result=NULL;
}
}
{
UErrorCode ec = U_ZERO_ERROR;
int32_t patternLength = u_strlen(testCasePatterns[0]);
UMessageFormat formatter = umsg_open(testCasePatterns[0],patternLength,"en_US",NULL,&ec);
if(U_FAILURE(ec)){
log_data_err("umsg_open() failed for testCasePattens[%d]. -> %s (Are you missing data?)\n",i, u_errorName(ec));
return;
}
for(i = 0;i<cnt_testCases; i++){
UParseError parseError;
int32_t resultLength =0,count=0;
int32_t one=0;
int32_t two=0;
UDate d2=0;
result=NULL;
patternLength = u_strlen(testCasePatterns[i]);
umsg_applyPattern(formatter,testCasePatterns[i],patternLength,&parseError,&ec);
if(U_FAILURE(ec)){
log_err("umsg_applyPattern() failed for testCasePattens[%d].\n",i);
return;
}
/* pre-flight */
resultLength = umsg_format(formatter,result,resultLength,&ec,1,3456.00,d1);
if(ec==U_BUFFER_OVERFLOW_ERROR){
ec=U_ZERO_ERROR;
result = (UChar*) malloc(U_SIZEOF_UCHAR*resultLength+2);
resultLength = umsg_format(formatter,result,resultLength+2,&ec,1,3456.00,d1);
if(U_FAILURE(ec)){
log_err("ERROR: failure in message format on testcase %d: %s\n", i, u_errorName(status) );
free(result);
return;
}
if(u_strcmp(result, testResultStrings[i])==0){
log_verbose("PASS: MessagFormat successful on testcase : %d\n", i);
}
else{
log_err("FAIL: Error in MessageFormat on testcase : %d\n GOT %s EXPECTED %s\n", i,
austrdup(result), austrdup(testResultStrings[i]) );
}
if (returnsNullForType(1, (double)2.0)) {
/* HP/UX and possibly other platforms don't properly check for this case.
We pass in a UDate, but the function expects a UDate *. When va_arg is used,
most compilers will return NULL, but HP-UX won't do that and will return 2
in this case. This is a platform dependent test.
This relies upon "undefined" behavior, as indicated by C99 7.15.1.1 paragraph 2
*/
umsg_parse(formatter,result,resultLength,&count,&ec,one,two,d2);
if(ec!=U_ILLEGAL_ARGUMENT_ERROR){
log_err("FAIL: Did not get expected error for umsg_parse(). Expected: U_ILLEGAL_ARGUMENT_ERROR Got: %s \n",u_errorName(ec));
}else{
ec = U_ZERO_ERROR;
}
}
else {
log_verbose("Warning: Returning NULL for a mismatched va_arg type isn't supported on this platform.\n", i);
}
umsg_parse(formatter,result,resultLength,&count,&ec,&one,&two,&d2);
if(U_FAILURE(ec)){
log_err("umsg_parse could not parse the pattern. Error: %s.\n",u_errorName(ec));
}
free(result);
}else{
log_err("FAIL: Expected U_BUFFER_OVERFLOW error while preflighting got: %s for testCasePatterns[%d]",u_errorName(ec),i);
}
}
umsg_close(formatter);
}
FreeStrings();
ctest_resetTimeZone();
}
static void TestPUtilAPI(void){
double n1=0.0, y1=0.0, expn1, expy1;
double value1 = 0.021;
UVersionInfo versionArray = {0x01, 0x00, 0x02, 0x02};
char versionString[17]; /* xxx.xxx.xxx.xxx\0 */
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(VERBOSITY){
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_log10()\n");
doAssert(uprv_log10(3456), 3, "uprv_log10(3456) failed.");
#ifdef OS390
doAssert(uprv_log10(1.0e55), 55, "uprv_log10(1.0e55) failed.");
#else
doAssert(uprv_log10(1.0e300), 300, "uprv_log10(1.0e300) failed.");
#endif
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_versionToString().....\n");
u_versionToString(versionArray, versionString);
if(strcmp(versionString, "1.0.2.2") != 0){
log_err("ERROR: u_versionToString() failed. Expected: 1.0.2.2, Got=%s\n", versionString);
}
log_verbose("Testing the API u_versionToString().....with versionArray=NULL\n");
u_versionToString(NULL, versionString);
if(strcmp(versionString, "") != 0){
log_err("ERROR: u_versionToString() failed. with versionArray=NULL. It should just return\n");
}
log_verbose("Testing the API u_versionToString().....with versionArray=NULL\n");
u_versionToString(NULL, versionString);
if(strcmp(versionString, "") != 0){
log_err("ERROR: u_versionToString() failed . It should just return\n");
}
log_verbose("Testing the API u_versionToString().....with versionString=NULL\n");
u_versionToString(versionArray, NULL);
if(strcmp(versionString, "") != 0){
log_err("ERROR: u_versionToString() failed. with versionArray=NULL It should just return\n");
}
versionArray[0] = 0x0a;
log_verbose("Testing the API u_versionToString().....\n");
u_versionToString(versionArray, versionString);
if(strcmp(versionString, "10.0.2.2") != 0){
log_err("ERROR: u_versionToString() failed. Expected: 10.0.2.2, Got=%s\n", versionString);
}
versionArray[0] = 0xa0;
u_versionToString(versionArray, versionString);
if(strcmp(versionString, "160.0.2.2") != 0){
log_err("ERROR: u_versionToString() failed. Expected: 160.0.2.2, Got=%s\n", versionString);
}
versionArray[0] = 0xa0;
versionArray[1] = 0xa0;
u_versionToString(versionArray, versionString);
if(strcmp(versionString, "160.160.2.2") != 0){
log_err("ERROR: u_versionToString() failed. Expected: 160.160.2.2, Got=%s\n", versionString);
}
versionArray[0] = 0x01;
versionArray[1] = 0x0a;
u_versionToString(versionArray, versionString);
if(strcmp(versionString, "1.10.2.2") != 0){
log_err("ERROR: u_versionToString() failed. Expected: 160.160.2.2, Got=%s\n", versionString);
}
log_verbose("Testing the API u_versionFromString() ....\n");
u_versionFromString(versionArray, "1.3.5.6");
u_versionToString(versionArray, versionString);
if(strcmp(versionString, "1.3.5.6") != 0){
log_err("ERROR: u_getVersion() failed. Expected: 1.3.5.6, Got=%s\n", versionString);
}
log_verbose("Testing the API u_versionFromString() where versionArray=NULL....\n");
u_versionFromString(NULL, "1.3.5.6");
u_versionToString(versionArray, versionString);
if(strcmp(versionString, "1.3.5.6") != 0){
log_err("ERROR: u_getVersion() failed. Expected: 1.3.5.6, Got=%s\n", versionString);
}
log_verbose("Testing the API u_getVersion().....\n");
u_getVersion(versionArray);
u_versionToString(versionArray, versionString);
if(strcmp(versionString, U_ICU_VERSION) != 0){
log_err("ERROR: u_getVersion() failed. Got=%s, expected %s\n", versionString, U_ICU_VERSION);
}
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;
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*/
udataDir=(UChar*)malloc(sizeof(UChar) * (strlen(dataDirectory) + 1));
u_charsToUChars(dataDirectory, udataDir, (strlen(dataDirectory)+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_err("FAIL: t_timezone may be incorrect. It is not a multiple of 30min.");
}
tzoffset=uprv_getUTCtime();
}
}
/* test message format with a choice option */
static void TestMsgFormatChoice(void)
{
UChar* str;
UErrorCode status = U_ZERO_ERROR;
UChar *result;
UChar pattern[100];
UChar expected[100];
int32_t resultlength,resultLengthOut;
str=(UChar*)malloc(sizeof(UChar) * 25);
u_uastrcpy(str, "MyDisk");
log_verbose("Testing message format with choice test #6\n:");
/*There {0,choice,0#are no files|1#is one file|1<are {0,number,integer} files}.*/
u_uastrcpy(pattern, "The disk {1} contains {0,choice,0#no files|1#one file|1<{0,number,integer} files}");
u_uastrcpy(expected, "The disk MyDisk contains 100 files");
resultlength=0;
resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), NULL, resultlength, &status, 100., str);
if(status==U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
resultlength=resultLengthOut+1;
result=(UChar*)malloc(sizeof(UChar) * resultlength);
u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, 100., str);
if(u_strcmp(result, expected)==0)
log_verbose("PASS: MessagFormat successful on test#6\n");
else{
log_err("FAIL: Error in MessageFormat on test#6\n GOT %s EXPECTED %s\n", austrdup(result),
austrdup(expected) );
}
free(result);
}
if(U_FAILURE(status)){
log_data_err("ERROR: failure in message format on test#6 : %s (Are you missing data?)\n", myErrorName(status));
}
log_verbose("Testing message format with choice test #7\n:");
u_uastrcpy(expected, "The disk MyDisk contains no files");
resultlength=0;
resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), NULL, resultlength, &status, 0., str);
if(status==U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
resultlength=resultLengthOut+1;
result=(UChar*)malloc(sizeof(UChar) * resultlength);
u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, 0., str);
if(u_strcmp(result, expected)==0)
log_verbose("PASS: MessagFormat successful on test#7\n");
else{
log_err("FAIL: Error in MessageFormat on test#7\n GOT: %s EXPECTED %s\n", austrdup(result),
austrdup(expected) );
}
free(result);
}
if(U_FAILURE(status)){
log_data_err("ERROR: failure in message format on test#7 : %s (Are you missing data?)\n", myErrorName(status));
}
log_verbose("Testing message format with choice test #8\n:");
u_uastrcpy(expected, "The disk MyDisk contains one file");
resultlength=0;
resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), NULL, resultlength, &status, 1., str);
if(status==U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
resultlength=resultLengthOut+1;
result=(UChar*)malloc(sizeof(UChar) * resultlength);
u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, 1., str);
if(u_strcmp(result, expected)==0)
log_verbose("PASS: MessagFormat successful on test#8\n");
else{
log_err("FAIL: Error in MessageFormat on test#8\n GOT %s EXPECTED: %s\n", austrdup(result),
austrdup(expected) );
}
free(result);
}
if(U_FAILURE(status)){
log_data_err("ERROR: failure in message format on test#8 : %s (Are you missing data?)\n", myErrorName(status));
}
free(str);
}
/* Test message format with a Select option */
static void TestMsgFormatSelect(void)
{
UChar* str;
UChar* str1;
UErrorCode status = U_ZERO_ERROR;
UChar *result;
UChar pattern[100];
UChar expected[100];
int32_t resultlength,resultLengthOut;
str=(UChar*)malloc(sizeof(UChar) * 25);
u_uastrcpy(str, "Kirti");
str1=(UChar*)malloc(sizeof(UChar) * 25);
u_uastrcpy(str1, "female");
log_verbose("Testing message format with Select test #1\n:");
u_uastrcpy(pattern, "{0} est {1, select, female {all\\u00E9e} other {all\\u00E9}} \\u00E0 Paris.");
u_uastrcpy(expected, "Kirti est all\\u00E9e \\u00E0 Paris.");
resultlength=0;
resultLengthOut=u_formatMessage( "fr", pattern, u_strlen(pattern), NULL, resultlength, &status, str , str1);
if(status==U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
resultlength=resultLengthOut+1;
result=(UChar*)malloc(sizeof(UChar) * resultlength);
u_formatMessage( "fr", pattern, u_strlen(pattern), result, resultlength, &status, str , str1);
if(u_strcmp(result, expected)==0)
log_verbose("PASS: MessagFormat successful on Select test#1\n");
else{
log_err("FAIL: Error in MessageFormat on Select test#1\n GOT %s EXPECTED %s\n", austrdup(result),
austrdup(expected) );
}
free(result);
}
if(U_FAILURE(status)){
log_data_err("ERROR: failure in message format on Select test#1 : %s \n", myErrorName(status));
}
free(str);
free(str1);
/*Test a nested pattern*/
str=(UChar*)malloc(sizeof(UChar) * 25);
u_uastrcpy(str, "Noname");
str1=(UChar*)malloc(sizeof(UChar) * 25);
u_uastrcpy(str1, "other");
log_verbose("Testing message format with Select test #2\n:");
u_uastrcpy(pattern, "{0} est {1, select, female {{2,number,integer} all\\u00E9e} other {all\\u00E9}} \\u00E0 Paris.");
u_uastrcpy(expected, "Noname est all\\u00E9 \\u00E0 Paris.");
resultlength=0;
resultLengthOut=u_formatMessage( "fr", pattern, u_strlen(pattern), NULL, resultlength, &status, str , str1,6);
if(status==U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
resultlength=resultLengthOut+1;
result=(UChar*)malloc(sizeof(UChar) * resultlength);
u_formatMessage( "fr", pattern, u_strlen(pattern), result, resultlength, &status, str , str1);
if(u_strcmp(result, expected)==0)
log_verbose("PASS: MessagFormat successful on Select test#2\n");
else{
log_err("FAIL: Error in MessageFormat on Select test#2\n GOT %s EXPECTED %s\n", austrdup(result),
austrdup(expected) );
}
free(result);
}
if(U_FAILURE(status)){
log_data_err("ERROR: failure in message format on Select test#2 : %s \n", myErrorName(status));
}
free(str);
free(str1);
}
/* Test u_formatMessage() and u_parseMessage() , format and parse sequence and round trip */
static void TestSampleFormatAndParse(void)
{
UChar *result, *tzID, *str;
UChar pattern[100];
UChar expected[100];
int32_t resultLengthOut, resultlength;
UCalendar *cal;
UDate d1,d;
UDateFormat *def1;
UErrorCode status = U_ZERO_ERROR;
int32_t value = 0;
UChar ret[30];
ctest_setTimeZone(NULL, &status);
log_verbose("Testing format and parse\n");
str=(UChar*)malloc(sizeof(UChar) * 25);
u_uastrcpy(str, "disturbance in force");
tzID=(UChar*)malloc(sizeof(UChar) * 4);
u_uastrcpy(tzID, "PST");
cal=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_TRADITIONAL, &status);
if(U_FAILURE(status)){
log_data_err("error in ucal_open caldef : %s - (Are you missing data?)\n", myErrorName(status) );
}
ucal_setDateTime(cal, 1999, UCAL_MARCH, 18, 0, 0, 0, &status);
d1=ucal_getMillis(cal, &status);
if(U_FAILURE(status)){
log_data_err("Error: failure in get millis: %s - (Are you missing data?)\n", myErrorName(status) );
}
log_verbose("\nTesting with pattern test#4");
u_uastrcpy(pattern, "On {0, date, long}, there was a {1} on planet {2,number,integer}");
u_uastrcpy(expected, "On March 18, 1999, there was a disturbance in force on planet 7");
resultlength=1;
result=(UChar*)malloc(sizeof(UChar) * resultlength);
resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, d1, str, 7);
if(status==U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
resultlength=resultLengthOut+1;
result=(UChar*)realloc(result, sizeof(UChar) * resultlength);
u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, d1, str, 7);
}
if(U_FAILURE(status)){
log_data_err("ERROR: failure in message format test#4: %s (Are you missing data?)\n", myErrorName(status));
}
else if(u_strcmp(result, expected)==0)
log_verbose("PASS: MessagFormat successful on test#4\n");
else{
log_err("FAIL: Error in MessageFormat on test#4\n GOT: %s EXPECTED: %s\n", austrdup(result),
austrdup(expected) );
}
/*try to parse this and check*/
log_verbose("\nTesting the parse Message test#5\n");
u_parseMessage("en_US", pattern, u_strlen(pattern), result, u_strlen(result), &status, &d, ret, &value);
if(U_FAILURE(status)){
log_data_err("ERROR: error in parsing: test#5: %s (Are you missing data?)\n", myErrorName(status));
}
else if(value!=7 && u_strcmp(str,ret)!=0)
log_err("FAIL: Error in parseMessage on test#5 \n");
else
log_verbose("PASS: parseMessage successful on test#5\n");
def1 = udat_open(UDAT_DEFAULT,UDAT_DEFAULT ,NULL, NULL, 0, NULL,0,&status);
if(U_FAILURE(status))
{
log_data_err("error in creating the dateformat using short date and time style: %s (Are you missing data?)\n", myErrorName(status));
}else{
if(u_strcmp(myDateFormat(def1, d), myDateFormat(def1, d1))==0)
log_verbose("PASS: parseMessage successful test#5\n");
else{
log_err("FAIL: parseMessage didn't parse the date successfully\n GOT: %s EXPECTED %s\n",
austrdup(myDateFormat(def1,d)), austrdup(myDateFormat(def1,d1)) );
}
}
udat_close(def1);
ucal_close(cal);
free(result);
free(str);
free(tzID);
ctest_resetTimeZone();
}
/**
* @bug 4073003
*/
void Test4073003()
{
int32_t pos,i;
UDate d,dd;
UChar *datestr;
UChar temp[15];
UErrorCode status = U_ZERO_ERROR;
UDateFormat *fmt;
UChar *result, *result2;
const char* tests [] = {
"12/25/61",
"12/25/1961",
"4/3/1999",
"4/3/99"
};
fmt= udat_open(UDAT_SHORT,UDAT_SHORT ,NULL, NULL, 0, NULL, 0, &status);
if(U_FAILURE(status))
{
log_data_err("FAIL: error in creating the dateformat using short date and time style: %s (Are you missing data?)\n",
myErrorName(status));
return;
}
u_uastrcpy(temp, "m/D/yy");
udat_applyPattern(fmt, FALSE, temp, u_strlen(temp));
for(i= 0; i < 4; i+=2) {
status=U_ZERO_ERROR;
datestr=(UChar*)malloc(sizeof(UChar) * (strlen(tests[i])+1));
u_uastrcpy(datestr, tests[i]);
pos=0;
d = udat_parse(fmt, datestr, u_strlen(datestr), &pos, &status);
if(U_FAILURE(status)) {
log_err("ERROR : in test 4073003: %s\n", myErrorName(status));
}
free(datestr);
datestr=(UChar*)malloc(sizeof(UChar) * (strlen(tests[i+1])+1));
u_uastrcpy(datestr, tests[i+1]);
pos=0;
status=U_ZERO_ERROR;
dd = udat_parse(fmt, datestr, u_strlen(datestr), &pos, &status);
if(U_FAILURE(status)) {
log_err("ERROR : in test 4073003: %s\n", myErrorName(status));
}
free(datestr);
result =myFormatit(fmt, d);
result2 =myFormatit(fmt, dd);
if(!result || !result2) {
log_data_err("Fail: could not format - exitting test\n");
return;
}
if (u_strcmp(result, result2)!=0) {
log_err("Fail: %s != %s\n", austrdup(result), austrdup(result2) );
}
else {
log_verbose("Ok: %s == %s\n", austrdup(result), austrdup(result2) );
}
}
udat_close(fmt);
}
/* Test whether apps and ICU can each have their own root.res */
static void TestAppData()
{
UResourceBundle *icu, *app;
UResourceBundle *tmp = NULL;
UResourceBundle *tmp2 = NULL;
const UChar *appString;
const UChar *icuString;
int32_t len;
UErrorCode status = U_ZERO_ERROR;
char testMsgBuf[256];
const char* testPath=loadTestData(&status);
icu = ures_open(NULL, "root", &status);
if(U_FAILURE(status))
{
log_err("%s:%d: Couldn't open root ICU bundle- %s", __FILE__, __LINE__, u_errorName(status));
return;
}
/* log_info("Open icu root: %s size_%d\n", u_errorName(status), ures_getSize(icu)); */
status = U_ZERO_ERROR;
app = ures_open(testPath, "root", &status);
if(U_FAILURE(status))
{
log_err("%s:%d: Couldn't open app ICU bundle [%s]- %s", __FILE__, __LINE__, testPath, u_errorName(status));
return;
}
/* log_info("Open app: %s, size %d\n", u_errorName(status), ures_getSize(app)); */
tmp = ures_getByKey(icu, "Version", tmp, &status);
if(U_FAILURE(status))
{
log_err("%s:%d: Couldn't get Version string from ICU root bundle- %s", __FILE__, __LINE__, u_errorName(status));
return;
}
icuString = ures_getString(tmp, &len, &status);
if(U_FAILURE(status))
{
log_err("%s:%d: Couldn't get string from Version string from ICU root bundle- %s", __FILE__, __LINE__, u_errorName(status));
return;
}
/* log_info("icuString=%p - %s\n", icuString, austrdup(icuString)); */
tmp2 = ures_getByKey(app, "Version", tmp2, &status);
if(U_FAILURE(status))
{
log_err("%s:%d: Couldn't get Version string from App root bundle- %s", __FILE__, __LINE__, u_errorName(status));
return;
}
appString = ures_getString(tmp2, &len, &status);
if(U_FAILURE(status))
{
log_err("%s:%d: Couldn't get string from Version string from App root bundle- %s", __FILE__, __LINE__, u_errorName(status));
return;
}
/* log_info("appString=%p - %s\n", appString, austrdup(appString)); */
if(!u_strcmp(icuString, appString))
{
log_err("%s:%d: Error! Expected ICU and App root version strings to be DIFFERENT but they are both %s and %s\n", __FILE__, __LINE__, austrdup(icuString),
austrdup(appString));
}
else
{
log_verbose("%s:%d: appstr=%s, icustr=%s\n", __FILE__,
__LINE__, u_austrcpy(testMsgBuf, appString), u_austrcpy(testMsgBuf, icuString));
}
ures_close(tmp);
ures_close(tmp2);
ures_close(icu);
ures_close(app);
}
/*Test Various format patterns*/
static void TestPatterns(void)
{
int32_t pat_length, i, lneed;
UNumberFormat *fmt;
UChar upat[5];
UChar unewpat[5];
UChar unum[5];
UChar *unewp=NULL;
UChar *str=NULL;
UErrorCode status = U_ZERO_ERROR;
const char* pat[] = { "#.#", "#.", ".#", "#" };
const char* newpat[] = { "0.#", "0.", "#.0", "0" };
const char* num[] = { "0", "0.", ".0", "0" };
log_verbose("\nTesting different format patterns\n");
pat_length = UPRV_LENGTHOF(pat);
for (i=0; i < pat_length; ++i)
{
status = U_ZERO_ERROR;
u_uastrcpy(upat, pat[i]);
fmt= unum_open(UNUM_IGNORE,upat, u_strlen(upat), "en_US",NULL, &status);
if (U_FAILURE(status)) {
log_err_status(status, "FAIL: Number format constructor failed for pattern %s -> %s\n", pat[i], u_errorName(status));
continue;
}
lneed=0;
lneed=unum_toPattern(fmt, FALSE, NULL, lneed, &status);
if(status==U_BUFFER_OVERFLOW_ERROR){
status= U_ZERO_ERROR;
unewp=(UChar*)malloc(sizeof(UChar) * (lneed+1) );
unum_toPattern(fmt, FALSE, unewp, lneed+1, &status);
}
if(U_FAILURE(status)){
log_err("FAIL: Number format extracting the pattern failed for %s\n", pat[i]);
}
u_uastrcpy(unewpat, newpat[i]);
if(u_strcmp(unewp, unewpat) != 0)
log_err("FAIL: Pattern %s should be transmute to %s; %s seen instead\n", pat[i], newpat[i], austrdup(unewp) );
lneed=0;
lneed=unum_format(fmt, 0, NULL, lneed, NULL, &status);
if(status==U_BUFFER_OVERFLOW_ERROR){
status=U_ZERO_ERROR;
str=(UChar*)malloc(sizeof(UChar) * (lneed+1) );
unum_format(fmt, 0, str, lneed+1, NULL, &status);
}
if(U_FAILURE(status)) {
log_err("Error in formatting using unum_format(.....): %s\n", myErrorName(status) );
}
u_uastrcpy(unum, num[i]);
if (u_strcmp(str, unum) != 0)
{
log_err("FAIL: Pattern %s should format zero as %s; %s Seen instead\n", pat[i], num[i], austrdup(str) );
}
free(unewp);
free(str);
unum_close(fmt);
}
}
/* Test exponential pattern*/
static void TestExponential(void)
{
int32_t pat_length, val_length, lval_length;
int32_t ival, ilval, p, v, lneed;
UNumberFormat *fmt;
int32_t ppos;
UChar *upat;
UChar pattern[20];
UChar *str=NULL;
UChar uvalfor[20], ulvalfor[20];
char tempMsgBug[256];
double a;
UErrorCode status = U_ZERO_ERROR;
#if U_PLATFORM == U_PF_OS390
static const double val[] = { 0.01234, 123456789, 1.23e75, -3.141592653e-78 };
#else
static const double val[] = { 0.01234, 123456789, 1.23e300, -3.141592653e-271 };
#endif
static const char* pat[] = { "0.####E0", "00.000E00", "##0.######E000", "0.###E0;[0.###E0]" };
static const int32_t lval[] = { 0, -1, 1, 123456789 };
static const char* valFormat[] =
{
"1.234E-2", "1.2346E8", "1.23E300", "-3.1416E-271",
"12.340E-03", "12.346E07", "12.300E299", "-31.416E-272",
"12.34E-003", "123.4568E006", "1.23E300", "-314.1593E-273",
"1.234E-2", "1.235E8", "1.23E300", "[3.142E-271]"
};
static const char* lvalFormat[] =
{
"0E0", "-1E0", "1E0", "1.2346E8",
"00.000E00", "-10.000E-01", "10.000E-01", "12.346E07",
"0E000", "-1E000", "1E000", "123.4568E006",
"0E0", "[1E0]", "1E0", "1.235E8"
};
static const double valParse[] =
{
#if U_PLATFORM == U_PF_OS390
0.01234, 123460000, 1.23E75, -3.1416E-78,
0.01234, 123460000, 1.23E75, -3.1416E-78,
0.01234, 123456800, 1.23E75, -3.141593E-78,
0.01234, 123500000, 1.23E75, -3.142E-78
#else
/* We define the whole IEEE 754 number in the 4th column because
Visual Age 7 has a bug in rounding numbers. */
0.01234, 123460000, 1.23E300, -3.1415999999999999E-271,
0.01234, 123460000, 1.23E300, -3.1415999999999999E-271,
0.01234, 123456800, 1.23E300, -3.1415929999999999E-271,
0.01234, 123500000, 1.23E300, -3.1420000000000001E-271
#endif
};
static const int32_t lvalParse[] =
{
0, -1, 1, 123460000,
0, -1, 1, 123460000,
0, -1, 1, 123456800,
0, -1, 1, 123500000
};
pat_length = UPRV_LENGTHOF(pat);
val_length = UPRV_LENGTHOF(val);
lval_length = UPRV_LENGTHOF(lval);
ival = 0;
ilval = 0;
for (p=0; p < pat_length; ++p)
{
upat=(UChar*)malloc(sizeof(UChar) * (strlen(pat[p])+1) );
u_uastrcpy(upat, pat[p]);
fmt=unum_open(UNUM_IGNORE,upat, u_strlen(upat), "en_US",NULL, &status);
if (U_FAILURE(status)) {
log_err_status(status, "FAIL: Bad status returned by Number format construction with pattern %s -> %s\n", pat[p], u_errorName(status));
continue;
}
lneed= u_strlen(upat) + 1;
unum_toPattern(fmt, FALSE, pattern, lneed, &status);
log_verbose("Pattern \" %s \" -toPattern-> \" %s \" \n", upat, u_austrcpy(tempMsgBug, pattern) );
for (v=0; v<val_length; ++v)
{
/*format*/
lneed=0;
lneed=unum_formatDouble(fmt, val[v], NULL, lneed, NULL, &status);
if(status==U_BUFFER_OVERFLOW_ERROR){
status=U_ZERO_ERROR;
str=(UChar*)malloc(sizeof(UChar) * (lneed+1) );
unum_formatDouble(fmt, val[v], str, lneed+1, NULL, &status);
}
if(U_FAILURE(status)) {
log_err("Error in formatting using unum_format(.....): %s\n", myErrorName(status) );
}
u_uastrcpy(uvalfor, valFormat[v+ival]);
if(u_strcmp(str, uvalfor) != 0)
log_verbose("FAIL: Expected %s ( %s )\n", valFormat[v+ival], u_austrcpy(tempMsgBug, uvalfor) );
/*parsing*/
ppos=0;
a=unum_parseDouble(fmt, str, u_strlen(str), &ppos, &status);
if (ppos== u_strlen(str)) {
if (a != valParse[v+ival])
log_err("FAIL: Expected: %e, Got: %g\n", valParse[v+ival], a);
}
else
log_err(" FAIL: Partial parse ( %d chars ) -> %e\n", ppos, a);
free(str);
}
for (v=0; v<lval_length; ++v)
{
/*format*/
lneed=0;
lneed=unum_formatDouble(fmt, lval[v], NULL, lneed, NULL, &status);
if(status==U_BUFFER_OVERFLOW_ERROR){
status=U_ZERO_ERROR;
str=(UChar*)malloc(sizeof(UChar) * (lneed+1) );
unum_formatDouble(fmt, lval[v], str, lneed+1, NULL, &status);
}
if(U_FAILURE(status)) {
log_err("Error in formatting using unum_format(.....): %s\n", myErrorName(status) );
}
/*printf(" Format %e -> %s\n", lval[v], austrdup(str) );*/
u_uastrcpy(ulvalfor, lvalFormat[v+ilval]);
if(u_strcmp(str, ulvalfor) != 0)
log_err("FAIL: Expected %s ( %s )\n", valFormat[v+ilval], austrdup(ulvalfor) );
/*parsing*/
ppos=0;
a=unum_parseDouble(fmt, str, u_strlen(str), &ppos, &status);
if (ppos== u_strlen(str)) {
/*printf(" Parse -> %e\n", a);*/
if (a != lvalParse[v+ilval])
log_err("FAIL: Expected : %e\n", valParse[v+ival]);
}
else
log_err(" FAIL: Partial parse ( %d chars ) -> %e\n", ppos, a);
free(str);
}
ival += val_length;
ilval += lval_length;
unum_close(fmt);
free(upat);
}
}
static void verifyEnumeration(int line, UEnumeration *u, const char * const * compareToChar, const UChar * const * compareToUChar, int32_t expect_count) {
UErrorCode status = U_ZERO_ERROR;
int32_t got_count,i,len;
const char *c;
UChar buf[1024];
log_verbose("%s:%d: verifying enumeration..\n", __FILE__, line);
uenum_reset(u, &status);
if(U_FAILURE(status)) {
log_err("%s:%d: FAIL: could not reset char strings enumeration: %s\n", __FILE__, line, u_errorName(status));
return;
}
got_count = uenum_count(u, &status);
if(U_FAILURE(status)) {
log_err("%s:%d: FAIL: could not count char strings enumeration: %s\n", __FILE__, line, u_errorName(status));
return;
}
if(got_count!=expect_count) {
log_err("%s:%d: FAIL: expect count %d got %d\n", __FILE__, line, expect_count, got_count);
} else {
log_verbose("%s:%d: OK: got count %d\n", __FILE__, line, got_count);
}
if(compareToChar!=NULL) { /* else, not invariant */
for(i=0;i<got_count;i++) {
c = uenum_next(u,&len, &status);
if(U_FAILURE(status)) {
log_err("%s:%d: FAIL: could not iterate to next after %d: %s\n", __FILE__, line, i, u_errorName(status));
return;
}
if(c==NULL) {
log_err("%s:%d: FAIL: got NULL for next after %d: %s\n", __FILE__, line, i, u_errorName(status));
return;
}
if(strcmp(c,compareToChar[i])) {
log_err("%s:%d: FAIL: string #%d expected '%s' got '%s'\n", __FILE__, line, i, compareToChar[i], c);
} else {
log_verbose("%s:%d: OK: string #%d got '%s'\n", __FILE__, line, i, c);
}
if(len!=strlen(compareToChar[i])) {
log_err("%s:%d: FAIL: string #%d expected len %d got %d\n", __FILE__, line, i, strlen(compareToChar[i]), len);
} else {
log_verbose("%s:%d: OK: string #%d got len %d\n", __FILE__, line, i, len);
}
}
}
/* now try U */
uenum_reset(u, &status);
if(U_FAILURE(status)) {
log_err("%s:%d: FAIL: could not reset again char strings enumeration: %s\n", __FILE__, line, u_errorName(status));
return;
}
for(i=0;i<got_count;i++) {
const UChar *ustr = uenum_unext(u,&len, &status);
if(U_FAILURE(status)) {
log_err("%s:%d: FAIL: could not iterate to unext after %d: %s\n", __FILE__, line, i, u_errorName(status));
return;
}
if(ustr==NULL) {
log_err("%s:%d: FAIL: got NULL for unext after %d: %s\n", __FILE__, line, i, u_errorName(status));
return;
}
if(compareToChar!=NULL) {
u_charsToUChars(compareToChar[i], buf, strlen(compareToChar[i])+1);
if(u_strncmp(ustr,buf,len)) {
int j;
log_err("%s:%d: FAIL: ustring #%d expected '%s' got '%s'\n", __FILE__, line, i, compareToChar[i], austrdup(ustr));
for(j=0;ustr[j]&&buf[j];j++) {
log_verbose(" @ %d\t<U+%04X> vs <U+%04X>\n", j, ustr[j],buf[j]);
}
} else {
log_verbose("%s:%d: OK: ustring #%d got '%s'\n", __FILE__, line, i, compareToChar[i]);
}
if(len!=strlen(compareToChar[i])) {
log_err("%s:%d: FAIL: ustring #%d expected len %d got %d\n", __FILE__, line, i, strlen(compareToChar[i]), len);
} else {
log_verbose("%s:%d: OK: ustring #%d got len %d\n", __FILE__, line, i, len);
}
}
if(compareToUChar!=NULL) {
if(u_strcmp(ustr,compareToUChar[i])) {
int j;
log_err("%s:%d: FAIL: ustring #%d expected '%s' got '%s'\n", __FILE__, line, i, austrdup(compareToUChar[i]), austrdup(ustr));
for(j=0;ustr[j]&&compareToUChar[j];j++) {
log_verbose(" @ %d\t<U+%04X> vs <U+%04X>\n", j, ustr[j],compareToUChar[j]);
}
} else {
log_verbose("%s:%d: OK: ustring #%d got '%s'\n", __FILE__, line, i, austrdup(compareToUChar[i]));
}
if(len!=u_strlen(compareToUChar[i])) {
log_err("%s:%d: FAIL: ustring #%d expected len %d got %d\n", __FILE__, line, i, u_strlen(compareToUChar[i]), len);
} else {
log_verbose("%s:%d: OK: ustring #%d got len %d\n", __FILE__, line, i, len);
}
}
}
}
/**
* @bug 4029195
*/
void Test4029195()
{
int32_t resultlength, resultlengthneeded;
UChar *fmdt, *todayS, *rt;
UChar *pat=NULL;
UChar *temp;
UDate today, d1;
UDateFormat *df;
int32_t parsepos;
UErrorCode status = U_ZERO_ERROR;
log_verbose("Testing date format and parse function in regression test\n");
today = ucal_getNow();
df = udat_open(UDAT_DEFAULT,UDAT_DEFAULT ,"en_US", NULL, 0, NULL, 0, &status);
if(U_FAILURE(status))
{
log_data_err("FAIL: error in creating the dateformat using default date and time style : %s (Are you missing data?)\n", myErrorName(status));
return;
}
resultlength=0;
resultlengthneeded=udat_toPattern(df, TRUE, NULL, resultlength, &status);
if(status==U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
resultlength=resultlengthneeded + 1;
pat=(UChar*)malloc(sizeof(UChar) * resultlength);
udat_toPattern(df, TRUE, pat, resultlength, &status);
}
log_verbose("pattern: %s\n", austrdup(pat));
fmdt = myFormatit(df, today);
if(fmdt) {
log_verbose("today: %s\n", austrdup(fmdt));
} else {
log_data_err("ERROR: couldn't format, exitting test");
return;
}
temp=(UChar*)malloc(sizeof(UChar) * 10);
u_uastrcpy(temp, "M yyyy dd");
udat_applyPattern(df, TRUE, temp, u_strlen(temp));
todayS =myFormatit(df, today);
log_verbose("After teh pattern is applied\n today: %s\n", austrdup(todayS) );
parsepos=0;
d1=udat_parse(df, todayS, u_strlen(todayS), &parsepos, &status);
if(U_FAILURE(status))
{
log_err("FAIL: Error in parsing using udat_parse(.....): %s\n", myErrorName(status));
}
rt =myFormatit(df, d1);
log_verbose("today: %s\n", austrdup(rt) );
log_verbose("round trip: %s\n", austrdup(rt) );
if(u_strcmp(rt, todayS)!=0) {
log_err("Fail: Want %s Got %s\n", austrdup(todayS), austrdup(rt) );
}
else
log_verbose("Pass: parse and format working fine\n");
udat_close(df);
free(temp);
if(pat != NULL) {
free(pat);
}
}
/**
* @bug 4056591
* Verify the function of the [s|g]et2DigitYearStart() API.
*/
void Test4056591()
{
int i;
UCalendar *cal;
UDateFormat *def;
UDate start,exp,got;
UChar s[10];
UChar *gotdate, *expdate;
UChar pat[10];
UDate d[4];
UErrorCode status = U_ZERO_ERROR;
const char* strings[] = {
"091225",
"091224",
"611226",
"991227"
};
log_verbose("Testing s[get] 2 digit year start regressively\n");
cal=ucal_open(NULL, 0, "en_US", UCAL_GREGORIAN, &status);
if(U_FAILURE(status)) {
log_data_err("error in ucal_open caldef : %s - (Are you missing data?)\n", myErrorName(status));
return;
}
ucal_setDateTime(cal, 1809, UCAL_DECEMBER, 25, 17, 40, 30, &status);
d[0]=ucal_getMillis(cal, &status);
if(U_FAILURE(status)) {
log_err("Error: failure in get millis: %s\n", myErrorName(status));
}
ucal_setDateTime(cal, 1909, UCAL_DECEMBER, 24, 17, 40, 30, &status);
d[1]=ucal_getMillis(cal, &status);
ucal_setDateTime(cal, 1861, UCAL_DECEMBER, 26, 17, 40, 30, &status);
d[2]=ucal_getMillis(cal, &status);
ucal_setDateTime(cal, 1999, UCAL_DECEMBER, 27, 17, 40, 30, &status);
d[3]=ucal_getMillis(cal, &status);
u_uastrcpy(pat, "yyMMdd");
def = udat_open(UDAT_IGNORE,UDAT_IGNORE,NULL, NULL, 0, pat, u_strlen(pat), &status);
if(U_FAILURE(status))
{
log_err_status(status, "FAIL: error in creating the dateformat using u_openPattern(): %s\n", myErrorName(status));
return;
}
start = 1800;
udat_set2DigitYearStart(def, start, &status);
if(U_FAILURE(status))
log_err("ERROR: in setTwoDigitStartDate: %s\n", myErrorName(status));
if( (udat_get2DigitYearStart(def, &status) != start))
log_err("ERROR: get2DigitYearStart broken\n");
for(i = 0; i < 4; ++i) {
u_uastrcpy(s, strings[i]);
exp = d[i];
got = udat_parse(def, s, u_strlen(s), 0, &status);
gotdate=myFormatit(def, got);
expdate=myFormatit(def, exp);
if (gotdate == NULL || expdate == NULL) {
log_err("myFormatit failed!\n");
}
else if(u_strcmp(gotdate, expdate) !=0) {
log_err("set2DigitYearStart broken for %s \n got: %s, expected: %s\n", austrdup(s),
austrdup(gotdate), austrdup(expdate) );
}
}
udat_close(def);
ucal_close(cal);
}
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();*/
}
}
/*test u_formatMessage() with sample patterns */
static void TestSampleMessageFormat(void)
{
UChar *str;
UChar *result;
UChar pattern[100], expected[100];
int32_t resultLengthOut, resultlength;
UDate d = 837039928046.0;
UErrorCode status = U_ZERO_ERROR;
ctest_setTimeZone(NULL, &status);
str=(UChar*)malloc(sizeof(UChar) * 15);
u_uastrcpy(str, "abc");
u_uastrcpy(pattern, "There are {0} files on {1,date}");
u_uastrcpy(expected, "There are abc files on Jul 10, 1996");
result=(UChar*)malloc(sizeof(UChar) * 1);
log_verbose("\nTesting a sample for Message format test#1\n");
resultlength=1;
resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, str, d);
if(status==U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
resultlength=resultLengthOut+1;
result=(UChar*)realloc(result, sizeof(UChar) * resultlength);
u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, str, d);
}
if(U_FAILURE(status)){
log_data_err("Error: failure in message format on test#1: %s (Are you missing data?)\n", myErrorName(status));
}
else if(u_strcmp(result, expected)==0)
log_verbose("PASS: MessagFormat successful on test#1\n");
else{
log_err("FAIL: Error in MessageFormat on test#1 \n GOT: %s EXPECTED: %s\n",
austrdup(result), austrdup(expected) );
}
log_verbose("\nTesting message format with another pattern test#2\n");
u_uastrcpy(pattern, "The disk \"{0}\" contains {1,number,integer} file(s)");
u_uastrcpy(expected, "The disk \"MyDisk\" contains 23 file(s)");
u_uastrcpy(str, "MyDisk");
resultLengthOut=u_formatMessage( "en_US",
pattern,
u_strlen(pattern),
result,
resultlength,
&status,
str,
235);
if(status==U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
resultlength=resultLengthOut+1;
result=(UChar*)realloc(result, sizeof(UChar) * (resultlength+1));
u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, str, 23);
}
if(U_FAILURE(status)){
log_data_err("Error: failure in message format on test#2 : %s (Are you missing data?)\n", myErrorName(status));
}
else if(u_strcmp(result, expected)==0)
log_verbose("PASS: MessagFormat successful on test#2\n");
else{
log_err("FAIL: Error in MessageFormat on test#2\n GOT: %s EXPECTED: %s\n",
austrdup(result), austrdup(expected) );
}
log_verbose("\nTesting message format with another pattern test#3\n");
u_uastrcpy(pattern, "You made a {0} of {1,number,currency}");
u_uastrcpy(expected, "You made a deposit of $500.00");
u_uastrcpy(str, "deposit");
resultlength=0;
resultLengthOut=u_formatMessage( "en_US", pattern, u_strlen(pattern), NULL, resultlength, &status, str, 500.00);
if(status==U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
resultlength=resultLengthOut+1;
result=(UChar*)realloc(result, sizeof(UChar) * resultlength);
u_formatMessage( "en_US", pattern, u_strlen(pattern), result, resultlength, &status, str, 500.00);
}
if(U_FAILURE(status)){
log_data_err("Error: failure in message format on test#3 : %s (Are you missing data?)\n", myErrorName(status));
}
else if(u_strcmp(result, expected)==0)
log_verbose("PASS: MessagFormat successful on test#3\n");
else{
log_err("FAIL: Error in MessageFormat on test#3\n GOT: %s EXPECTED %s\n", austrdup(result),
austrdup(expected) );
}
free(result);
free(str);
ctest_resetTimeZone();
}
