private void assertMinguoDate(
MinguoDate test, MinguoEra era, int year, MonthOfYear month, int day) throws Exception {
assertEquals(test.getEra(), era);
assertEquals(test.getYearOfEra(), year);
assertEquals(test.getMonthOfYear(), month);
assertEquals(test.getDayOfMonth(), day);
assertEquals(test.isLeapYear(), isLeapYear(era.getValue(), year));
}
@Test
public void testHashCode() throws Exception {
MinguoDate a = MinguoDate.of(1, MonthOfYear.JANUARY, 1);
MinguoDate b = MinguoDate.of(1, MonthOfYear.JANUARY, 1);
assertEquals(a.hashCode(), a.hashCode());
assertEquals(a.hashCode(), b.hashCode());
assertEquals(b.hashCode(), b.hashCode());
}
@Test
public void testEqualsNotEqualYear() throws Exception {
MinguoDate a = MinguoDate.of(testYear, testMonthOfYear, testDayOfMonth);
MinguoDate b = MinguoDate.of(testYear + 1, testMonthOfYear, testDayOfMonth);
assertEquals(a.equals(b), false);
assertEquals(b.equals(a), false);
assertEquals(a.equals(a), true);
assertEquals(b.equals(b), true);
}
@Test
public void testWithDayOfYearInvalidTooBig() throws Exception {
try {
testDate.withDayOfYear(367);
fail();
} catch (IllegalCalendarFieldValueException ex) {
assertEquals(ex.getRule(), MinguoChronology.dayOfYearRule());
}
}
@Test
public void testWithYearInvalidTooBig() throws Exception {
try {
testDate.withYear(testEra, 10000);
fail();
} catch (IllegalCalendarFieldValueException ex) {
assertEquals(ex.getRule(), MinguoChronology.yearOfEraRule());
}
}
@Test
public void testMinusWeeksOverflow() throws Exception {
try {
testDate.minusWeeks(Integer.MAX_VALUE);
fail();
} catch (IllegalCalendarFieldValueException ex) {
assertEquals(ex.getRule(), MinguoChronology.yearOfEraRule());
}
}
@Test
public void test_factory_of_3_invalidDay() throws Exception {
try {
MinguoDate.of(testYear, testMonthOfYear, 40); // Invalid day of month.
fail();
} catch (IllegalCalendarFieldValueException ex) {
assertEquals(ex.getRule(), MinguoChronology.dayOfMonthRule());
}
}
@Test
public void test_factory_of_3_invalidYear() throws Exception {
try {
MinguoDate.of(10000, testMonthOfYear, testDayOfMonth); // Invalid year.
fail();
} catch (IllegalCalendarFieldValueException ex) {
assertEquals(ex.getRule(), MinguoChronology.yearOfEraRule());
}
}
// -----------------------------------------------------------------------
// getDayOfWeek()
// -----------------------------------------------------------------------
@Test
public void testGetDayOfWeek() {
assertEquals(MinguoDate.of(testYear, testMonthOfYear, 2).getDayOfWeek(), DayOfWeek.MONDAY);
assertEquals(MinguoDate.of(testYear, testMonthOfYear, 3).getDayOfWeek(), DayOfWeek.TUESDAY);
assertEquals(MinguoDate.of(testYear, testMonthOfYear, 4).getDayOfWeek(), DayOfWeek.WEDNESDAY);
assertEquals(MinguoDate.of(testYear, testMonthOfYear, 5).getDayOfWeek(), DayOfWeek.THURSDAY);
assertEquals(MinguoDate.of(testYear, testMonthOfYear, 6).getDayOfWeek(), DayOfWeek.FRIDAY);
assertEquals(MinguoDate.of(testYear, testMonthOfYear, 7).getDayOfWeek(), DayOfWeek.SATURDAY);
assertEquals(MinguoDate.of(testYear, testMonthOfYear, 8).getDayOfWeek(), DayOfWeek.SUNDAY);
assertEquals(MinguoDate.of(testYear, testMonthOfYear, 9).getDayOfWeek(), DayOfWeek.MONDAY);
}
@Test(expectedExceptions = CalendricalException.class)
public void testPlusYearsInvalidTooBig() {
testDate.plusYears(9999);
}
@Test(expectedExceptions = NullPointerException.class)
public void testIsAfterObjectNull() throws Exception {
testDate.isAfter(null);
}
@Test(expectedExceptions = NullPointerException.class)
public void testCompareToObjectNull() throws Exception {
testDate.compareTo(null);
}
@BeforeTest
public void setUp() throws Exception {
testDate = MinguoDate.of(testEra, testYear, testMonthOfYear, testDayOfMonth);
}
// -----------------------------------------------------------------------
// withDayOfMonth()
// -----------------------------------------------------------------------
@Test
public void testWithDayOfMonth() {
MinguoDate date = testDate.withDayOfMonth(4);
assertEquals(date, MinguoDate.of(testYear, testMonthOfYear, 4));
}
// -----------------------------------------------------------------------
// withDayOfYear()
// -----------------------------------------------------------------------
@Test
public void testWithDayOfYear() {
MinguoDate date = testDate.withDayOfYear(15);
assertEquals(date, MinguoDate.of(testYear, MonthOfYear.JANUARY, 15));
}
// -----------------------------------------------------------------------
// minusWeeks()
// -----------------------------------------------------------------------
@Test
public void testMinusWeeks() {
assertEquals(
testDate.minusWeeks(2),
MinguoDate.of(testYear, testMonthOfYear.previous(), 28 + testDayOfMonth - (2 * 7)));
}
// -----------------------------------------------------------------------
// minusDays()
// -----------------------------------------------------------------------
@Test
public void testMinusDays() {
assertEquals(
testDate.minusDays(2), MinguoDate.of(testYear, testMonthOfYear, testDayOfMonth - 2));
}
// -----------------------------------------------------------------------
// minusMonths()
// -----------------------------------------------------------------------
@Test
public void testMinusMonths() {
assertEquals(
testDate.minusMonths(1),
MinguoDate.of(testYear, testMonthOfYear.previous(), testDayOfMonth));
}
@Test(expectedExceptions = CalendricalException.class)
public void testMinusYearsInvalidTooSmall() {
testDate.minusYears(20000);
}
// -----------------------------------------------------------------------
// minusYears()
// -----------------------------------------------------------------------
@Test
public void testMinusYears() {
assertEquals(
testDate.minusYears(10), MinguoDate.of(testYear - 10, testMonthOfYear, testDayOfMonth));
}
// -----------------------------------------------------------------------
// plusWeeks()
// -----------------------------------------------------------------------
@Test
public void testPlusWeeks() {
assertEquals(
testDate.plusWeeks(2), MinguoDate.of(testYear, testMonthOfYear, testDayOfMonth + (2 * 7)));
}
@Test
public void testEqualsItselfTrue() throws Exception {
assertEquals(testDate.equals(testDate), true);
}
@Test
public void testEqualsStringFalse() throws Exception {
assertEquals(testDate.equals("2009-07-15"), false);
}
// -----------------------------------------------------------------------
// toLocalDate()
// -----------------------------------------------------------------------
@Test
public void testToLocalDate() {
assertEquals(
MinguoDate.of(testYear, testMonthOfYear, testDayOfMonth).toLocalDate(),
LocalDate.of(testGregorianYear, testMonthOfYear, testDayOfMonth));
}
// -----------------------------------------------------------------------
// toString()
// -----------------------------------------------------------------------
@Test
public void testToString() {
String expected = "98-03-03 (Minguo)";
String actual = testDate.toString();
assertEquals(expected, actual);
}
// -----------------------------------------------------------------------
// compareTo(), isAfter(), isBefore(), and equals()
// -----------------------------------------------------------------------
@Test
public void testCompareTo() throws Exception {
doTestComparisons(
MinguoDate.of(1, MonthOfYear.JANUARY, 1),
MinguoDate.of(1, MonthOfYear.JANUARY, 2),
MinguoDate.of(1, MonthOfYear.JANUARY, 31),
MinguoDate.of(1, MonthOfYear.FEBRUARY, 1),
MinguoDate.of(1, MonthOfYear.FEBRUARY, 28),
MinguoDate.of(1, MonthOfYear.DECEMBER, 31),
MinguoDate.of(2, MonthOfYear.JANUARY, 1),
MinguoDate.of(2, MonthOfYear.DECEMBER, 31),
MinguoDate.of(3, MonthOfYear.JANUARY, 1),
MinguoDate.of(3, MonthOfYear.DECEMBER, 31),
MinguoDate.of(9999, MonthOfYear.JANUARY, 1),
MinguoDate.of(9999, MonthOfYear.DECEMBER, 31));
}
@Test
public void test_factory_of_4() throws Exception {
assertEquals(MinguoDate.of(testEra, testYear, testMonthOfYear, testDayOfMonth), testDate);
assertMinguoDate(testDate, testEra, testYear, testMonthOfYear, testDayOfMonth);
}
void doTestComparisons(MinguoDate... dates) {
for (int i = 0; i < dates.length; i++) {
MinguoDate a = dates[i];
for (int j = 0; j < dates.length; j++) {
MinguoDate b = dates[j];
if (i < j) {
assertTrue(a.compareTo(b) < 0, a + " <=> " + b);
assertEquals(a.isBefore(b), true, a + " <=> " + b);
assertEquals(a.isAfter(b), false, a + " <=> " + b);
assertEquals(a.equals(b), false, a + " <=> " + b);
} else if (i > j) {
assertTrue(a.compareTo(b) > 0, a + " <=> " + b);
assertEquals(a.isBefore(b), false, a + " <=> " + b);
assertEquals(a.isAfter(b), true, a + " <=> " + b);
assertEquals(a.equals(b), false, a + " <=> " + b);
} else {
assertEquals(a.compareTo(b), 0, a + " <=> " + b);
assertEquals(a.isBefore(b), false, a + " <=> " + b);
assertEquals(a.isAfter(b), false, a + " <=> " + b);
assertEquals(a.equals(b), true, a + " <=> " + b);
}
}
}
}
@Test(expectedExceptions = NullPointerException.class)
public void test_factory_of_3_invalidMonth() throws Exception {
MinguoDate.of(testYear, null, testDayOfMonth);
}
// -----------------------------------------------------------------------
// plusMonths()
// -----------------------------------------------------------------------
@Test
public void testPlusMonths() {
assertEquals(
testDate.plusMonths(5), MinguoDate.of(testYear, testMonthOfYear.roll(5), testDayOfMonth));
}
