public void TestInitWithCurrentTime()
{
// jb4555
// if the chinese calendar current millis isn't called, the default year
// is wrong.
// this test is assuming the 'year' is the current cycle
// so when we cross a cycle boundary, the target will need to change
// that shouldn't be for awhile yet...
ChineseCalendar cc = new ChineseCalendar();
cc.Set(IBM.ICU.Util.Calendar.YEAR, 22);
cc.Set(IBM.ICU.Util.Calendar.MONTH, 0);
// need to set leap month flag off, otherwise, the test case always
// fails when
// current time is in a leap month
cc.Set(IBM.ICU.Util.ChineseCalendar.IS_LEAP_MONTH, 0);
cc.Set(IBM.ICU.Util.Calendar.DATE, 19);
cc.Set(IBM.ICU.Util.Calendar.HOUR_OF_DAY, 0);
cc.Set(IBM.ICU.Util.Calendar.MINUTE, 0);
cc.Set(IBM.ICU.Util.Calendar.SECOND, 0);
cc.Set(IBM.ICU.Util.Calendar.MILLISECOND, 0);
cc.Add(IBM.ICU.Util.Calendar.DATE, 1);
DateTime target = new DateTime(105, IBM.ICU.Util.Calendar.FEBRUARY, 28);
DateTime result = cc.GetTime();
AssertEquals("chinese and gregorian date should match", target, result);
}
internal void DoRollAdd(bool roll, ChineseCalendar cal, int[][] tests)
{
String name = (roll) ? "rolling" : "adding";
for (int i = 0; i < tests.Length; i++)
{
int[] test = tests[i];
cal.Clear();
cal.Set(IBM.ICU.Util.Calendar.EXTENDED_YEAR, test[0]);
cal.Set(IBM.ICU.Util.Calendar.MONTH, test[1] - 1);
cal.Set(IBM.ICU.Util.ChineseCalendar.IS_LEAP_MONTH, test[2]);
cal.Set(IBM.ICU.Util.Calendar.DAY_OF_MONTH, test[3]);
if (roll)
{
cal.Roll(test[4], test[5]);
}
else
{
cal.Add(test[4], test[5]);
}
if (cal.Get(IBM.ICU.Util.Calendar.EXTENDED_YEAR) != test[6] ||
cal.Get(IBM.ICU.Charset.CalendarTest.MONTH) != (test[7] - 1) ||
cal.Get(IBM.ICU.Util.ChineseCalendar.IS_LEAP_MONTH) != test[8] ||
cal.Get(IBM.ICU.Charset.CalendarTest.DATE) != test[9])
{
Errln("Fail: " + name + " "
+ YmdToString(test[0], test[1] - 1, test[2], test[3])
+ " " + IBM.ICU.Charset.CalendarTest.FieldName(test[4]) + " by " + test[5]
+ ": expected "
+ YmdToString(test[6], test[7] - 1, test[8], test[9])
+ ", got " + IBM.ICU.Charset.CalendarTest.YmdToString(cal));
}
else if (IsVerbose())
{
Logln("OK: " + name + " "
+ YmdToString(test[0], test[1] - 1, test[2], test[3])
+ " " + IBM.ICU.Charset.CalendarTest.FieldName(test[4]) + " by " + test[5]
+ ": got " + IBM.ICU.Charset.CalendarTest.YmdToString(cal));
}
}
}
public void TestOutOfRange()
{
int[] DATA = new int[] {
// Input Output
4638, 13, 1, 4639, 1, 1, 4638, 18, 1, 4639, 6, 1, 4639, 0, 1,
4638, 12, 1, 4639, -6, 1, 4638, 6, 1, 4638, 1, 32, 4638, 2, 2, // 1-4638
// has
// 30
// days
4638, 2, -1, 4638, 1, 29,
};
ChineseCalendar cal = new ChineseCalendar();
for (int i = 0; i < DATA.Length;)
{
int y1 = DATA[i++];
int m1 = DATA[i++] - 1;
int d1 = DATA[i++];
int y2 = DATA[i++];
int m2 = DATA[i++] - 1;
int d2 = DATA[i++];
cal.Clear();
cal.Set(IBM.ICU.Util.Calendar.EXTENDED_YEAR, y1);
cal.Set(IBM.ICU.Charset.CalendarTest.MONTH, m1);
cal.Set(IBM.ICU.Charset.CalendarTest.DATE, d1);
int y = cal.Get(IBM.ICU.Util.Calendar.EXTENDED_YEAR);
int m = cal.Get(IBM.ICU.Charset.CalendarTest.MONTH);
int d = cal.Get(IBM.ICU.Charset.CalendarTest.DATE);
if (y != y2 || m != m2 || d != d2)
{
Errln("Fail: " + y1 + "/" + (m1 + 1) + "/" + d1
+ " resolves to " + y + "/" + (m + 1) + "/" + d
+ ", expected " + y2 + "/" + (m2 + 1) + "/" + d2);
}
else if (IsVerbose())
{
Logln("OK: " + y1 + "/" + (m1 + 1) + "/" + d1 + " resolves to "
+ y + "/" + (m + 1) + "/" + d);
}
}
}
public void TestMapping()
{
int[] DATA =
{
// (Note: months are 1-based)
// Gregorian Chinese
1964, 9, 4, 4601, 7, 0, 28, 1964, 9, 5, 4601, 7, 0, 29, 1964,
9, 6, 4601, 8, 0, 1, 1964, 9, 7, 4601, 8, 0, 2, 1961, 12, 25,
4598, 11, 0, 18, 1999, 6, 4, 4636, 4, 0, 21,
1990, 5, 23, 4627, 4, 0, 29, 1990, 5, 24, 4627, 5, 0, 1, 1990,
6, 22, 4627, 5, 0, 30, 1990, 6, 23, 4627, 5, 1, 1, 1990, 7, 20,
4627, 5, 1, 28, 1990, 7, 21, 4627, 5, 1, 29, 1990, 7, 22, 4627,
6, 0, 1,
};
ChineseCalendar cal = new ChineseCalendar();
StringBuilder buf = new StringBuilder();
Logln("Gregorian -> Chinese");
// java.util.Calendar grego = java.util.Calendar.getInstance();
IBM.ICU.Util.Calendar grego = IBM.ICU.Util.Calendar.GetInstance();
grego.Clear();
for (int i = 0; i < DATA.Length;)
{
grego.Set(DATA[i++], DATA[i++] - 1, DATA[i++]);
DateTime date = grego.GetTime();
cal.SetTime(date);
int y = cal.Get(IBM.ICU.Util.Calendar.EXTENDED_YEAR);
int m = cal.Get(IBM.ICU.Util.Calendar.MONTH) + 1; // 0-based -> 1-based
int L = cal.Get(IBM.ICU.Util.ChineseCalendar.IS_LEAP_MONTH);
int d = cal.Get(IBM.ICU.Util.Calendar.DAY_OF_MONTH);
int yE = DATA[i++]; // Expected y, m, isLeapMonth, d
int mE = DATA[i++]; // 1-based
int LE = DATA[i++];
int dE = DATA[i++];
buf.Length = 0;
buf.Append(date + " -> ");
buf.Append(y + "/" + m + ((L == 1) ? "(leap)" : "") + "/" + d);
if (y == yE && m == mE && L == LE && d == dE)
{
Logln("OK: " + buf.ToString());
}
else
{
Errln("Fail: " + buf.ToString() + ", expected " + yE + "/" + mE
+ ((LE == 1) ? "(leap)" : "") + "/" + dE);
}
}
Logln("Chinese -> Gregorian");
for (int i_0 = 0; i_0 < DATA.Length;)
{
grego.Set(DATA[i_0++], DATA[i_0++] - 1, DATA[i_0++]);
DateTime dexp = grego.GetTime();
int cyear = DATA[i_0++];
int cmonth = DATA[i_0++];
int cisleapmonth = DATA[i_0++];
int cdayofmonth = DATA[i_0++];
cal.Clear();
cal.Set(IBM.ICU.Util.Calendar.EXTENDED_YEAR, cyear);
cal.Set(IBM.ICU.Util.Calendar.MONTH, cmonth - 1);
cal.Set(IBM.ICU.Util.ChineseCalendar.IS_LEAP_MONTH, cisleapmonth);
cal.Set(IBM.ICU.Util.Calendar.DAY_OF_MONTH, cdayofmonth);
DateTime date_1 = cal.GetTime();
buf.Length = 0;
buf.Append(cyear + "/" + cmonth
+ ((cisleapmonth == 1) ? "(leap)" : "") + "/" + cdayofmonth);
buf.Append(" -> " + date_1);
if (date_1.Equals(dexp))
{
Logln("OK: " + buf.ToString());
}
else
{
Errln("Fail: " + buf.ToString() + ", expected " + dexp);
}
}
}
public void TestResolution()
{
ChineseCalendar cal = new ChineseCalendar();
DateFormat fmt = IBM.ICU.Text.DateFormat.GetDateInstance(cal, IBM.ICU.Text.DateFormat.DEFAULT);
// May 22 2001 = y4638 m4 d30 doy119
// May 23 2001 = y4638 m4* d1 doy120
int THE_YEAR = 4638;
int END = -1;
int[] DATA =
{
// Format:
// (field, value)+, END, exp.month, exp.isLeapMonth, exp.DOM
// Note: exp.month is ONE-BASED
IBM.ICU.Util.Calendar.DAY_OF_YEAR, 1, END,
1,
0,
1, // Expect 1-1
IBM.ICU.Util.ChineseCalendar.IS_LEAP_MONTH, 1, IBM.ICU.Util.Calendar.DAY_OF_MONTH, 1,
IBM.ICU.Util.Calendar.MONTH,
3,
END,
4,
1,
1, // Expect 4*-1
IBM.ICU.Util.Calendar.MONTH,
1, // Should ignore
IBM.ICU.Util.ChineseCalendar.IS_LEAP_MONTH,
1, // Should ignore
IBM.ICU.Util.Calendar.DAY_OF_MONTH,
1, // Should ignore
IBM.ICU.Util.Calendar.DAY_OF_YEAR,
121,
END,
4,
1,
2, // Expect 4*-2
// I've disabled this test because it doesn't work this way,
// not even with a GregorianCalendar! MONTH alone isn't enough
// to supersede DAY_OF_YEAR. Some other month-related field is
// also required. - Liu 11/28/00
// ! // If we set MONTH last, that should take precedence
// ! ChineseCalendar.IS_LEAP_MONTH, 1,
// ! Calendar.DAY_OF_MONTH, 1,
// ! Calendar.DAY_OF_YEAR, 5, // Should ignore
// ! Calendar.MONTH, 3,
// ! END,
// ! 4,1,1, // Expect 4*-1
IBM.ICU.Util.Calendar.MONTH, 3, IBM.ICU.Util.Calendar.DAY_OF_MONTH, 1,
IBM.ICU.Util.Calendar.DAY_OF_YEAR, 5, // Should ignore
IBM.ICU.Util.ChineseCalendar.IS_LEAP_MONTH, 1, END, 4,1, 1, // Expect 4*-1
};
StringBuilder buf = new StringBuilder();
for (int i = 0; i < DATA.Length;)
{
cal.Clear();
cal.Set(IBM.ICU.Util.Calendar.EXTENDED_YEAR, THE_YEAR);
buf.Length = 0;
buf.Append("EXTENDED_YEAR=" + THE_YEAR);
while (DATA[i] != END)
{
cal.Set(DATA[i++], DATA[i++]);
buf.Append(" " + IBM.ICU.Charset.CalendarTest.FieldName(DATA[i - 2]) + "=" + DATA[i - 1]);
}
++i; // Skip over END mark
int expMonth = DATA[i++] - 1;
int expIsLeapMonth = DATA[i++];
int expDOM = DATA[i++];
int month = cal.Get(IBM.ICU.Util.Calendar.MONTH);
int isLeapMonth = cal.Get(IBM.ICU.Util.ChineseCalendar.IS_LEAP_MONTH);
int dom = cal.Get(IBM.ICU.Util.Calendar.DAY_OF_MONTH);
if (expMonth == month && expIsLeapMonth == isLeapMonth &&
dom == expDOM)
{
Logln("OK: " + buf + " => " + fmt.Format(cal.GetTime()));
}
else
{
String s = fmt.Format(cal.GetTime());
cal.Clear();
cal.Set(IBM.ICU.Util.Calendar.EXTENDED_YEAR, THE_YEAR);
cal.Set(IBM.ICU.Util.Calendar.MONTH, expMonth);
cal.Set(IBM.ICU.Util.ChineseCalendar.IS_LEAP_MONTH, expIsLeapMonth);
cal.Set(IBM.ICU.Util.Calendar.DAY_OF_MONTH, expDOM);
Errln("Fail: " + buf + " => " + s + "=" + (month + 1) + ","
+ isLeapMonth + "," + dom + ", expected "
+ fmt.Format(cal.GetTime()) + "=" + (expMonth + 1)
+ "," + expIsLeapMonth + "," + expDOM);
}
}
}
