下面列出了怎么用java.time.chrono.Era的API类实例代码及写法，或者点击链接到github查看源代码。
@Test(dataProvider="prolepticYear")
public void test_prolepticYear(int eraValue, Era era, int yearOfEra, int expectedProlepticYear, boolean isLeapYear) {
Era eraObj = JapaneseChronology.INSTANCE.eraOf(eraValue);
assertTrue(JapaneseChronology.INSTANCE.eras().contains(eraObj));
assertEquals(eraObj, era);
assertEquals(JapaneseChronology.INSTANCE.prolepticYear(era, yearOfEra), expectedProlepticYear);
}
@Test(dataProvider="prolepticYear")
public void test_isLeapYear(int eraValue, Era era, int yearOfEra, int expectedProlepticYear, boolean isLeapYear) {
assertEquals(JapaneseChronology.INSTANCE.isLeapYear(expectedProlepticYear), isLeapYear);
assertEquals(JapaneseChronology.INSTANCE.isLeapYear(expectedProlepticYear), Year.of(expectedProlepticYear).isLeap());
JapaneseDate jdate = JapaneseDate.now();
jdate = jdate.with(ChronoField.YEAR, expectedProlepticYear).with(ChronoField.MONTH_OF_YEAR, 2);
if (isLeapYear) {
assertEquals(jdate.lengthOfMonth(), 29);
} else {
assertEquals(jdate.lengthOfMonth(), 28);
}
}
@Test(dataProvider="prolepticYear")
public void test_isLeapYear(int eraValue, Era era, int yearOfEra, int expectedProlepticYear, boolean isLeapYear) {
assertEquals(MinguoChronology.INSTANCE.isLeapYear(expectedProlepticYear), isLeapYear);
assertEquals(MinguoChronology.INSTANCE.isLeapYear(expectedProlepticYear), Year.of(expectedProlepticYear + YDIFF).isLeap());
MinguoDate minguo = MinguoDate.now();
minguo = minguo.with(ChronoField.YEAR, expectedProlepticYear).with(ChronoField.MONTH_OF_YEAR, 2);
if (isLeapYear) {
assertEquals(minguo.lengthOfMonth(), 29);
} else {
assertEquals(minguo.lengthOfMonth(), 28);
}
}
@Override
public int prolepticYear(Era era, int yearOfEra) {
if (era instanceof CopticEra == false) {
throw new ClassCastException("Era must be CopticEra");
}
return (era == CopticEra.AM ? yearOfEra : 1 - yearOfEra);
}
@Test(dataProvider = "era_epochSecond_dataProvider")
public void test_epochSecond(Chronology chrono, Era era, int y, int m, int d, int h, int min, int s, ZoneOffset offset) {
ChronoLocalDate chronoLd = chrono.date(era, y, m, d);
assertEquals(chrono.epochSecond(era, y, m, d, h, min, s, offset),
OffsetDateTime.of(LocalDate.from(chronoLd), LocalTime.of(h, min, s), offset)
.toEpochSecond());
}
@Test(dataProvider="japaneseEras")
public void test_JapaneseEra_singletons(Era expectedEra, int eraValue, String name) {
JapaneseEra actualEra = JapaneseEra.valueOf(name);
assertEquals(actualEra, expectedEra, "JapaneseEra.valueOf(name)");
actualEra = JapaneseEra.of(eraValue);
assertEquals(actualEra, expectedEra, "JapaneseEra.of(value)");
String string = actualEra.toString();
assertEquals(string, name, "JapaneseEra.toString()");
}
@Test
public void test_JapaneseChronology_eras() {
List<Era> actualEras = JapaneseChronology.INSTANCE.eras();
Object[][] erasInfo = data_japanseseEras();
assertEquals(actualEras.size(), erasInfo.length, "Wrong number of Eras");
for (int i = 0; i < erasInfo.length; i++) {
Object[] eraInfo = erasInfo[i];
assertEquals(actualEras.get(i), eraInfo[0], "Singleton mismatch");
}
}
@Override
public int prolepticYear(Era era, int yearOfEra) {
if (era instanceof CopticEra == false) {
throw new ClassCastException("Era must be CopticEra");
}
return (era == CopticEra.AM ? yearOfEra : 1 - yearOfEra);
}
@Test(dataProvider="prolepticYear")
public void test_prolepticYear(int eraValue, Era era, int yearOfEra, int expectedProlepticYear, boolean isLeapYear) {
Era eraObj = MinguoChronology.INSTANCE.eraOf(eraValue);
assertTrue(MinguoChronology.INSTANCE.eras().contains(eraObj));
assertEquals(eraObj, era);
assertEquals(MinguoChronology.INSTANCE.prolepticYear(era, yearOfEra), expectedProlepticYear);
}
@Test(dataProvider="prolepticYear")
public void test_isLeapYear(int eraValue, Era era, int yearOfEra, int expectedProlepticYear, boolean isLeapYear) {
assertEquals(MinguoChronology.INSTANCE.isLeapYear(expectedProlepticYear), isLeapYear);
assertEquals(MinguoChronology.INSTANCE.isLeapYear(expectedProlepticYear), Year.of(expectedProlepticYear + YDIFF).isLeap());
MinguoDate minguo = MinguoDate.now();
minguo = minguo.with(ChronoField.YEAR, expectedProlepticYear).with(ChronoField.MONTH_OF_YEAR, 2);
if (isLeapYear) {
assertEquals(minguo.lengthOfMonth(), 29);
} else {
assertEquals(minguo.lengthOfMonth(), 28);
}
}
@DataProvider(name = "Eras")
Era[][] data_of_calendars() {
return new Era[][] {
{HijrahEra.AH},
{IsoEra.BCE},
{IsoEra.CE},
{MinguoEra.BEFORE_ROC},
{MinguoEra.ROC},
{ThaiBuddhistEra.BEFORE_BE},
{ThaiBuddhistEra.BE},
};
}
@DataProvider(name = "Eras")
Era[][] data_of_calendars() {
return new Era[][] {
{HijrahEra.AH},
{IsoEra.BCE},
{IsoEra.CE},
{MinguoEra.BEFORE_ROC},
{MinguoEra.ROC},
{ThaiBuddhistEra.BEFORE_BE},
{ThaiBuddhistEra.BE},
};
}
@Test(dataProvider="prolepticYear")
public void test_prolepticYear(int eraValue, Era era, int yearOfEra, int expectedProlepticYear, boolean isLeapYear) {
Era eraObj = ThaiBuddhistChronology.INSTANCE.eraOf(eraValue);
assertTrue(ThaiBuddhistChronology.INSTANCE.eras().contains(eraObj));
assertEquals(eraObj, era);
assertEquals(ThaiBuddhistChronology.INSTANCE.prolepticYear(era, yearOfEra), expectedProlepticYear);
}
@DataProvider(name = "Eras")
Era[][] data_of_calendars() {
return new Era[][] {
{HijrahEra.AH},
{IsoEra.BCE},
{IsoEra.CE},
{MinguoEra.BEFORE_ROC},
{MinguoEra.ROC},
{ThaiBuddhistEra.BEFORE_BE},
{ThaiBuddhistEra.BE},
};
}
@Test(dataProvider="japaneseEras")
public void test_Japanese_Eras(Era era, int eraValue, String name) {
assertEquals(era.getValue(), eraValue, "EraValue");
assertEquals(era.toString(), name, "Era Name");
assertEquals(era, JapaneseChronology.INSTANCE.eraOf(eraValue), "JapaneseChronology.eraOf()");
List<Era> eras = JapaneseChronology.INSTANCE.eras();
assertTrue(eras.contains(era), "Era is not present in JapaneseChronology.INSTANCE.eras()");
}
@Test
public void test_Japanese_badEras() {
int badEras[] = {-1000, -998, -997, -2, 3, 4, 1000};
for (int badEra : badEras) {
try {
Era era = JapaneseChronology.INSTANCE.eraOf(badEra);
fail("JapaneseChronology.eraOf returned " + era + " + for invalid eraValue " + badEra);
} catch (DateTimeException ex) {
// ignore expected exception
}
}
}
@Override
public int prolepticYear(Era era, int yearOfEra) {
if (era instanceof CopticEra == false) {
throw new ClassCastException("Era must be CopticEra");
}
return (era == CopticEra.AM ? yearOfEra : 1 - yearOfEra);
}
@Override
public int prolepticYear(Era era, int yearOfEra) {
if (era instanceof CopticEra == false) {
throw new ClassCastException("Era must be CopticEra");
}
return (era == CopticEra.AM ? yearOfEra : 1 - yearOfEra);
}
@DataProvider(name = "Eras")
Era[][] data_of_calendars() {
return new Era[][] {
{HijrahEra.AH},
{IsoEra.BCE},
{IsoEra.CE},
{MinguoEra.BEFORE_ROC},
{MinguoEra.ROC},
{ThaiBuddhistEra.BEFORE_BE},
{ThaiBuddhistEra.BE},
};
}
@Test(dataProvider="prolepticYear")
public void test_prolepticYear(int eraValue, Era era, int yearOfEra, int expectedProlepticYear, boolean isLeapYear) {
Era eraObj = MinguoChronology.INSTANCE.eraOf(eraValue);
assertTrue(MinguoChronology.INSTANCE.eras().contains(eraObj));
assertEquals(eraObj, era);
assertEquals(MinguoChronology.INSTANCE.prolepticYear(era, yearOfEra), expectedProlepticYear);
}
@Test(dataProvider="prolepticYear")
public void test_isLeapYear(int eraValue, Era era, int yearOfEra, int expectedProlepticYear, boolean isLeapYear) {
assertEquals(MinguoChronology.INSTANCE.isLeapYear(expectedProlepticYear), isLeapYear);
assertEquals(MinguoChronology.INSTANCE.isLeapYear(expectedProlepticYear), Year.of(expectedProlepticYear + YDIFF).isLeap());
MinguoDate minguo = MinguoDate.now();
minguo = minguo.with(ChronoField.YEAR, expectedProlepticYear).with(ChronoField.MONTH_OF_YEAR, 2);
if (isLeapYear) {
assertEquals(minguo.lengthOfMonth(), 29);
} else {
assertEquals(minguo.lengthOfMonth(), 28);
}
}
@Test
public void test_Japanese_badEras() {
int badEras[] = {-1000, -998, -997, -2, 3, 4, 1000};
for (int badEra : badEras) {
try {
Era era = JapaneseChronology.INSTANCE.eraOf(badEra);
fail("JapaneseChronology.eraOf returned " + era + " + for invalid eraValue " + badEra);
} catch (DateTimeException ex) {
// ignore expected exception
}
}
}
@Test(dataProvider="prolepticYear")
public void test_prolepticYear(int eraValue, Era era, int yearOfEra, int expectedProlepticYear, boolean isLeapYear) {
Era eraObj = ThaiBuddhistChronology.INSTANCE.eraOf(eraValue);
assertTrue(ThaiBuddhistChronology.INSTANCE.eras().contains(eraObj));
assertEquals(eraObj, era);
assertEquals(ThaiBuddhistChronology.INSTANCE.prolepticYear(era, yearOfEra), expectedProlepticYear);
}
@Test(dataProvider="prolepticYear")
public void test_isLeapYear(int eraValue, Era era, int yearOfEra, int expectedProlepticYear, boolean isLeapYear) {
assertEquals(ThaiBuddhistChronology.INSTANCE.isLeapYear(expectedProlepticYear), isLeapYear) ;
assertEquals(ThaiBuddhistChronology.INSTANCE.isLeapYear(expectedProlepticYear), Year.of(expectedProlepticYear - YDIFF).isLeap());
ThaiBuddhistDate jdate = ThaiBuddhistDate.now();
jdate = jdate.with(ChronoField.YEAR, expectedProlepticYear).with(ChronoField.MONTH_OF_YEAR, 2);
if (isLeapYear) {
assertEquals(jdate.lengthOfMonth(), 29);
} else {
assertEquals(jdate.lengthOfMonth(), 28);
}
}
@Test(dataProvider="prolepticYear")
public void test_prolepticYear(int eraValue, Era era, int yearOfEra, int expectedProlepticYear, boolean isLeapYear) {
Era eraObj = JapaneseChronology.INSTANCE.eraOf(eraValue);
assertTrue(JapaneseChronology.INSTANCE.eras().contains(eraObj));
assertEquals(eraObj, era);
assertEquals(JapaneseChronology.INSTANCE.prolepticYear(era, yearOfEra), expectedProlepticYear);
}
@Test(dataProvider="prolepticYear")
public void test_isLeapYear(int eraValue, Era era, int yearOfEra, int expectedProlepticYear, boolean isLeapYear) {
assertEquals(JapaneseChronology.INSTANCE.isLeapYear(expectedProlepticYear), isLeapYear);
assertEquals(JapaneseChronology.INSTANCE.isLeapYear(expectedProlepticYear), Year.of(expectedProlepticYear).isLeap());
JapaneseDate jdate = JapaneseDate.now();
jdate = jdate.with(ChronoField.YEAR, expectedProlepticYear).with(ChronoField.MONTH_OF_YEAR, 2);
if (isLeapYear) {
assertEquals(jdate.lengthOfMonth(), 29);
} else {
assertEquals(jdate.lengthOfMonth(), 28);
}
}
@Test(dataProvider="japaneseEras")
public void test_Japanese_Eras(Era era, int eraValue, String name) {
assertEquals(era.getValue(), eraValue, "EraValue");
assertEquals(era.toString(), name, "Era Name");
assertEquals(era, JapaneseChronology.INSTANCE.eraOf(eraValue), "JapaneseChronology.eraOf()");
List<Era> eras = JapaneseChronology.INSTANCE.eras();
assertTrue(eras.contains(era), "Era is not present in JapaneseChronology.INSTANCE.eras()");
}
@Test
public void test_Japanese_badEras() {
int badEras[] = {-1000, -998, -997, -2, 3, 4, 1000};
for (int badEra : badEras) {
try {
Era era = JapaneseChronology.INSTANCE.eraOf(badEra);
fail("JapaneseChronology.eraOf returned " + era + " + for invalid eraValue " + badEra);
} catch (DateTimeException ex) {
// ignore expected exception
}
}
}
@Test(dataProvider="japaneseEras")
public void test_JapaneseEra_singletons(Era expectedEra, int eraValue, String name) {
JapaneseEra actualEra = JapaneseEra.valueOf(name);
assertEquals(actualEra, expectedEra, "JapaneseEra.valueOf(name)");
actualEra = JapaneseEra.of(eraValue);
assertEquals(actualEra, expectedEra, "JapaneseEra.of(value)");
String string = actualEra.toString();
assertEquals(string, name, "JapaneseEra.toString()");
}
@Test
public void test_JapaneseChronology_eras() {
List<Era> actualEras = JapaneseChronology.INSTANCE.eras();
Object[][] erasInfo = data_japanseseEras();
assertEquals(actualEras.size(), erasInfo.length, "Wrong number of Eras");
for (int i = 0; i < erasInfo.length; i++) {
Object[] eraInfo = erasInfo[i];
assertEquals(actualEras.get(i), eraInfo[0], "Singleton mismatch");
}
}