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");
     }
 
 }