void Test_GEec(void)
{
UErrorCode status = U_ZERO_ERROR;
UDateFormat * dtfmt = udat_open(UDAT_LONG, UDAT_LONG, "en", zonePST, -1, NULL, 0, &status);
if ( U_SUCCESS(status) ) {
const DatePatternAndText *patTextPtr;
for (patTextPtr = datePatternsAndText; patTextPtr->pattern != NULL; ++patTextPtr) {
UChar dmyGnText[DATE_TEXT_MAX_CHARS];
char byteText[3*DATE_TEXT_MAX_CHARS];
int32_t dmyGnTextLen;
UDate dateResult;
udat_applyPattern(dtfmt, FALSE, patTextPtr->pattern, -1);
dmyGnTextLen = udat_format(dtfmt, july022008, dmyGnText, DATE_TEXT_MAX_CHARS, NULL, &status);
if ( U_FAILURE(status) ) {
log_err("FAIL: udat_format with %s: %s\n", patTextPtr->label, myErrorName(status) );
status = U_ZERO_ERROR;
} else if ( u_strcmp(dmyGnText, patTextPtr->text) != 0 ) {
log_err("FAIL: udat_format with %s: wrong UChar[] result %s\n", patTextPtr->label, u_austrcpy(byteText,dmyGnText) );
}
dateResult = udat_parse(dtfmt, patTextPtr->text, -1, NULL, &status); /* no time, dateResult != july022008 by some hours */
if ( U_FAILURE(status) ) {
log_err("FAIL: udat_parse with %s: %s\n", patTextPtr->label, myErrorName(status) );
status = U_ZERO_ERROR;
} else if ( patTextPtr->label[0] != '*' && july022008 - dateResult > dayMillisec ) {
log_err("FAIL: udat_parse with %s: wrong UDate result\n", patTextPtr->label );
}
}
udat_close(dtfmt);
} else {
log_data_err("FAIL: udat_open fails: %s (Are you missing data?)\n", myErrorName(status));
}
}
/* Format the date */
static void
date(const UChar *tz,
UDateFormatStyle style,
char *format,
UErrorCode *status)
{
UChar *s = 0;
int32_t len = 0;
UDateFormat *fmt;
UChar uFormat[100];
fmt = udat_open(style, style, 0, tz, -1,NULL,0, status);
if ( format != NULL ) {
u_charsToUChars(format,uFormat,strlen(format)),
udat_applyPattern(fmt,FALSE,uFormat,strlen(format));
}
len = udat_format(fmt, ucal_getNow(), 0, len, 0, status);
if(*status == U_BUFFER_OVERFLOW_ERROR) {
*status = U_ZERO_ERROR;
s = (UChar*) malloc(sizeof(UChar) * (len+1));
if(s == 0) goto finish;
udat_format(fmt, ucal_getNow(), s, len + 1, 0, status);
if(U_FAILURE(*status)) goto finish;
}
/* print the date string */
uprint(s, stdout, status);
/* print a trailing newline */
printf("\n");
finish:
udat_close(fmt);
free(s);
}
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);
}
/** call-seq:
* calendar.format(pattern = nil , locale = nil)
*
* Formats this calendar time using given pattern and locale. Returns UString or nil on failure.
* Valid value types for pattern are:
* nil - long format for date and time
* UString - specification of format, as defined in docs/FORMATTING
* Symbol - one of :short, :medium, :long, :full, :none , sets format for both date and time
* Hash - {:time => aSymbol, :date => aSymbol} - sets separate formats for date and time, valid symbols see above
*/
VALUE icu4r_cal_format(int argc, VALUE * argv, VALUE obj)
{
UErrorCode status = U_ZERO_ERROR;
UDateFormat * format;
UDate time_to_format;
UChar * buf = NULL, * pattern = NULL;
long capa = 0, pattern_len = 0;
char *locale = NULL;
VALUE loc, pat, ret = Qnil;
int n , def_d_format = UDAT_FULL, def_t_format = UDAT_FULL;
n = rb_scan_args(argc, argv, "02", &pat, &loc);
if( n == 2) {
Check_Type(loc, T_STRING);
locale = RSTRING_PTR(loc);
}
if (n >= 1 && pat != Qnil) {
switch(TYPE(pat)) {
case T_SYMBOL:
def_d_format = def_t_format = icu4r_get_cal_format_int(pat);
break;
case T_HASH:
def_d_format = icu4r_get_cal_format_int(rb_hash_aref(pat, ID2SYM(rb_intern("date"))));
def_t_format = icu4r_get_cal_format_int(rb_hash_aref(pat, ID2SYM(rb_intern("time"))));
break;
default:
Check_Class(pat, rb_cUString);
pattern = ICU_PTR(pat);
pattern_len = ICU_LEN(pat);
break;
}
}
format = udat_open(def_t_format, def_d_format, locale, NULL, 0, NULL, 0, &status);
if( pattern ) {
udat_applyPattern(format, 0, pattern, pattern_len);
}
ICU_RAISE(status);
udat_setCalendar(format, UCALENDAR(obj));
time_to_format = ucal_getMillis(UCALENDAR(obj), &status);
capa = udat_format(format, time_to_format, buf, capa, NULL, &status);
if( U_BUFFER_OVERFLOW_ERROR == status) {
buf = ALLOC_N(UChar, capa+1);
status = U_ZERO_ERROR;
capa = udat_format(format, time_to_format, buf, capa, NULL, &status);
ret = icu_ustr_new_set(buf, capa, capa+1);
}
udat_close(format);
ICU_RAISE(status);
return ret;
}
static bool HHVM_METHOD(IntlDateFormatter, setPattern,
const String& pattern) {
DATFMT_GET(data, this_, false);
UErrorCode error = U_ZERO_ERROR;
String pat(u16(pattern, error));
if (U_FAILURE(error)) {
data->setError(error, "Error converting pattern to UTF-16");
return false;
}
udat_applyPattern(data->datefmt(), (UBool)false,
(UChar*)pat.c_str(), pat.size() / sizeof(UChar));
return true;
}
static bool HHVM_METHOD(IntlDateFormatter, setPattern,
const String& pattern) {
DATFMT_GET(data, this_, false);
UErrorCode error = U_ZERO_ERROR;
icu::UnicodeString pat(u16(pattern, error));
if (U_FAILURE(error)) {
data->setError(error, "Error converting pattern to UTF-16");
return false;
}
udat_applyPattern(data->datefmt(), (UBool)false,
pat.getBuffer(), pat.length());
return true;
}
/*Testing udat_getSymbols() and udat_setSymbols() and udat_countSymbols()*/
static void TestSymbols()
{
UDateFormat *def, *fr;
UErrorCode status = U_ZERO_ERROR;
UChar *value=NULL;
UChar *result = NULL;
int32_t resultlength;
int32_t resultlengthout;
UChar *pattern;
/*creating a dateformat with french locale */
log_verbose("\ncreating a date format with french locale\n");
fr = udat_open(UDAT_FULL, UDAT_DEFAULT, "fr_FR", NULL, 0, NULL, 0, &status);
if(U_FAILURE(status))
{
log_data_err("error in creating the dateformat using full time style with french locale -> %s (Are you missing data?)\n",
myErrorName(status) );
return;
}
/*creating a default dateformat */
log_verbose("\ncreating a date format with default locale\n");
/* 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" */
/* def = udat_open(UDAT_DEFAULT,UDAT_DEFAULT ,NULL, NULL, 0, &status); */
def = udat_open(UDAT_DEFAULT,UDAT_DEFAULT ,"en_US", NULL, 0, NULL, 0, &status);
if(U_FAILURE(status))
{
log_err("error in creating the dateformat using short date and time style\n %s\n",
myErrorName(status) );
return;
}
/*Testing countSymbols, getSymbols and setSymbols*/
log_verbose("\nTesting countSymbols\n");
/*since the month names has the last string empty and week names are 1 based 1.e first string in the weeknames array is empty */
if(udat_countSymbols(def, UDAT_ERAS)!=2 || udat_countSymbols(def, UDAT_MONTHS)!=12 ||
udat_countSymbols(def, UDAT_SHORT_MONTHS)!=12 || udat_countSymbols(def, UDAT_WEEKDAYS)!=8 ||
udat_countSymbols(def, UDAT_SHORT_WEEKDAYS)!=8 || udat_countSymbols(def, UDAT_AM_PMS)!=2 ||
udat_countSymbols(def, UDAT_QUARTERS) != 4 || udat_countSymbols(def, UDAT_SHORT_QUARTERS) != 4 ||
udat_countSymbols(def, UDAT_LOCALIZED_CHARS)!=1)
{
log_err("FAIL: error in udat_countSymbols\n");
}
else
log_verbose("PASS: udat_countSymbols() successful\n");
/*testing getSymbols*/
log_verbose("\nTesting getSymbols\n");
pattern=(UChar*)malloc(sizeof(UChar) * 10);
u_uastrcpy(pattern, "jeudi");
resultlength=0;
resultlengthout=udat_getSymbols(fr, UDAT_WEEKDAYS, 5 , NULL, resultlength, &status);
if(status==U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
resultlength=resultlengthout+1;
if(result != NULL) {
free(result);
result = NULL;
}
result=(UChar*)malloc(sizeof(UChar) * resultlength);
udat_getSymbols(fr, UDAT_WEEKDAYS, 5, result, resultlength, &status);
}
if(U_FAILURE(status))
{
log_err("FAIL: Error in udat_getSymbols().... %s\n", myErrorName(status) );
}
else
log_verbose("PASS: getSymbols succesful\n");
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");
/*run series of tests to test getsymbols regressively*/
log_verbose("\nTesting getSymbols() regressively\n");
VerifygetSymbols(fr, UDAT_WEEKDAYS, 1, "dimanche");
VerifygetSymbols(def, UDAT_WEEKDAYS, 1, "Sunday");
VerifygetSymbols(fr, UDAT_SHORT_WEEKDAYS, 7, "sam.");
VerifygetSymbols(def, UDAT_SHORT_WEEKDAYS, 7, "Sat");
VerifygetSymbols(def, UDAT_MONTHS, 11, "December");
VerifygetSymbols(def, UDAT_MONTHS, 0, "January");
VerifygetSymbols(fr, UDAT_ERAS, 0, "av. J.-C.");
VerifygetSymbols(def, UDAT_AM_PMS, 0, "AM");
VerifygetSymbols(def, UDAT_AM_PMS, 1, "PM");
VerifygetSymbols(fr, UDAT_SHORT_MONTHS, 0, "janv.");
VerifygetSymbols(def, UDAT_SHORT_MONTHS, 11, "Dec");
VerifygetSymbols(fr, UDAT_QUARTERS, 0, "1er trimestre");
VerifygetSymbols(def, UDAT_QUARTERS, 3, "4th quarter");
VerifygetSymbols(fr, UDAT_SHORT_QUARTERS, 1, "T2");
VerifygetSymbols(def, UDAT_SHORT_QUARTERS, 2, "Q3");
VerifygetSymbols(def,UDAT_LOCALIZED_CHARS, 0, "GyMdkHmsSEDFwWahKzYeugAZvcLQqV");
if(result != NULL) {
free(result);
result = NULL;
}
free(pattern);
log_verbose("\nTesting setSymbols\n");
/*applying the pattern so that setSymbolss works */
resultlength=0;
resultlengthout=udat_toPattern(fr, FALSE, NULL, resultlength, &status);
if(status==U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
resultlength=resultlengthout + 1;
pattern=(UChar*)malloc(sizeof(UChar) * resultlength);
udat_toPattern(fr, FALSE, pattern, resultlength, &status);
}
if(U_FAILURE(status))
{
log_err("FAIL: error in extracting the pattern from UNumberFormat\n %s\n",
myErrorName(status) );
}
udat_applyPattern(def, FALSE, pattern, u_strlen(pattern));
resultlength=0;
resultlengthout=udat_toPattern(def, FALSE, NULL, resultlength,&status);
if(status==U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
resultlength=resultlengthout + 1;
if(result != NULL) {
free(result);
result = NULL;
}
result=(UChar*)malloc(sizeof(UChar) * resultlength);
udat_toPattern(fr, FALSE,result, resultlength, &status);
}
if(U_FAILURE(status))
{
log_err("FAIL: error in extracting the pattern from UNumberFormat\n %s\n",
myErrorName(status) );
}
if(u_strcmp(result, pattern)==0)
log_verbose("Pattern applied properly\n");
else
log_err("pattern could not be applied properly\n");
free(pattern);
/*testing set symbols */
resultlength=0;
resultlengthout=udat_getSymbols(fr, UDAT_MONTHS, 11 , NULL, resultlength, &status);
if(status==U_BUFFER_OVERFLOW_ERROR){
status=U_ZERO_ERROR;
resultlength=resultlengthout+1;
if(result != NULL) {
free(result);
result = NULL;
}
result=(UChar*)malloc(sizeof(UChar) * resultlength);
udat_getSymbols(fr, UDAT_MONTHS, 11, result, resultlength, &status);
}
if(U_FAILURE(status))
log_err("FAIL: error in getSymbols() %s\n", myErrorName(status) );
resultlength=resultlengthout+1;
udat_setSymbols(def, UDAT_MONTHS, 11, result, resultlength, &status);
if(U_FAILURE(status))
{
log_err("FAIL: Error in udat_setSymbols() : %s\n", myErrorName(status) );
}
else
log_verbose("PASS: SetSymbols successful\n");
resultlength=0;
resultlengthout=udat_getSymbols(def, UDAT_MONTHS, 11, NULL, resultlength, &status);
if(status==U_BUFFER_OVERFLOW_ERROR){
status=U_ZERO_ERROR;
resultlength=resultlengthout+1;
value=(UChar*)malloc(sizeof(UChar) * resultlength);
udat_getSymbols(def, UDAT_MONTHS, 11, value, resultlength, &status);
}
if(U_FAILURE(status))
log_err("FAIL: error in retrieving the value using getSymbols i.e roundtrip\n");
if(u_strcmp(result, value)!=0)
log_data_err("FAIL: Error in settting and getting symbols\n");
else
log_verbose("PASS: setSymbols successful\n");
/*run series of tests to test setSymbols regressively*/
log_verbose("\nTesting setSymbols regressively\n");
VerifysetSymbols(def, UDAT_ERAS, 0, "BeforeChrist");
VerifysetSymbols(def, UDAT_ERA_NAMES, 1, "AnnoDomini");
VerifysetSymbols(def, UDAT_WEEKDAYS, 1, "Sundayweek");
VerifysetSymbols(def, UDAT_SHORT_WEEKDAYS, 7, "Satweek");
VerifysetSymbols(def, UDAT_NARROW_WEEKDAYS, 4, "M");
VerifysetSymbols(def, UDAT_STANDALONE_WEEKDAYS, 1, "Sonntagweek");
VerifysetSymbols(def, UDAT_STANDALONE_SHORT_WEEKDAYS, 7, "Sams");
VerifysetSymbols(def, UDAT_STANDALONE_NARROW_WEEKDAYS, 4, "V");
VerifysetSymbols(fr, UDAT_MONTHS, 11, "december");
VerifysetSymbols(fr, UDAT_SHORT_MONTHS, 0, "Jan");
VerifysetSymbols(fr, UDAT_NARROW_MONTHS, 1, "R");
VerifysetSymbols(fr, UDAT_STANDALONE_MONTHS, 11, "dezember");
VerifysetSymbols(fr, UDAT_STANDALONE_SHORT_MONTHS, 7, "Aug");
VerifysetSymbols(fr, UDAT_STANDALONE_NARROW_MONTHS, 2, "M");
VerifysetSymbols(fr, UDAT_QUARTERS, 0, "1. Quart");
VerifysetSymbols(fr, UDAT_SHORT_QUARTERS, 1, "QQ2");
VerifysetSymbols(fr, UDAT_STANDALONE_QUARTERS, 2, "3rd Quar.");
VerifysetSymbols(fr, UDAT_STANDALONE_SHORT_QUARTERS, 3, "4QQ");
/*run series of tests to test get and setSymbols regressively*/
log_verbose("\nTesting get and set symbols regressively\n");
VerifygetsetSymbols(fr, def, UDAT_WEEKDAYS, 1);
VerifygetsetSymbols(fr, def, UDAT_WEEKDAYS, 7);
VerifygetsetSymbols(fr, def, UDAT_SHORT_WEEKDAYS, 1);
VerifygetsetSymbols(fr, def, UDAT_SHORT_WEEKDAYS, 7);
VerifygetsetSymbols(fr, def, UDAT_MONTHS, 0);
VerifygetsetSymbols(fr, def, UDAT_SHORT_MONTHS, 0);
VerifygetsetSymbols(fr, def, UDAT_ERAS,1);
VerifygetsetSymbols(fr, def, UDAT_LOCALIZED_CHARS, 0);
VerifygetsetSymbols(fr, def, UDAT_AM_PMS, 1);
/*closing*/
udat_close(fr);
udat_close(def);
if(result != NULL) {
free(result);
result = NULL;
}
free(value);
}
/* Testing the DateFormat API */
static void TestDateFormat()
{
UDateFormat *def, *fr, *it, *de, *def1, *fr_pat;
UDateFormat *any;
UDateFormat *copy;
UErrorCode status = U_ZERO_ERROR;
UChar* result = NULL;
const UCalendar *cal;
const UNumberFormat *numformat1, *numformat2;
UChar temp[50];
int32_t numlocales;
UDate d1;
int i;
int32_t resultlength;
int32_t resultlengthneeded;
int32_t parsepos;
UDate d = 837039928046.0;
double num = -10456.37;
/*const char* str="yyyy.MM.dd G 'at' hh:mm:ss z";
const char t[]="2/3/76 2:50 AM";*/
/*Testing udat_open() to open a dateformat */
ctest_setTimeZone(NULL, &status);
log_verbose("\nTesting udat_open() with various parameters\n");
fr = udat_open(UDAT_FULL, UDAT_DEFAULT, "fr_FR", NULL,0, NULL, 0,&status);
if(U_FAILURE(status))
{
log_data_err("FAIL: error in creating the dateformat using full time style with french locale -> %s (Are you missing data?)\n",
myErrorName(status) );
return;
}
/* 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" */
/* def = udat_open(UDAT_SHORT, UDAT_SHORT, NULL, NULL, 0, &status); */
def = udat_open(UDAT_SHORT, UDAT_SHORT, "en_US", NULL, 0,NULL, 0, &status);
if(U_FAILURE(status))
{
log_err("FAIL: error in creating the dateformat using short date and time style\n %s\n",
myErrorName(status) );
return;
}
it = udat_open(UDAT_DEFAULT, UDAT_MEDIUM, "it_IT", NULL, 0, NULL, 0,&status);
if(U_FAILURE(status))
{
log_err("FAIL: error in creating the dateformat using medium date style with italian locale\n %s\n",
myErrorName(status) );
return;
}
de = udat_open(UDAT_LONG, UDAT_LONG, "de_DE", NULL, 0, NULL, 0,&status);
if(U_FAILURE(status))
{
log_err("FAIL: error in creating the dateformat using long time and date styles with german locale\n %s\n",
myErrorName(status));
return;
}
/*creating a default dateformat */
def1 = udat_open(UDAT_SHORT, UDAT_SHORT, NULL, NULL, 0,NULL, 0, &status);
if(U_FAILURE(status))
{
log_err("FAIL: error in creating the dateformat using short date and time style\n %s\n",
myErrorName(status) );
return;
}
/*Testing udat_getAvailable() and udat_countAvailable()*/
log_verbose("\nTesting getAvailableLocales and countAvailable()\n");
numlocales=udat_countAvailable();
/* use something sensible w/o hardcoding the count */
if(numlocales < 0)
log_data_err("FAIL: error in countAvailable\n");
log_verbose("The number of locales for which date/time formatting patterns are available is %d\n", numlocales);
for(i=0;i<numlocales;i++) {
UErrorCode subStatus = U_ZERO_ERROR;
log_verbose("Testing open of %s\n", udat_getAvailable(i));
any = udat_open(UDAT_SHORT, UDAT_SHORT, udat_getAvailable(i), NULL ,0, NULL, 0, &subStatus);
if(U_FAILURE(subStatus)) {
log_data_err("FAIL: date format %s (getAvailable(%d)) is not instantiable: %s\n", udat_getAvailable(i), i, u_errorName(subStatus));
}
udat_close(any);
}
/*Testing udat_clone()*/
log_verbose("\nTesting the udat_clone() function of date format\n");
copy=udat_clone(def, &status);
if(U_FAILURE(status)){
log_err("Error in creating the clone using udat_clone: %s\n", myErrorName(status) );
}
/*if(def != copy)
log_err("Error in udat_clone");*/ /*how should i check for equality???? */
/*Testing udat_format()*/
log_verbose("\nTesting the udat_format() function of date format\n");
u_uastrcpy(temp, "7/10/96 4:05 PM");
/*format using def */
resultlength=0;
resultlengthneeded=udat_format(def, d, NULL, resultlength, NULL, &status);
if(status==U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
resultlength=resultlengthneeded+1;
if(result != NULL) {
free(result);
result = NULL;
}
result=(UChar*)malloc(sizeof(UChar) * resultlength);
udat_format(def, d, result, resultlength, NULL, &status);
}
if(U_FAILURE(status) || !result)
{
log_err("FAIL: Error in formatting using udat_format(.....) %s\n", myErrorName(status) );
return;
}
else
log_verbose("PASS: formatting successful\n");
if(u_strcmp(result, temp)==0)
log_verbose("PASS: Date Format for US locale successful using udat_format()\n");
else {
char xbuf[2048];
char gbuf[2048];
u_austrcpy(xbuf, temp);
u_austrcpy(gbuf, result);
log_err("FAIL: Date Format for US locale failed using udat_format() - expected %s got %s\n", xbuf, gbuf);
}
/*format using fr */
u_unescape("10 juil. 1996 16:05:28 heure avanc\\u00E9e du Pacifique", temp, 50);
if(result != NULL) {
free(result);
result = NULL;
}
result=myDateFormat(fr, d);
if(u_strcmp(result, temp)==0)
log_verbose("PASS: Date Format for french locale successful using udat_format()\n");
else
log_data_err("FAIL: Date Format for french locale failed using udat_format().\n" );
/*format using it */
u_uastrcpy(temp, "10/lug/1996 16:05:28");
{
UChar *fmtted;
char g[100];
char x[100];
fmtted = myDateFormat(it,d);
u_austrcpy(g, fmtted);
u_austrcpy(x, temp);
if(u_strcmp(fmtted, temp)==0) {
log_verbose("PASS: Date Format for italian locale successful uisng udat_format() - wanted %s, got %s\n", x, g);
} else {
log_data_err("FAIL: Date Format for italian locale failed using udat_format() - wanted %s, got %s\n", x, g);
}
}
/*Testing parsing using udat_parse()*/
log_verbose("\nTesting parsing using udat_parse()\n");
u_uastrcpy(temp,"2/3/76 2:50 AM");
parsepos=0;
status=U_ZERO_ERROR;
d1=udat_parse(def, temp, u_strlen(temp), &parsepos, &status);
if(U_FAILURE(status))
{
log_err("FAIL: Error in parsing using udat_parse(.....) %s\n", myErrorName(status) );
}
else
log_verbose("PASS: parsing succesful\n");
/*format it back and check for equality */
if(u_strcmp(myDateFormat(def, d1),temp)!=0)
log_err("FAIL: error in parsing\n");
/*Testing parsing using udat_parse()*/
log_verbose("\nTesting parsing using udat_parse()\n");
u_uastrcpy(temp,"2/Don't parse this part");
status=U_ZERO_ERROR;
d1=udat_parse(def, temp, u_strlen(temp), NULL, &status);
if(status != U_PARSE_ERROR)
{
log_err("FAIL: udat_parse(\"bad string\") passed when it should have failed\n");
}
else
log_verbose("PASS: parsing succesful\n");
/*Testing udat_openPattern() */
status=U_ZERO_ERROR;
log_verbose("\nTesting the udat_openPattern with a specified pattern\n");
/*for french locale */
fr_pat=udat_open(UDAT_IGNORE, UDAT_IGNORE,"fr_FR",NULL,0,temp, u_strlen(temp), &status);
if(U_FAILURE(status))
{
log_err("FAIL: Error in creating a date format using udat_openPattern \n %s\n",
myErrorName(status) );
}
else
log_verbose("PASS: creating dateformat using udat_openPattern() succesful\n");
/*Testing applyPattern and toPattern */
log_verbose("\nTesting applyPattern and toPattern()\n");
udat_applyPattern(def1, FALSE, temp, u_strlen(temp));
log_verbose("Extracting the pattern\n");
resultlength=0;
resultlengthneeded=udat_toPattern(def1, FALSE, NULL, resultlength, &status);
if(status==U_BUFFER_OVERFLOW_ERROR)
{
status=U_ZERO_ERROR;
resultlength=resultlengthneeded + 1;
result=(UChar*)malloc(sizeof(UChar) * resultlength);
udat_toPattern(def1, FALSE, result, resultlength, &status);
}
if(U_FAILURE(status))
{
log_err("FAIL: error in extracting the pattern from UNumberFormat\n %s\n",
myErrorName(status) );
}
if(u_strcmp(result, temp)!=0)
log_err("FAIL: Error in extracting the pattern\n");
else
log_verbose("PASS: applyPattern and toPattern work fine\n");
if(result != NULL) {
free(result);
result = NULL;
}
/*Testing getter and setter functions*/
/*isLenient and setLenient()*/
log_verbose("\nTesting the isLenient and setLenient properties\n");
udat_setLenient(fr, udat_isLenient(it));
if(udat_isLenient(fr) != udat_isLenient(it))
log_err("ERROR: setLenient() failed\n");
else
log_verbose("PASS: setLenient() successful\n");
/*Test get2DigitYearStart set2DigitYearStart */
log_verbose("\nTesting the get and set 2DigitYearStart properties\n");
d1= udat_get2DigitYearStart(fr_pat,&status);
if(U_FAILURE(status)) {
log_err("ERROR: udat_get2DigitYearStart failed %s\n", myErrorName(status) );
}
status = U_ZERO_ERROR;
udat_set2DigitYearStart(def1 ,d1, &status);
if(U_FAILURE(status)) {
log_err("ERROR: udat_set2DigitYearStart failed %s\n", myErrorName(status) );
}
if(udat_get2DigitYearStart(fr_pat, &status) != udat_get2DigitYearStart(def1, &status))
log_err("FAIL: error in set2DigitYearStart\n");
else
log_verbose("PASS: set2DigitYearStart successful\n");
/*try setting it to another value */
udat_set2DigitYearStart(de, 2000.0, &status);
if(U_FAILURE(status)){
log_verbose("ERROR: udat_set2DigitYearStart failed %s\n", myErrorName(status) );
}
if(udat_get2DigitYearStart(de, &status) != 2000)
log_err("FAIL: error in set2DigitYearStart\n");
else
log_verbose("PASS: set2DigitYearStart successful\n");
/*Test getNumberFormat() and setNumberFormat() */
log_verbose("\nTesting the get and set NumberFormat properties of date format\n");
numformat1=udat_getNumberFormat(fr_pat);
udat_setNumberFormat(def1, numformat1);
numformat2=udat_getNumberFormat(def1);
if(u_strcmp(myNumformat(numformat1, num), myNumformat(numformat2, num)) !=0)
log_err("FAIL: error in setNumberFormat or getNumberFormat()\n");
else
log_verbose("PASS:setNumberFormat and getNumberFormat succesful\n");
/*try setting the number format to another format */
numformat1=udat_getNumberFormat(def);
udat_setNumberFormat(def1, numformat1);
numformat2=udat_getNumberFormat(def1);
if(u_strcmp(myNumformat(numformat1, num), myNumformat(numformat2, num)) !=0)
log_err("FAIL: error in setNumberFormat or getNumberFormat()\n");
else
log_verbose("PASS: setNumberFormat and getNumberFormat succesful\n");
/*Test getCalendar and setCalendar*/
log_verbose("\nTesting the udat_getCalendar() and udat_setCalendar() properties\n");
cal=udat_getCalendar(fr_pat);
udat_setCalendar(def1, cal);
if(!ucal_equivalentTo(udat_getCalendar(fr_pat), udat_getCalendar(def1)))
log_err("FAIL: Error in setting and getting the calendar\n");
else
log_verbose("PASS: getting and setting calendar successful\n");
if(result!=NULL) {
free(result);
}
/*Closing the UDateForamt */
udat_close(def);
udat_close(fr);
udat_close(it);
udat_close(de);
udat_close(def1);
udat_close(fr_pat);
udat_close(copy);
ctest_resetTimeZone();
}
static void TestRelativeCrash(void) {
static const UChar tzName[] = { 0x0055, 0x0053, 0x002F, 0x0050, 0x0061, 0x0063, 0x0069, 0x0066, 0x0069, 0x0063, 0 };
static const UDate aDate = -631152000000.0;
UErrorCode status = U_ZERO_ERROR;
UErrorCode expectStatus = U_ILLEGAL_ARGUMENT_ERROR;
UDateFormat icudf;
icudf = udat_open(UDAT_NONE, UDAT_SHORT_RELATIVE, "en", tzName, -1, NULL, 0, &status);
if ( U_SUCCESS(status) ) {
const char *what = "???";
{
UErrorCode subStatus = U_ZERO_ERROR;
what = "udat_set2DigitYearStart";
log_verbose("Trying %s on a relative date..\n", what);
udat_set2DigitYearStart(icudf, aDate, &subStatus);
if(subStatus == expectStatus) {
log_verbose("Success: did not crash on %s, but got %s.\n", what, u_errorName(subStatus));
} else {
log_err("FAIL: didn't crash on %s, but got success %s instead of %s. \n", what, u_errorName(subStatus), u_errorName(expectStatus));
}
}
{
/* clone works polymorphically. try it anyways */
UErrorCode subStatus = U_ZERO_ERROR;
UDateFormat *oth;
what = "clone";
log_verbose("Trying %s on a relative date..\n", what);
oth = udat_clone(icudf, &subStatus);
if(subStatus == U_ZERO_ERROR) {
log_verbose("Success: did not crash on %s, but got %s.\n", what, u_errorName(subStatus));
udat_close(oth); /* ? */
} else {
log_err("FAIL: didn't crash on %s, but got %s instead of %s. \n", what, u_errorName(subStatus), u_errorName(expectStatus));
}
}
{
UErrorCode subStatus = U_ZERO_ERROR;
what = "udat_get2DigitYearStart";
log_verbose("Trying %s on a relative date..\n", what);
udat_get2DigitYearStart(icudf, &subStatus);
if(subStatus == expectStatus) {
log_verbose("Success: did not crash on %s, but got %s.\n", what, u_errorName(subStatus));
} else {
log_err("FAIL: didn't crash on %s, but got success %s instead of %s. \n", what, u_errorName(subStatus), u_errorName(expectStatus));
}
}
{
/* Now udat_toPattern works for relative date formatters, unless localized is TRUE */
UErrorCode subStatus = U_ZERO_ERROR;
what = "udat_toPattern";
log_verbose("Trying %s on a relative date..\n", what);
udat_toPattern(icudf, TRUE,NULL,0, &subStatus);
if(subStatus == expectStatus) {
log_verbose("Success: did not crash on %s, but got %s.\n", what, u_errorName(subStatus));
} else {
log_err("FAIL: didn't crash on %s, but got success %s instead of %s. \n", what, u_errorName(subStatus), u_errorName(expectStatus));
}
}
{
UErrorCode subStatus = U_ZERO_ERROR;
what = "udat_applyPattern";
log_verbose("Trying %s on a relative date..\n", what);
udat_applyPattern(icudf, FALSE,tzName,-1);
subStatus = U_ILLEGAL_ARGUMENT_ERROR; /* what it should be, if this took an errorcode. */
if(subStatus == expectStatus) {
log_verbose("Success: did not crash on %s, but got %s.\n", what, u_errorName(subStatus));
} else {
log_err("FAIL: didn't crash on %s, but got success %s instead of %s. \n", what, u_errorName(subStatus), u_errorName(expectStatus));
}
}
{
UErrorCode subStatus = U_ZERO_ERROR;
what = "udat_getSymbols";
log_verbose("Trying %s on a relative date..\n", what);
udat_getSymbols(icudf, UDAT_ERAS,0,NULL,0, &subStatus); /* bogus values */
if(subStatus == expectStatus) {
log_verbose("Success: did not crash on %s, but got %s.\n", what, u_errorName(subStatus));
} else {
log_err("FAIL: didn't crash on %s, but got success %s instead of %s. \n", what, u_errorName(subStatus), u_errorName(expectStatus));
}
}
{
UErrorCode subStatus = U_ZERO_ERROR;
what = "udat_countSymbols";
log_verbose("Trying %s on a relative date..\n", what);
udat_countSymbols(icudf, UDAT_ERAS);
subStatus = U_ILLEGAL_ARGUMENT_ERROR; /* should have an errorcode. */
if(subStatus == expectStatus) {
log_verbose("Success: did not crash on %s, but got %s.\n", what, u_errorName(subStatus));
} else {
log_err("FAIL: didn't crash on %s, but got success %s instead of %s. \n", what, u_errorName(subStatus), u_errorName(expectStatus));
}
}
udat_close(icudf);
} else {
log_data_err("FAIL: err calling udat_open() ->%s (Are you missing data?)\n", u_errorName(status));
}
}
/**
* @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 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);
}
