ERL_NIF_TERM date_get3(ErlNifEnv* env, int argc,
const ERL_NIF_TERM argv[])
{
UErrorCode status = U_ZERO_ERROR;
UCalendar* cal;
cloner* ptr;
int32_t year, month, day;
if(!((argc == 4)
&& enif_get_resource(env, argv[0], calendar_type, (void**) &ptr)
&& enif_get_int(env, argv[1], &year)
&& enif_get_int(env, argv[2], &month)
&& enif_get_int(env, argv[3], &day))) {
return enif_make_badarg(env);
}
month--;
cal = (UCalendar*) cloner_get(ptr);
CHECK_RES(env, cal);
ucal_setDate(cal,
year,
month,
day,
&status);
CHECK(env, status);
return calendar_to_double(env, (const UCalendar*) cal);
}
/**
* call-seq:
* calendar.set_date(year, month, date)
*
* Set a UCalendar's current date.
*/
VALUE icu4r_cal_set_date(VALUE obj,VALUE year, VALUE mon, VALUE date)
{
UErrorCode status = U_ZERO_ERROR;
Check_Type(year, T_FIXNUM);
Check_Type(mon, T_FIXNUM);
Check_Type(date, T_FIXNUM);
ucal_setDate(UCALENDAR(obj), FIX2INT(year), FIX2INT(mon), FIX2INT(date), &status);
ICU_RAISE(status);
return Qnil;
}
/*
* ICU's Universal Time Scale is designed to be tick-for-tick compatible with
* .Net System.DateTime. Verify that this is so for the
* .Net-supported date range (years 1-9999 AD).
* This requires a proleptic Gregorian calendar because that's what .Net uses.
* Proleptic: No Julian/Gregorian switchover, or a switchover before
* any date that we test, that is, before 0001 AD.
*/
static void
TestDotNet() {
static const UChar utc[] = { 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0 }; /* "Etc/GMT" */
const int32_t dayMillis = 86400 * INT64_C(1000); /* 1 day = 86400 seconds */
const int64_t dayTicks = 86400 * INT64_C(10000000);
const DotNetDateTimeTicks *dt;
UCalendar *cal;
UErrorCode errorCode;
UDate icuDate;
int64_t ticks, millis;
int32_t i;
/* Open a proleptic Gregorian calendar. */
errorCode = U_ZERO_ERROR;
cal = ucal_open(utc, -1, "", UCAL_GREGORIAN, &errorCode);
ucal_setGregorianChange(cal, -1000000 * (dayMillis * (UDate)1), &errorCode);
if(U_FAILURE(errorCode)) {
log_err("ucal_open(UTC/proleptic Gregorian) failed: %s\n", u_errorName(errorCode));
ucal_close(cal);
return;
}
for(i = 0; i < LENGTHOF(dotNetDateTimeTicks); ++i) {
/* Test conversion from .Net/Universal time to ICU time. */
dt = dotNetDateTimeTicks + i;
millis = utmscale_toInt64(dt->ticks, UDTS_ICU4C_TIME, &errorCode);
ucal_clear(cal);
ucal_setDate(cal, dt->year, dt->month - 1, dt->day, &errorCode); /* Java & ICU use January = month 0. */
icuDate = ucal_getMillis(cal, &errorCode);
if(millis != icuDate) {
/* Print days not millis to stay within printf() range. */
log_err("utmscale_toInt64(ticks[%d], ICU4C)=%dd != %dd=ucal_getMillis(%04d-%02d-%02d)\n",
(int)i, (int)(millis/dayMillis), (int)(icuDate/dayMillis), (int)dt->year, (int)dt->month, (int)dt->day);
}
/* Test conversion from ICU time to .Net/Universal time. */
ticks = utmscale_fromInt64((int64_t)icuDate, UDTS_ICU4C_TIME, &errorCode);
if(ticks != dt->ticks) {
/* Print days not ticks to stay within printf() range. */
log_err("utmscale_fromInt64(date[%d], ICU4C)=%dd != %dd=.Net System.DateTime(%04d-%02d-%02d).Ticks\n",
(int)i, (int)(ticks/dayTicks), (int)(dt->ticks/dayTicks), (int)dt->year, (int)dt->month, (int)dt->day);
}
}
ucal_close(cal);
}
void TestCzechMonths459()
{
int32_t lneed, pos;
UChar *pattern=NULL, *tzID=NULL;
UChar *juneStr, *julyStr;
UDateFormat *fmt;
UCalendar *cal;
UDate june, july, d;
UErrorCode status = U_ZERO_ERROR;
UChar *date;
ctest_setTimeZone(NULL, &status);
fmt = udat_open(UDAT_FULL, UDAT_FULL, "cs", NULL, 0, NULL, 0, &status);
if(U_FAILURE(status)){
log_data_err("Error in constructing the date format -> %s (Are you missing data?)\n", u_errorName(status));
ctest_resetTimeZone();
return;
}
lneed=0;
lneed=udat_toPattern(fmt, TRUE, NULL, lneed, &status);
if(status==U_BUFFER_OVERFLOW_ERROR){
status=U_ZERO_ERROR;
pattern=(UChar*)malloc(sizeof(UChar) * (lneed+1) );
udat_toPattern(fmt, TRUE, pattern, lneed+1, &status);
}
if(U_FAILURE(status)){ log_err("Error in extracting the pattern\n"); }
tzID=(UChar*)malloc(sizeof(UChar) * 4);
u_uastrcpy(tzID, "GMT");
cal=ucal_open(tzID, u_strlen(tzID), "cs", UCAL_GREGORIAN, &status);
if(U_FAILURE(status)){ log_err("error in ucal_open caldef : %s\n", myErrorName(status)); }
ucal_setDate(cal, 1997, UCAL_JUNE, 15, &status);
june=ucal_getMillis(cal, &status);
ucal_setDate(cal, 1997, UCAL_JULY, 15, &status);
july=ucal_getMillis(cal, &status);
juneStr = myDateFormat(fmt, june);
julyStr = myDateFormat(fmt, july);
pos=0;
if(juneStr == NULL) {
log_data_err("Can't load juneStr. Quitting.\n");
return;
}
d = udat_parse(fmt, juneStr, u_strlen(juneStr), &pos, &status);
date = myDateFormat(fmt, d);
if(U_SUCCESS(status)){
UChar* out1 = myDateFormat(fmt, june);
UChar* out2 = myDateFormat(fmt, d);
if(u_strcmp(out1, out2) !=0)
log_err("Error in handling the czech month june\n");
else
log_verbose("Pass: Date = %s (czech month June)\n", aescstrdup(date, -1));
}else{
log_err("udat_parse failed. Error. %s\n",u_errorName(status));
}
pos=0;
d = udat_parse(fmt, julyStr, u_strlen(julyStr), &pos, &status);
date = myDateFormat(fmt, d);
if(u_strcmp(myDateFormat(fmt, july), myDateFormat(fmt, d) ) !=0)
log_err("Error in handling the czech month july\n");
else
log_verbose("Pass: Date = %s (czech month July)\n", aescstrdup(date, -1));
ctest_resetTimeZone();
udat_close(fmt);
ucal_close(cal);
free(pattern);
free(tzID);
}
