47 *
48 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
49 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
50 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
51 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
52 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
53 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
54 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
55 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
56 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
57 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
58 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
59 */
60 package tck.java.time.chrono;
61
62 import static org.testng.Assert.assertEquals;
63 import static org.testng.Assert.assertNotNull;
64 import static org.testng.Assert.assertSame;
65 import static org.testng.Assert.assertTrue;
66
67 import java.io.ByteArrayInputStream;
68 import java.io.ByteArrayOutputStream;
69 import java.io.ObjectInputStream;
70 import java.io.ObjectOutputStream;
71 import java.time.DateTimeException;
72 import java.time.chrono.ChronoLocalDate;
73 import java.time.chrono.Chronology;
74 import java.time.chrono.HijrahChronology;
75 import java.time.chrono.IsoChronology;
76 import java.time.chrono.JapaneseChronology;
77 import java.time.chrono.MinguoChronology;
78 import java.time.chrono.ThaiBuddhistChronology;
79 import java.time.temporal.ChronoField;
80 import java.util.Locale;
81 import java.util.Set;
82
83 import org.testng.annotations.DataProvider;
84 import org.testng.annotations.Test;
85
86 /**
87 * Test Chronology class.
88 */
89 @Test
90 public class TCKChronology {
91
92 //-----------------------------------------------------------------------
93 // regular data factory for ID and calendarType of available calendars
94 //-----------------------------------------------------------------------
95 @DataProvider(name = "calendarNameAndType")
96 Object[][] data_of_calendars() {
97 return new Object[][] {
98 {"Hijrah-umalqura", "islamic-umalqura"},
116 Chronology chrono = Chronology.of(chronoId);
117 assertNotNull(chrono, "Required calendar not found by ID: " + chronoId);
118 chrono = Chronology.of(calendarSystemType);
119 assertNotNull(chrono, "Required calendar not found by type: " + chronoId);
120 Set<Chronology> cals = Chronology.getAvailableChronologies();
121 assertTrue(cals.contains(chrono), "Required calendar not found in set of available calendars");
122 }
123
124 @Test
125 public void test_calendar_list() {
126 Set<Chronology> chronos = Chronology.getAvailableChronologies();
127 assertNotNull(chronos, "Required list of calendars must be non-null");
128 for (Chronology chrono : chronos) {
129 Chronology lookup = Chronology.of(chrono.getId());
130 assertNotNull(lookup, "Required calendar not found: " + chrono);
131 }
132 assertEquals(chronos.size() >= data_of_calendars().length, true, "Chronology.getAvailableChronologies().size = " + chronos.size()
133 + ", expected >= " + data_of_calendars().length);
134 }
135
136 /**
137 * Compute the number of days from the Epoch and compute the date from the number of days.
138 */
139 @Test(dataProvider = "calendarNameAndType")
140 public void test_epoch(String name, String alias) {
141 Chronology chrono = Chronology.of(name); // a chronology. In practice this is rarely hardcoded
142 ChronoLocalDate<?> date1 = chrono.dateNow();
143 long epoch1 = date1.getLong(ChronoField.EPOCH_DAY);
144 ChronoLocalDate<?> date2 = date1.with(ChronoField.EPOCH_DAY, epoch1);
145 assertEquals(date1, date2, "Date from epoch day is not same date: " + date1 + " != " + date2);
146 long epoch2 = date1.getLong(ChronoField.EPOCH_DAY);
147 assertEquals(epoch1, epoch2, "Epoch day not the same: " + epoch1 + " != " + epoch2);
148 }
149
150 @Test(dataProvider = "calendarNameAndType")
151 public void test_dateEpochDay(String name, String alias) {
152 Chronology chrono = Chronology.of(name);
153 ChronoLocalDate<?> date = chrono.dateNow();
154 long epochDay = date.getLong(ChronoField.EPOCH_DAY);
155 ChronoLocalDate<?> test = chrono.dateEpochDay(epochDay);
156 assertEquals(test, date);
157 }
158
159 //-----------------------------------------------------------------------
160 // locale based lookup
161 //-----------------------------------------------------------------------
162 @DataProvider(name = "calendarsystemtype")
163 Object[][] data_CalendarType() {
164 return new Object[][] {
165 {HijrahChronology.INSTANCE, "islamic-umalqura"},
166 {IsoChronology.INSTANCE, "iso8601"},
167 {JapaneseChronology.INSTANCE, "japanese"},
168 {MinguoChronology.INSTANCE, "roc"},
169 {ThaiBuddhistChronology.INSTANCE, "buddhist"},
170 };
171 }
172
173 @Test(dataProvider = "calendarsystemtype")
174 public void test_getCalendarType(Chronology chrono, String calendarType) {
175 String type = calendarType;
176 assertEquals(chrono.getCalendarType(), type);
177 }
178
179 @Test(dataProvider = "calendarsystemtype")
180 public void test_lookupLocale(Chronology chrono, String calendarType) {
181 Locale.Builder builder = new Locale.Builder().setLanguage("en").setRegion("CA");
182 builder.setUnicodeLocaleKeyword("ca", calendarType);
183 Locale locale = builder.build();
184 assertEquals(Chronology.ofLocale(locale), chrono);
185 }
186
187 /**
188 * Test lookup by calendarType of each chronology.
189 * Verify that the calendar can be found by {@link java.time.chrono.Chronology#ofLocale}.
190 */
191 @Test
192 public void test_ofLocaleByType() {
193 // Test that all available chronologies can be successfully found using ofLocale
194 Set<Chronology> chronos = Chronology.getAvailableChronologies();
195 for (Chronology chrono : chronos) {
196 Locale.Builder builder = new Locale.Builder().setLanguage("en").setRegion("CA");
197 builder.setUnicodeLocaleKeyword("ca", chrono.getCalendarType());
198 Locale locale = builder.build();
199 assertEquals(Chronology.ofLocale(locale), chrono, "Lookup by type");
200 }
201 }
202
203 @Test(expectedExceptions=DateTimeException.class)
204 public void test_lookupLocale() {
205 Locale.Builder builder = new Locale.Builder().setLanguage("en").setRegion("CA");
206 builder.setUnicodeLocaleKeyword("ca", "xxx");
|
47 *
48 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
49 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
50 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
51 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
52 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
53 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
54 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
55 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
56 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
57 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
58 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
59 */
60 package tck.java.time.chrono;
61
62 import static org.testng.Assert.assertEquals;
63 import static org.testng.Assert.assertNotNull;
64 import static org.testng.Assert.assertSame;
65 import static org.testng.Assert.assertTrue;
66
67 import java.util.Locale;
68 import java.io.ByteArrayInputStream;
69 import java.io.ByteArrayOutputStream;
70 import java.io.ObjectInputStream;
71 import java.io.ObjectOutputStream;
72 import java.time.ZoneId;
73 import java.time.Clock;
74 import java.time.DateTimeException;
75 import java.time.chrono.ChronoLocalDate;
76 import java.time.chrono.Chronology;
77 import java.time.chrono.HijrahChronology;
78 import java.time.chrono.HijrahEra;
79 import java.time.chrono.IsoChronology;
80 import java.time.chrono.IsoEra;
81 import java.time.chrono.JapaneseChronology;
82 import java.time.chrono.JapaneseEra;
83 import java.time.chrono.MinguoChronology;
84 import java.time.chrono.MinguoEra;
85 import java.time.chrono.ThaiBuddhistChronology;
86 import java.time.chrono.ThaiBuddhistEra;
87 import java.time.format.TextStyle;
88 import java.time.temporal.ChronoField;
89 import java.util.Locale;
90 import java.util.Set;
91
92 import org.testng.annotations.DataProvider;
93 import org.testng.annotations.Test;
94
95 /**
96 * Test Chronology class.
97 */
98 @Test
99 public class TCKChronology {
100
101 //-----------------------------------------------------------------------
102 // regular data factory for ID and calendarType of available calendars
103 //-----------------------------------------------------------------------
104 @DataProvider(name = "calendarNameAndType")
105 Object[][] data_of_calendars() {
106 return new Object[][] {
107 {"Hijrah-umalqura", "islamic-umalqura"},
125 Chronology chrono = Chronology.of(chronoId);
126 assertNotNull(chrono, "Required calendar not found by ID: " + chronoId);
127 chrono = Chronology.of(calendarSystemType);
128 assertNotNull(chrono, "Required calendar not found by type: " + chronoId);
129 Set<Chronology> cals = Chronology.getAvailableChronologies();
130 assertTrue(cals.contains(chrono), "Required calendar not found in set of available calendars");
131 }
132
133 @Test
134 public void test_calendar_list() {
135 Set<Chronology> chronos = Chronology.getAvailableChronologies();
136 assertNotNull(chronos, "Required list of calendars must be non-null");
137 for (Chronology chrono : chronos) {
138 Chronology lookup = Chronology.of(chrono.getId());
139 assertNotNull(lookup, "Required calendar not found: " + chrono);
140 }
141 assertEquals(chronos.size() >= data_of_calendars().length, true, "Chronology.getAvailableChronologies().size = " + chronos.size()
142 + ", expected >= " + data_of_calendars().length);
143 }
144
145 //-----------------------------------------------------------------------
146 // getDisplayName()
147 //-----------------------------------------------------------------------
148 @DataProvider(name = "calendarDisplayName")
149 Object[][] data_of_calendarDisplayNames() {
150 return new Object[][] {
151 {"Hijrah", "Hijrah-umalqura"},
152 {"ISO", "ISO"},
153 {"Japanese", "Japanese Calendar"},
154 {"Minguo", "Minguo Calendar"},
155 {"ThaiBuddhist", "Buddhist Calendar"},
156 };
157 }
158
159 @Test(dataProvider = "calendarDisplayName")
160 public void test_getDisplayName(String chronoId, String calendarDisplayName) {
161 Chronology chrono = Chronology.of(chronoId);
162 assertEquals(chrono.getDisplayName(TextStyle.FULL, Locale.ENGLISH), calendarDisplayName);
163 }
164
165 /**
166 * Compute the number of days from the Epoch and compute the date from the number of days.
167 */
168 @Test(dataProvider = "calendarNameAndType")
169 public void test_epoch(String name, String alias) {
170 Chronology chrono = Chronology.of(name); // a chronology. In practice this is rarely hardcoded
171 ChronoLocalDate date1 = chrono.dateNow();
172 long epoch1 = date1.getLong(ChronoField.EPOCH_DAY);
173 ChronoLocalDate date2 = date1.with(ChronoField.EPOCH_DAY, epoch1);
174 assertEquals(date1, date2, "Date from epoch day is not same date: " + date1 + " != " + date2);
175 long epoch2 = date1.getLong(ChronoField.EPOCH_DAY);
176 assertEquals(epoch1, epoch2, "Epoch day not the same: " + epoch1 + " != " + epoch2);
177 }
178
179 @Test(dataProvider = "calendarNameAndType")
180 public void test_dateEpochDay(String name, String alias) {
181 Chronology chrono = Chronology.of(name);
182 ChronoLocalDate date = chrono.dateNow();
183 long epochDay = date.getLong(ChronoField.EPOCH_DAY);
184 ChronoLocalDate test = chrono.dateEpochDay(epochDay);
185 assertEquals(test, date);
186 }
187
188 //-----------------------------------------------------------------------
189 // locale based lookup
190 //-----------------------------------------------------------------------
191 @DataProvider(name = "calendarsystemtype")
192 Object[][] data_CalendarType() {
193 return new Object[][] {
194 {HijrahChronology.INSTANCE, "islamic-umalqura"},
195 {IsoChronology.INSTANCE, "iso8601"},
196 {JapaneseChronology.INSTANCE, "japanese"},
197 {MinguoChronology.INSTANCE, "roc"},
198 {ThaiBuddhistChronology.INSTANCE, "buddhist"},
199 };
200 }
201
202 @Test(dataProvider = "calendarsystemtype")
203 public void test_getCalendarType(Chronology chrono, String calendarType) {
204 String type = calendarType;
205 assertEquals(chrono.getCalendarType(), type);
206 }
207
208 @Test(dataProvider = "calendarsystemtype")
209 public void test_lookupLocale(Chronology chrono, String calendarType) {
210 Locale.Builder builder = new Locale.Builder().setLanguage("en").setRegion("CA");
211 builder.setUnicodeLocaleKeyword("ca", calendarType);
212 Locale locale = builder.build();
213 assertEquals(Chronology.ofLocale(locale), chrono);
214 }
215
216 //-----------------------------------------------------------------------
217 // dateNow()
218 //-----------------------------------------------------------------------
219 @Test
220 public void test_MinguoChronology_dateNow() {
221 ZoneId zoneId_paris = ZoneId.of("Europe/Paris");
222 Clock clock = Clock.system(zoneId_paris);
223
224 Chronology chrono = Chronology.of("Minguo");
225 assertEquals(chrono.dateNow(), MinguoChronology.INSTANCE.dateNow());
226 assertEquals(chrono.dateNow(zoneId_paris), MinguoChronology.INSTANCE.dateNow(zoneId_paris));
227 assertEquals(chrono.dateNow(clock), MinguoChronology.INSTANCE.dateNow(clock));
228 }
229
230 @Test
231 public void test_IsoChronology_dateNow() {
232 ZoneId zoneId_paris = ZoneId.of("Europe/Paris");
233 Clock clock = Clock.system(zoneId_paris);
234
235 Chronology chrono = Chronology.of("ISO");
236 assertEquals(chrono.dateNow(), IsoChronology.INSTANCE.dateNow());
237 assertEquals(chrono.dateNow(zoneId_paris), IsoChronology.INSTANCE.dateNow(zoneId_paris));
238 assertEquals(chrono.dateNow(clock), IsoChronology.INSTANCE.dateNow(clock));
239 }
240
241 @Test
242 public void test_JapaneseChronology_dateNow() {
243 ZoneId zoneId_paris = ZoneId.of("Europe/Paris");
244 Clock clock = Clock.system(zoneId_paris);
245
246 Chronology chrono = Chronology.of("Japanese");
247 assertEquals(chrono.dateNow(), JapaneseChronology.INSTANCE.dateNow());
248 assertEquals(chrono.dateNow(zoneId_paris), JapaneseChronology.INSTANCE.dateNow(zoneId_paris));
249 assertEquals(chrono.dateNow(clock), JapaneseChronology.INSTANCE.dateNow(clock));
250 }
251
252 @Test
253 public void test_ThaiBuddhistChronology_dateNow() {
254 ZoneId zoneId_paris = ZoneId.of("Europe/Paris");
255 Clock clock = Clock.system(zoneId_paris);
256
257 Chronology chrono = Chronology.of("ThaiBuddhist");
258 assertEquals(chrono.dateNow(), ThaiBuddhistChronology.INSTANCE.dateNow());
259 assertEquals(chrono.dateNow(zoneId_paris), ThaiBuddhistChronology.INSTANCE.dateNow(zoneId_paris));
260 assertEquals(chrono.dateNow(clock), ThaiBuddhistChronology.INSTANCE.dateNow(clock));
261 }
262
263 //-----------------------------------------------------------------------
264 // dateYearDay() and date()
265 //-----------------------------------------------------------------------
266 @Test
267 public void test_HijrahChronology_dateYearDay() {
268 Chronology chrono = Chronology.of("Hijrah");
269 ChronoLocalDate date1 = chrono.dateYearDay(HijrahEra.AH, 1434, 178);
270 ChronoLocalDate date2 = chrono.date(HijrahEra.AH, 1434, 7, 1);
271 assertEquals(date1, HijrahChronology.INSTANCE.dateYearDay(HijrahEra.AH, 1434, 178));
272 assertEquals(date2, HijrahChronology.INSTANCE.dateYearDay(HijrahEra.AH, 1434, 178));
273 }
274
275 @Test
276 public void test_MinguoChronology_dateYearDay() {
277 Chronology chrono = Chronology.of("Minguo");
278 ChronoLocalDate date1 = chrono.dateYearDay(MinguoEra.ROC, 5, 60);
279 ChronoLocalDate date2 = chrono.date(MinguoEra.ROC, 5, 2, 29);
280 assertEquals(date1, MinguoChronology.INSTANCE.dateYearDay(MinguoEra.ROC, 5, 60));
281 assertEquals(date2, MinguoChronology.INSTANCE.dateYearDay(MinguoEra.ROC, 5, 60));
282 }
283
284 @Test
285 public void test_IsoChronology_dateYearDay() {
286 Chronology chrono = Chronology.of("ISO");
287 ChronoLocalDate date1 = chrono.dateYearDay(IsoEra.CE, 5, 60);
288 ChronoLocalDate date2 = chrono.date(IsoEra.CE, 5, 3, 1);
289 assertEquals(date1, IsoChronology.INSTANCE.dateYearDay(IsoEra.CE, 5, 60));
290 assertEquals(date2, IsoChronology.INSTANCE.dateYearDay(IsoEra.CE, 5, 60));
291 }
292
293 @Test
294 public void test_JapaneseChronology_dateYearDay() {
295 Chronology chrono = Chronology.of("Japanese");
296 ChronoLocalDate date1 = chrono.dateYearDay(JapaneseEra.HEISEI, 8, 60);
297 ChronoLocalDate date2 = chrono.date(JapaneseEra.HEISEI, 8, 2, 29);
298 assertEquals(date1, JapaneseChronology.INSTANCE.dateYearDay(JapaneseEra.HEISEI, 8, 60));
299 assertEquals(date2, JapaneseChronology.INSTANCE.dateYearDay(JapaneseEra.HEISEI, 8, 60));
300 }
301
302 @Test
303 public void test_ThaiBuddhistChronology_dateYearDay() {
304 Chronology chrono = Chronology.of("ThaiBuddhist");
305 ChronoLocalDate date1 = chrono.dateYearDay(ThaiBuddhistEra.BE, 2459, 60);
306 ChronoLocalDate date2 = chrono.date(ThaiBuddhistEra.BE, 2459, 2, 29);
307 assertEquals(date1, ThaiBuddhistChronology.INSTANCE.dateYearDay(ThaiBuddhistEra.BE, 2459, 60));
308 assertEquals(date2, ThaiBuddhistChronology.INSTANCE.dateYearDay(ThaiBuddhistEra.BE, 2459, 60));
309 }
310
311 /**
312 * Test lookup by calendarType of each chronology.
313 * Verify that the calendar can be found by {@link java.time.chrono.Chronology#ofLocale}.
314 */
315 @Test
316 public void test_ofLocaleByType() {
317 // Test that all available chronologies can be successfully found using ofLocale
318 Set<Chronology> chronos = Chronology.getAvailableChronologies();
319 for (Chronology chrono : chronos) {
320 Locale.Builder builder = new Locale.Builder().setLanguage("en").setRegion("CA");
321 builder.setUnicodeLocaleKeyword("ca", chrono.getCalendarType());
322 Locale locale = builder.build();
323 assertEquals(Chronology.ofLocale(locale), chrono, "Lookup by type");
324 }
325 }
326
327 @Test(expectedExceptions=DateTimeException.class)
328 public void test_lookupLocale() {
329 Locale.Builder builder = new Locale.Builder().setLanguage("en").setRegion("CA");
330 builder.setUnicodeLocaleKeyword("ca", "xxx");
|