test/java/time/tck/java/time/TestChronology.java
Print this page
@@ -55,11 +55,11 @@
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-package tck.java.time.temporal;
+package tck.java.time;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertNotNull;
import static org.testng.Assert.assertSame;
import static org.testng.Assert.assertTrue;
@@ -69,40 +69,27 @@
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Locale;
import java.util.Set;
-import java.time.temporal.Chrono;
+import java.time.chrono.Chronology;
import java.time.temporal.ChronoField;
-import java.time.calendar.HijrahChrono;
-import java.time.calendar.JapaneseChrono;
-import java.time.calendar.MinguoChrono;
-import java.time.calendar.ThaiBuddhistChrono;
-import java.time.temporal.ChronoLocalDate;
-import java.time.temporal.ISOChrono;
+import java.time.chrono.HijrahChronology;
+import java.time.chrono.JapaneseChronology;
+import java.time.chrono.MinguoChronology;
+import java.time.chrono.ThaiBuddhistChronology;
+import java.time.chrono.ChronoLocalDate;
+import java.time.chrono.IsoChronology;
-import org.testng.annotations.BeforeMethod;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
/**
- * Test Chrono class.
+ * Test Chronology class.
*/
@Test
-public class TestChrono {
-
- @BeforeMethod(groups="tck")
- public void setUp() {
- // Ensure each of the classes are initialized (until initialization is fixed)
- Chrono<?> c;
- c = HijrahChrono.INSTANCE;
- c = ISOChrono.INSTANCE;
- c = JapaneseChrono.INSTANCE;
- c = MinguoChrono.INSTANCE;
- c = ThaiBuddhistChrono.INSTANCE;
- c.toString(); // avoids variable being marked as unused
- }
+public class TestChronology {
//-----------------------------------------------------------------------
// regular data factory for names and descriptions of available calendars
//-----------------------------------------------------------------------
@DataProvider(name = "calendars")
@@ -116,44 +103,44 @@
};
}
@Test(dataProvider = "calendars")
public void test_getters(String chronoId, String calendarSystemType, String description) {
- Chrono<?> chrono = Chrono.of(chronoId);
+ Chronology chrono = Chronology.of(chronoId);
assertNotNull(chrono, "Required calendar not found by ID: " + chronoId);
assertEquals(chrono.getId(), chronoId);
assertEquals(chrono.getCalendarType(), calendarSystemType);
}
@Test(dataProvider = "calendars")
public void test_required_calendars(String chronoId, String calendarSystemType, String description) {
- Chrono<?> chrono = Chrono.of(chronoId);
+ Chronology chrono = Chronology.of(chronoId);
assertNotNull(chrono, "Required calendar not found by ID: " + chronoId);
- chrono = Chrono.of(calendarSystemType);
+ chrono = Chronology.of(calendarSystemType);
assertNotNull(chrono, "Required calendar not found by type: " + chronoId);
- Set<Chrono<?>> cals = Chrono.getAvailableChronologies();
+ Set<Chronology> cals = Chronology.getAvailableChronologies();
assertTrue(cals.contains(chrono), "Required calendar not found in set of available calendars");
}
@Test(groups="tck")
public void test_calendar_list() {
- Set<Chrono<?>> chronos = Chrono.getAvailableChronologies();
+ Set<Chronology> chronos = Chronology.getAvailableChronologies();
assertNotNull(chronos, "Required list of calendars must be non-null");
- for (Chrono<?> chrono : chronos) {
- Chrono<?> lookup = Chrono.of(chrono.getId());
+ for (Chronology chrono : chronos) {
+ Chronology lookup = Chronology.of(chrono.getId());
assertNotNull(lookup, "Required calendar not found: " + chrono);
}
- assertEquals(chronos.size() >= data_of_calendars().length, true, "Chrono.getAvailableChronologies().size = " + chronos.size()
+ assertEquals(chronos.size() >= data_of_calendars().length, true, "Chronology.getAvailableChronologies().size = " + chronos.size()
+ ", expected >= " + data_of_calendars().length);
}
/**
* Compute the number of days from the Epoch and compute the date from the number of days.
*/
@Test(dataProvider = "calendars", groups="tck")
public void test_epoch(String name, String alias, String description) {
- Chrono<?> chrono = Chrono.of(name); // a chronology. In practice this is rarely hardcoded
+ Chronology chrono = Chronology.of(name); // a chronology. In practice this is rarely hardcoded
ChronoLocalDate<?> date1 = chrono.dateNow();
long epoch1 = date1.getLong(ChronoField.EPOCH_DAY);
ChronoLocalDate<?> date2 = date1.with(ChronoField.EPOCH_DAY, epoch1);
assertEquals(date1, date2, "Date from epoch day is not same date: " + date1 + " != " + date2);
long epoch2 = date1.getLong(ChronoField.EPOCH_DAY);
@@ -164,43 +151,42 @@
// locale based lookup
//-----------------------------------------------------------------------
@DataProvider(name = "calendarsystemtype")
Object[][] data_CalendarType() {
return new Object[][] {
- {HijrahChrono.INSTANCE, "islamicc"},
- {ISOChrono.INSTANCE, "iso8601"},
- {JapaneseChrono.INSTANCE, "japanese"},
- {MinguoChrono.INSTANCE, "roc"},
- {ThaiBuddhistChrono.INSTANCE, "buddhist"},
+ {HijrahChronology.INSTANCE, "islamicc"},
+ {IsoChronology.INSTANCE, "iso8601"},
+ {JapaneseChronology.INSTANCE, "japanese"},
+ {MinguoChronology.INSTANCE, "roc"},
+ {ThaiBuddhistChronology.INSTANCE, "buddhist"},
};
}
@Test(dataProvider = "calendarsystemtype", groups="tck")
- public void test_getCalendarType(Chrono<?> chrono, String calendarType) {
+ public void test_getCalendarType(Chronology chrono, String calendarType) {
assertEquals(chrono.getCalendarType(), calendarType);
}
@Test(dataProvider = "calendarsystemtype", groups="tck")
- public void test_lookupLocale(Chrono<?> chrono, String calendarType) {
+ public void test_lookupLocale(Chronology chrono, String calendarType) {
Locale locale = new Locale.Builder().setLanguage("en").setRegion("CA").setUnicodeLocaleKeyword("ca", calendarType).build();
- assertEquals(Chrono.ofLocale(locale), chrono);
+ assertEquals(Chronology.ofLocale(locale), chrono);
}
//-----------------------------------------------------------------------
// serialization; serialize and check each calendar system
//-----------------------------------------------------------------------
- @Test(groups={"implementation"}, dataProvider = "calendarsystemtype")
- public <C extends Chrono<C>> void test_chronoSerializationSingleton(C chrono, String calendarType) throws Exception {
- C orginal = chrono;
+ @Test(groups={"tck","implementation"}, dataProvider = "calendarsystemtype")
+ public void test_chronoSerializationSingleton(Chronology chrono, String calendarType) throws Exception {
+ Chronology orginal = chrono;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(baos);
out.writeObject(orginal);
out.close();
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream in = new ObjectInputStream(bais);
- @SuppressWarnings("unchecked")
- C ser = (C) in.readObject();
- assertSame(ser, chrono, "Deserialized Chrono is not the singleton serialized");
+ Chronology ser = (Chronology) in.readObject();
+ assertSame(ser, chrono, "Deserialized Chronology is not the singleton serialized");
}
}