40 *
41 * * Neither the name of JSR-310 nor the names of its contributors
42 * may be used to endorse or promote products derived from this software
43 * without specific prior written permission.
44 *
45 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
46 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
47 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
48 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
49 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
50 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
51 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
52 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
53 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
54 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
55 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
56 */
57 package tck.java.time.chrono;
58
59 import static java.time.temporal.ChronoField.DAY_OF_MONTH;
60 import static java.time.temporal.ChronoField.ERA;
61 import static java.time.temporal.ChronoField.MONTH_OF_YEAR;
62 import static java.time.temporal.ChronoField.YEAR;
63 import static java.time.temporal.ChronoField.YEAR_OF_ERA;
64 import static org.testng.Assert.assertEquals;
65 import static org.testng.Assert.assertFalse;
66 import static org.testng.Assert.assertTrue;
67 import static org.testng.Assert.fail;
68
69 import java.time.Clock;
70 import java.time.DateTimeException;
71 import java.time.LocalDate;
72 import java.time.LocalDateTime;
73 import java.time.Month;
74 import java.time.Period;
75 import java.time.Year;
76 import java.time.ZoneId;
77 import java.time.ZoneOffset;
78 import java.time.chrono.ChronoLocalDate;
79 import java.time.chrono.Chronology;
80 import java.time.chrono.Era;
81 import java.time.chrono.IsoChronology;
82 import java.time.chrono.JapaneseChronology;
83 import java.time.chrono.JapaneseDate;
84 import java.time.chrono.JapaneseEra;
85 import java.time.chrono.MinguoChronology;
86 import java.time.chrono.MinguoDate;
87 import java.time.temporal.ChronoUnit;
88 import java.time.temporal.TemporalAdjuster;
89 import java.util.List;
90 import java.util.Locale;
91
92 import org.testng.Assert;
93 import org.testng.annotations.DataProvider;
94 import org.testng.annotations.Test;
95
96 /**
97 * Test.
98 */
99 @Test
100 public class TCKJapaneseChronology {
101 private static final int YDIFF_HEISEI = 1988;
102 private static final int YDIFF_MEIJI = 1867;
103 private static final int YDIFF_SHOWA = 1925;
104 private static final int YDIFF_TAISHO = 1911;
105
106 //-----------------------------------------------------------------------
107 // Chronology.of(String)
108 //-----------------------------------------------------------------------
109 @Test
110 public void test_chrono_byName() {
138 Chronology test = Chronology.ofLocale(new Locale("ja", "JP"));
139 Assert.assertEquals(test.getId(), "ISO");
140 Assert.assertEquals(test, IsoChronology.INSTANCE);
141 }
142
143 @Test
144 public void test_chrono_byLocale_oldJP_variant() {
145 Chronology test = Chronology.ofLocale(new Locale("ja", "JP", "JP"));
146 Assert.assertEquals(test.getId(), "Japanese");
147 Assert.assertEquals(test, JapaneseChronology.INSTANCE);
148 }
149
150 @Test
151 public void test_chrono_byLocale_iso() {
152 Assert.assertEquals(Chronology.ofLocale(new Locale("ja", "JP")).getId(), "ISO");
153 Assert.assertEquals(Chronology.ofLocale(Locale.forLanguageTag("ja-JP")).getId(), "ISO");
154 Assert.assertEquals(Chronology.ofLocale(Locale.forLanguageTag("ja-JP-JP")).getId(), "ISO");
155 }
156
157 //-----------------------------------------------------------------------
158 // creation, toLocalDate()
159 //-----------------------------------------------------------------------
160 @DataProvider(name="samples")
161 Object[][] data_samples() {
162 return new Object[][] {
163 {JapaneseChronology.INSTANCE.date(1, 1, 1), LocalDate.of(1, 1, 1)},
164 {JapaneseChronology.INSTANCE.date(1, 1, 2), LocalDate.of(1, 1, 2)},
165 {JapaneseChronology.INSTANCE.date(1, 1, 3), LocalDate.of(1, 1, 3)},
166
167 {JapaneseChronology.INSTANCE.date(2, 1, 1), LocalDate.of(2, 1, 1)},
168 {JapaneseChronology.INSTANCE.date(3, 1, 1), LocalDate.of(3, 1, 1)},
169 {JapaneseChronology.INSTANCE.date(3, 12, 6), LocalDate.of(3, 12, 6)},
170 {JapaneseChronology.INSTANCE.date(4, 1, 1), LocalDate.of(4, 1, 1)},
171 {JapaneseChronology.INSTANCE.date(4, 7, 3), LocalDate.of(4, 7, 3)},
172 {JapaneseChronology.INSTANCE.date(4, 7, 4), LocalDate.of(4, 7, 4)},
173 {JapaneseChronology.INSTANCE.date(5, 1, 1), LocalDate.of(5, 1, 1)},
174 {JapaneseChronology.INSTANCE.date(1662, 3, 3), LocalDate.of(1662, 3, 3)},
175 {JapaneseChronology.INSTANCE.date(1728, 10, 28), LocalDate.of(1728, 10, 28)},
176 {JapaneseChronology.INSTANCE.date(1728, 10, 29), LocalDate.of(1728, 10, 29)},
177
178 {JapaneseChronology.INSTANCE.date(JapaneseEra.HEISEI, 1996 - YDIFF_HEISEI, 2, 29), LocalDate.of(1996, 2, 29)},
179 {JapaneseChronology.INSTANCE.date(JapaneseEra.HEISEI, 2000 - YDIFF_HEISEI, 2, 29), LocalDate.of(2000, 2, 29)},
180 {JapaneseChronology.INSTANCE.date(JapaneseEra.MEIJI, 1868 - YDIFF_MEIJI, 2, 29), LocalDate.of(1868, 2, 29)},
181 {JapaneseChronology.INSTANCE.date(JapaneseEra.SHOWA, 1928 - YDIFF_SHOWA, 12, 25), LocalDate.of(1928, 12, 25)},
182 {JapaneseChronology.INSTANCE.date(JapaneseEra.TAISHO, 1912 - YDIFF_TAISHO, 7, 30), LocalDate.of(1912, 7, 30)},
183
184 {JapaneseChronology.INSTANCE.dateYearDay(1996, 60), LocalDate.of(1996, 2, 29)},
185 {JapaneseChronology.INSTANCE.dateYearDay(1868, 60), LocalDate.of(1868, 2, 29)},
186 {JapaneseChronology.INSTANCE.dateYearDay(1928, 60), LocalDate.of(1928, 2, 29)},
187 {JapaneseChronology.INSTANCE.dateYearDay(1912, 60), LocalDate.of(1912, 2, 29)},
188
189 {JapaneseDate.ofYearDay(1996, 60), LocalDate.of(1996, 2, 29)},
190 {JapaneseDate.ofYearDay(1868, 60), LocalDate.of(1868, 2, 29)},
191 {JapaneseDate.ofYearDay(1928, 60), LocalDate.of(1928, 2, 29)},
192 {JapaneseDate.ofYearDay(1912, 60), LocalDate.of(1912, 2, 29)},
193
194 {JapaneseChronology.INSTANCE.dateYearDay(JapaneseEra.HEISEI, 1996 - YDIFF_HEISEI, 60), LocalDate.of(1996, 2, 29)},
195 {JapaneseChronology.INSTANCE.dateYearDay(JapaneseEra.MEIJI, 1868 - YDIFF_MEIJI, 60), LocalDate.of(1868, 2, 29)},
196 {JapaneseChronology.INSTANCE.dateYearDay(JapaneseEra.SHOWA, 1928 - YDIFF_SHOWA, 60), LocalDate.of(1928, 2, 29)},
197 // {JapaneseChronology.INSTANCE.dateYearDay(JapaneseEra.TAISHO, 1916 - YDIFF_TAISHO, 60), LocalDate.of(1912, 2, 29)},
198 };
199 }
200
201 @Test(dataProvider="samples")
202 public void test_toLocalDate(JapaneseDate jdate, LocalDate iso) {
203 assertEquals(LocalDate.from(jdate), iso);
204 }
205
206 @Test(dataProvider="samples")
207 public void test_fromCalendrical(JapaneseDate jdate, LocalDate iso) {
208 assertEquals(JapaneseChronology.INSTANCE.date(iso), jdate);
209 }
210
211 @Test
212 public void test_dateNow(){
213 assertEquals(JapaneseChronology.INSTANCE.dateNow(), JapaneseDate.now()) ;
214 assertEquals(JapaneseChronology.INSTANCE.dateNow(), JapaneseDate.now(ZoneId.systemDefault())) ;
215 assertEquals(JapaneseChronology.INSTANCE.dateNow(), JapaneseDate.now(Clock.systemDefaultZone())) ;
216 assertEquals(JapaneseChronology.INSTANCE.dateNow(), JapaneseDate.now(Clock.systemDefaultZone().getZone())) ;
217
218 assertEquals(JapaneseChronology.INSTANCE.dateNow(), JapaneseChronology.INSTANCE.dateNow(ZoneId.systemDefault())) ;
219 assertEquals(JapaneseChronology.INSTANCE.dateNow(), JapaneseChronology.INSTANCE.dateNow(Clock.systemDefaultZone())) ;
220 assertEquals(JapaneseChronology.INSTANCE.dateNow(), JapaneseChronology.INSTANCE.dateNow(Clock.systemDefaultZone().getZone())) ;
221
222 ZoneId zoneId = ZoneId.of("Europe/Paris");
223 assertEquals(JapaneseChronology.INSTANCE.dateNow(zoneId), JapaneseChronology.INSTANCE.dateNow(Clock.system(zoneId))) ;
224 assertEquals(JapaneseChronology.INSTANCE.dateNow(zoneId), JapaneseChronology.INSTANCE.dateNow(Clock.system(zoneId).getZone())) ;
225 assertEquals(JapaneseChronology.INSTANCE.dateNow(zoneId), JapaneseDate.now(Clock.system(zoneId))) ;
226 assertEquals(JapaneseChronology.INSTANCE.dateNow(zoneId), JapaneseDate.now(Clock.system(zoneId).getZone())) ;
227
228 assertEquals(JapaneseChronology.INSTANCE.dateNow(ZoneId.of(ZoneOffset.UTC.getId())), JapaneseChronology.INSTANCE.dateNow(Clock.systemUTC())) ;
229 }
230
231 @DataProvider(name="badDates")
232 Object[][] data_badDates() {
233 return new Object[][] {
234 {1728, 0, 0},
235
236 {1728, -1, 1},
237 {1728, 0, 1},
238 {1728, 14, 1},
239 {1728, 15, 1},
240
241 {1728, 1, -1},
242 {1728, 1, 0},
243 {1728, 1, 32},
244
245 {1728, 12, -1},
246 {1728, 12, 0},
247 {1728, 12, 32},
248
249 {1725, 2, 29},
250 {500, 2, 29},
251 {2100, 2, 29},
252 };
253 }
254
255 @Test(dataProvider="badDates", expectedExceptions=DateTimeException.class)
256 public void test_badDates(int year, int month, int dom) {
257 JapaneseChronology.INSTANCE.date(year, month, dom);
258 }
259
260 //-----------------------------------------------------------------------
261 // prolepticYear() and is LeapYear()
262 //-----------------------------------------------------------------------
263 @DataProvider(name="prolepticYear")
264 Object[][] data_prolepticYear() {
265 return new Object[][] {
266 {2, JapaneseEra.HEISEI, 1, 1 + YDIFF_HEISEI, false},
267 {2, JapaneseEra.HEISEI, 100, 100 + YDIFF_HEISEI, true},
268
269 {-1, JapaneseEra.MEIJI, 1, 1 + YDIFF_MEIJI, true},
270 {-1, JapaneseEra.MEIJI, 4, 4 + YDIFF_MEIJI, false},
271
272 {1, JapaneseEra.SHOWA, 1, 1 + YDIFF_SHOWA, false},
273 {1, JapaneseEra.SHOWA, 7, 7 + YDIFF_SHOWA, true},
274
275 {0, JapaneseEra.TAISHO, 1, 1 + YDIFF_TAISHO, true},
276 {0, JapaneseEra.TAISHO, 4, 4 + YDIFF_TAISHO, false},
277 };
278 }
279
280 @Test(dataProvider="prolepticYear")
281 public void test_prolepticYear(int eraValue, Era era, int yearOfEra, int expectedProlepticYear, boolean isLeapYear) {
282 Era eraObj = JapaneseChronology.INSTANCE.eraOf(eraValue) ;
283 assertTrue(JapaneseChronology.INSTANCE.eras().contains(eraObj));
284 assertEquals(eraObj, era);
285 assertEquals(JapaneseChronology.INSTANCE.prolepticYear(era, yearOfEra), expectedProlepticYear);
286 assertEquals(JapaneseChronology.INSTANCE.isLeapYear(expectedProlepticYear), isLeapYear) ;
287 assertEquals(JapaneseChronology.INSTANCE.isLeapYear(expectedProlepticYear), Year.of(expectedProlepticYear).isLeap()) ;
288 }
289
290 @DataProvider(name="prolepticYearError")
291 Object[][] data_prolepticYearError() {
292 return new Object[][] {
293 {JapaneseEra.MEIJI, 100},
294 {JapaneseEra.MEIJI, 0},
295 {JapaneseEra.MEIJI, -10},
296
297 {JapaneseEra.SHOWA, 100},
298 {JapaneseEra.SHOWA, 0},
299 {JapaneseEra.SHOWA, -10},
300
301 {JapaneseEra.TAISHO, 100},
302 {JapaneseEra.TAISHO, 0},
303 {JapaneseEra.TAISHO, -10},
304 };
305 }
306
307 @Test(dataProvider="prolepticYearError", expectedExceptions=DateTimeException.class)
310 }
311
312 //-----------------------------------------------------------------------
313 // Bad Era for Chronology.date(era,...) and Chronology.prolepticYear(Era,...)
314 //-----------------------------------------------------------------------
315 @Test
316 public void test_InvalidEras() {
317 // Verify that the eras from every other Chronology are invalid
318 for (Chronology chrono : Chronology.getAvailableChronologies()) {
319 if (chrono instanceof JapaneseChronology) {
320 continue;
321 }
322 List<Era> eras = chrono.eras();
323 for (Era era : eras) {
324 try {
325 ChronoLocalDate date = JapaneseChronology.INSTANCE.date(era, 1, 1, 1);
326 fail("JapaneseChronology.date did not throw ClassCastException for Era: " + era);
327 } catch (ClassCastException cex) {
328 ; // ignore expected exception
329 }
330
331 try {
332 @SuppressWarnings("unused")
333 JapaneseDate jdate = JapaneseDate.of(era, 1, 1, 1);
334 fail("JapaneseDate.of did not throw ClassCastException for Era: " + era);
335 } catch (ClassCastException cex) {
336 ; // ignore expected exception
337 }
338
339 try {
340 @SuppressWarnings("unused")
341 int year = JapaneseChronology.INSTANCE.prolepticYear(era, 1);
342 fail("JapaneseChronology.prolepticYear did not throw ClassCastException for Era: " + era);
343 } catch (ClassCastException cex) {
344 ; // ignore expected exception
345 }
346
347 }
348 }
349 }
350
351 //-----------------------------------------------------------------------
352 // get(TemporalField)
353 //-----------------------------------------------------------------------
354 @Test
355 public void test_getLong() {
356 JapaneseDate base = JapaneseChronology.INSTANCE.date(JapaneseEra.SHOWA, 63, 6, 30);
357 assertEquals(base.getLong(ERA), JapaneseEra.SHOWA.getValue());
358 assertEquals(base.getLong(YEAR), 1988L);
371 assertEquals(test, JapaneseChronology.INSTANCE.date(JapaneseEra.SHOWA, 62, 6, 30));
372
373 test = test.with(YEAR_OF_ERA, 2);
374 assertEquals(test, JapaneseChronology.INSTANCE.date(JapaneseEra.SHOWA, 2, 6, 30));
375
376 test = test.with(ERA, JapaneseEra.HEISEI.getValue());
377 assertEquals(test, JapaneseChronology.INSTANCE.date(JapaneseEra.HEISEI, 2, 6, 30));
378
379 test = test.with(MONTH_OF_YEAR, 3);
380 assertEquals(test, JapaneseChronology.INSTANCE.date(JapaneseEra.HEISEI, 2, 3, 30));
381
382 test = test.with(DAY_OF_MONTH, 4);
383 assertEquals(test, JapaneseChronology.INSTANCE.date(JapaneseEra.HEISEI, 2, 3, 4));
384 }
385
386 //-----------------------------------------------------------------------
387 // with(WithAdjuster)
388 //-----------------------------------------------------------------------
389 @Test
390 public void test_adjust1() {
391 JapaneseDate base = JapaneseChronology.INSTANCE.date(1728, 10, 29);
392 JapaneseDate test = base.with(TemporalAdjuster.lastDayOfMonth());
393 assertEquals(test, JapaneseChronology.INSTANCE.date(1728, 10, 31));
394 }
395
396 @Test
397 public void test_adjust2() {
398 JapaneseDate base = JapaneseChronology.INSTANCE.date(1728, 12, 2);
399 JapaneseDate test = base.with(TemporalAdjuster.lastDayOfMonth());
400 assertEquals(test, JapaneseChronology.INSTANCE.date(1728, 12, 31));
401 }
402
403 //-----------------------------------------------------------------------
404 // JapaneseDate.with(Local*)
405 //-----------------------------------------------------------------------
406 @Test
407 public void test_adjust_toLocalDate() {
408 JapaneseDate jdate = JapaneseChronology.INSTANCE.date(1726, 1, 4);
409 JapaneseDate test = jdate.with(LocalDate.of(2012, 7, 6));
410 assertEquals(test, JapaneseChronology.INSTANCE.date(2012, 7, 6));
411 }
412
413 @Test(expectedExceptions=DateTimeException.class)
414 public void test_adjust_toMonth() {
415 JapaneseDate jdate = JapaneseChronology.INSTANCE.date(1726, 1, 4);
416 jdate.with(Month.APRIL);
417 }
418
419 //-----------------------------------------------------------------------
420 // LocalDate.with(JapaneseDate)
421 //-----------------------------------------------------------------------
422 @Test
423 public void test_LocalDate_adjustToJapaneseDate() {
424 JapaneseDate jdate = JapaneseChronology.INSTANCE.date(1728, 10, 29);
425 LocalDate test = LocalDate.MIN.with(jdate);
426 assertEquals(test, LocalDate.of(1728, 10, 29));
427 }
428
429 @Test
430 public void test_LocalDateTime_adjustToJapaneseDate() {
431 JapaneseDate jdate = JapaneseChronology.INSTANCE.date(1728, 10, 29);
432 LocalDateTime test = LocalDateTime.MIN.with(jdate);
433 assertEquals(test, LocalDateTime.of(1728, 10, 29, 0, 0));
434 }
435
436 //-----------------------------------------------------------------------
437 // Check Japanese Eras
438 //-----------------------------------------------------------------------
439 @DataProvider(name="japaneseEras")
440 Object[][] data_japanseseEras() {
441 return new Object[][] {
442 { JapaneseEra.SEIREKI, -999, "Seireki"},
443 { JapaneseEra.MEIJI, -1, "Meiji"},
444 { JapaneseEra.TAISHO, 0, "Taisho"},
445 { JapaneseEra.SHOWA, 1, "Showa"},
446 { JapaneseEra.HEISEI, 2, "Heisei"},
447 };
448 }
449
450 @Test(dataProvider="japaneseEras")
451 public void test_Japanese_Eras(Era era, int eraValue, String name) {
452 assertEquals(era.getValue(), eraValue, "EraValue");
453 assertEquals(era.toString(), name, "Era Name");
454 assertEquals(era, JapaneseChronology.INSTANCE.eraOf(eraValue), "JapaneseChronology.eraOf()");
455 List<Era> eras = JapaneseChronology.INSTANCE.eras();
456 assertTrue(eras.contains(era), "Era is not present in JapaneseChronology.INSTANCE.eras()");
457 }
458
459 @Test
460 public void test_Japanese_badEras() {
461 int badEras[] = {-1000, -998, -997, -2, 3, 4, 1000};
462 for (int badEra : badEras) {
495
496 @Test
497 public void test_JapaneseChronology_eras() {
498 List<Era> actualEras = JapaneseChronology.INSTANCE.eras();
499 Object[][] erasInfo = data_japanseseEras();
500 assertEquals(actualEras.size(), erasInfo.length, "Wrong number of Eras");
501
502 for (int i = 0; i < erasInfo.length; i++) {
503 Object[] eraInfo = erasInfo[i];
504 assertEquals(actualEras.get(i), eraInfo[0], "Singleton mismatch");
505 }
506 }
507
508 //-----------------------------------------------------------------------
509 // PeriodUntil()
510 //-----------------------------------------------------------------------
511 @Test
512 public void test_periodUntilDate() {
513 JapaneseDate mdate1 = JapaneseDate.of(1970, 1, 1);
514 JapaneseDate mdate2 = JapaneseDate.of(1971, 2, 2);
515 Period period = mdate1.periodUntil(mdate2);
516 assertEquals(period, Period.of(1, 1, 1));
517 }
518
519 @Test
520 public void test_periodUntilUnit() {
521 JapaneseDate mdate1 = JapaneseDate.of(1970, 1, 1);
522 JapaneseDate mdate2 = JapaneseDate.of(1971, 2, 2);
523 long months = mdate1.periodUntil(mdate2, ChronoUnit.MONTHS);
524 assertEquals(months, 13);
525 }
526
527 @Test
528 public void test_periodUntilDiffChrono() {
529 JapaneseDate mdate1 = JapaneseDate.of(1970, 1, 1);
530 JapaneseDate mdate2 = JapaneseDate.of(1971, 2, 2);
531 MinguoDate ldate2 = MinguoChronology.INSTANCE.date(mdate2);
532 Period period = mdate1.periodUntil(ldate2);
533 assertEquals(period, Period.of(1, 1, 1));
534 }
535
536 //-----------------------------------------------------------------------
537 // toString()
538 //-----------------------------------------------------------------------
539 @DataProvider(name="toString")
540 Object[][] data_toString() {
541 return new Object[][] {
542 {JapaneseChronology.INSTANCE.date(0001, 1, 1), "Japanese 0001-01-01"},
543 {JapaneseChronology.INSTANCE.date(1728, 10, 28), "Japanese 1728-10-28"},
544 {JapaneseChronology.INSTANCE.date(1728, 10, 29), "Japanese 1728-10-29"},
545 {JapaneseChronology.INSTANCE.date(1727, 12, 5), "Japanese 1727-12-05"},
546 {JapaneseChronology.INSTANCE.date(1727, 12, 6), "Japanese 1727-12-06"},
547 {JapaneseChronology.INSTANCE.date(1868, 9, 8), "Japanese Meiji 1-09-08"},
548 {JapaneseChronology.INSTANCE.date(1912, 7, 29), "Japanese Meiji 45-07-29"},
549 {JapaneseChronology.INSTANCE.date(1912, 7, 30), "Japanese Taisho 1-07-30"},
550 {JapaneseChronology.INSTANCE.date(1926, 12, 24), "Japanese Taisho 15-12-24"},
551 {JapaneseChronology.INSTANCE.date(1926, 12, 25), "Japanese Showa 1-12-25"},
552 {JapaneseChronology.INSTANCE.date(1989, 1, 7), "Japanese Showa 64-01-07"},
553 {JapaneseChronology.INSTANCE.date(1989, 1, 8), "Japanese Heisei 1-01-08"},
554 {JapaneseChronology.INSTANCE.date(2012, 12, 6), "Japanese Heisei 24-12-06"},
555 };
556 }
557
558 @Test(dataProvider="toString")
559 public void test_toString(JapaneseDate jdate, String expected) {
560 assertEquals(jdate.toString(), expected);
561 }
562
563 //-----------------------------------------------------------------------
564 // equals()
565 //-----------------------------------------------------------------------
566 @Test
567 public void test_equals_true() {
568 assertTrue(JapaneseChronology.INSTANCE.equals(JapaneseChronology.INSTANCE));
569 }
570
571 @Test
572 public void test_equals_false() {
573 assertFalse(JapaneseChronology.INSTANCE.equals(IsoChronology.INSTANCE));
574 }
575
576 }
|
40 *
41 * * Neither the name of JSR-310 nor the names of its contributors
42 * may be used to endorse or promote products derived from this software
43 * without specific prior written permission.
44 *
45 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
46 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
47 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
48 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
49 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
50 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
51 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
52 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
53 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
54 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
55 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
56 */
57 package tck.java.time.chrono;
58
59 import static java.time.temporal.ChronoField.DAY_OF_MONTH;
60 import static java.time.temporal.ChronoField.DAY_OF_YEAR;
61 import static java.time.temporal.ChronoField.EPOCH_DAY;
62 import static java.time.temporal.ChronoField.ERA;
63 import static java.time.temporal.ChronoField.MONTH_OF_YEAR;
64 import static java.time.temporal.ChronoField.YEAR;
65 import static java.time.temporal.ChronoField.YEAR_OF_ERA;
66 import static org.testng.Assert.assertEquals;
67 import static org.testng.Assert.assertFalse;
68 import static org.testng.Assert.assertNotEquals;
69 import static org.testng.Assert.assertTrue;
70 import static org.testng.Assert.fail;
71
72 import java.time.Clock;
73 import java.time.DateTimeException;
74 import java.time.LocalDate;
75 import java.time.LocalDateTime;
76 import java.time.Month;
77 import java.time.Period;
78 import java.time.Year;
79 import java.time.ZoneId;
80 import java.time.ZoneOffset;
81 import java.time.chrono.ChronoLocalDate;
82 import java.time.chrono.Chronology;
83 import java.time.chrono.Era;
84 import java.time.chrono.IsoChronology;
85 import java.time.chrono.JapaneseChronology;
86 import java.time.chrono.JapaneseDate;
87 import java.time.chrono.JapaneseEra;
88 import java.time.chrono.MinguoChronology;
89 import java.time.chrono.MinguoDate;
90 import java.time.format.ResolverStyle;
91 import java.time.temporal.ChronoField;
92 import java.time.temporal.ChronoUnit;
93 import java.time.temporal.Temporal;
94 import java.time.temporal.TemporalAdjuster;
95 import java.time.temporal.TemporalField;
96 import java.time.temporal.TemporalQuery;
97 import java.time.temporal.ValueRange;
98
99 import java.util.HashMap;
100 import java.util.List;
101 import java.util.Locale;
102 import java.util.Map;
103
104 import org.testng.Assert;
105 import org.testng.annotations.DataProvider;
106 import org.testng.annotations.Test;
107
108 /**
109 * Test.
110 */
111 @Test
112 public class TCKJapaneseChronology {
113 private static final int YDIFF_HEISEI = 1988;
114 private static final int YDIFF_MEIJI = 1867;
115 private static final int YDIFF_SHOWA = 1925;
116 private static final int YDIFF_TAISHO = 1911;
117
118 //-----------------------------------------------------------------------
119 // Chronology.of(String)
120 //-----------------------------------------------------------------------
121 @Test
122 public void test_chrono_byName() {
150 Chronology test = Chronology.ofLocale(new Locale("ja", "JP"));
151 Assert.assertEquals(test.getId(), "ISO");
152 Assert.assertEquals(test, IsoChronology.INSTANCE);
153 }
154
155 @Test
156 public void test_chrono_byLocale_oldJP_variant() {
157 Chronology test = Chronology.ofLocale(new Locale("ja", "JP", "JP"));
158 Assert.assertEquals(test.getId(), "Japanese");
159 Assert.assertEquals(test, JapaneseChronology.INSTANCE);
160 }
161
162 @Test
163 public void test_chrono_byLocale_iso() {
164 Assert.assertEquals(Chronology.ofLocale(new Locale("ja", "JP")).getId(), "ISO");
165 Assert.assertEquals(Chronology.ofLocale(Locale.forLanguageTag("ja-JP")).getId(), "ISO");
166 Assert.assertEquals(Chronology.ofLocale(Locale.forLanguageTag("ja-JP-JP")).getId(), "ISO");
167 }
168
169 //-----------------------------------------------------------------------
170 // creation and cross-checks
171 //-----------------------------------------------------------------------
172 @DataProvider(name="createByEra")
173 Object[][] data_createByEra() {
174 return new Object[][] {
175 {JapaneseEra.HEISEI, 1996 - YDIFF_HEISEI, 2, 29, 60, LocalDate.of(1996, 2, 29)},
176 {JapaneseEra.HEISEI, 2000 - YDIFF_HEISEI, 2, 29, 60, LocalDate.of(2000, 2, 29)},
177 {JapaneseEra.MEIJI, 1874 - YDIFF_MEIJI, 2, 28, 59, LocalDate.of(1874, 2, 28)},
178 {JapaneseEra.SHOWA, 1928 - YDIFF_SHOWA, 12, 25, 360, LocalDate.of(1928, 12, 25)},
179 {JapaneseEra.TAISHO, 1916 - YDIFF_TAISHO, 7, 30, 212, LocalDate.of(1916, 7, 30)},
180 {JapaneseEra.MEIJI, 6, 1, 1, 1, LocalDate.of(1873, 1, 1)},
181 {JapaneseEra.MEIJI, 45, 7, 29, 211, LocalDate.of(1912, 7, 29)},
182 {JapaneseEra.TAISHO, 1, 7, 30, 1, LocalDate.of(1912, 7, 30)},
183 {JapaneseEra.TAISHO, 15, 12, 24, 358, LocalDate.of(1926, 12, 24)},
184 {JapaneseEra.SHOWA, 1, 12, 25, 1, LocalDate.of(1926, 12, 25)},
185 {JapaneseEra.SHOWA, 64, 1, 7, 7, LocalDate.of(1989, 1, 7)},
186 {JapaneseEra.HEISEI, 1, 1, 8, 1, LocalDate.of(1989, 1, 8)},
187 };
188 }
189
190 @Test(dataProvider="createByEra")
191 public void test_createEymd(JapaneseEra era, int yoe, int moy, int dom, int doy, LocalDate iso) {
192 JapaneseDate dateByChronoFactory = JapaneseChronology.INSTANCE.date(era, yoe, moy, dom);
193 JapaneseDate dateByDateFactory = JapaneseDate.of(era, yoe, moy, dom);
194 assertEquals(dateByChronoFactory, dateByDateFactory);
195 assertEquals(dateByChronoFactory.hashCode(), dateByDateFactory.hashCode());
196 }
197
198 @Test(dataProvider="createByEra")
199 public void test_createEyd(JapaneseEra era, int yoe, int moy, int dom, int doy, LocalDate iso) {
200 JapaneseDate dateByChronoFactory = JapaneseChronology.INSTANCE.dateYearDay(era, yoe, doy);
201 JapaneseDate dateByDateFactory = JapaneseDate.of(era, yoe, moy, dom);
202 assertEquals(dateByChronoFactory, dateByDateFactory);
203 assertEquals(dateByChronoFactory.hashCode(), dateByDateFactory.hashCode());
204 }
205
206 @Test(dataProvider="createByEra")
207 public void test_createByEra_isEqual(JapaneseEra era, int yoe, int moy, int dom, int doy, LocalDate iso) {
208 JapaneseDate test = JapaneseDate.of(era, yoe, moy, dom);
209 assertEquals(test.isEqual(iso), true);
210 assertEquals(iso.isEqual(test), true);
211 }
212
213 @Test(dataProvider="createByEra")
214 public void test_createByEra_chronologyTemporalFactory(JapaneseEra era, int yoe, int moy, int dom, int doy, LocalDate iso) {
215 JapaneseDate test = JapaneseDate.of(era, yoe, moy, dom);
216 assertEquals(IsoChronology.INSTANCE.date(test), iso);
217 assertEquals(JapaneseChronology.INSTANCE.date(iso), test);
218 }
219
220 @Test(dataProvider="createByEra")
221 public void test_createByEra_dateFrom(JapaneseEra era, int yoe, int moy, int dom, int doy, LocalDate iso) {
222 JapaneseDate test = JapaneseDate.of(era, yoe, moy, dom);
223 assertEquals(LocalDate.from(test), iso);
224 assertEquals(JapaneseDate.from(iso), test);
225 }
226
227 @Test(dataProvider="createByEra")
228 public void test_createByEra_query(JapaneseEra era, int yoe, int moy, int dom, int doy, LocalDate iso) {
229 JapaneseDate test = JapaneseDate.of(era, yoe, moy, dom);
230 assertEquals(test.query(TemporalQuery.localDate()), iso);
231 }
232
233 @Test(dataProvider="createByEra")
234 public void test_createByEra_epochDay(JapaneseEra era, int yoe, int moy, int dom, int doy, LocalDate iso) {
235 JapaneseDate test = JapaneseDate.of(era, yoe, moy, dom);
236 assertEquals(test.getLong(EPOCH_DAY), iso.getLong(EPOCH_DAY));
237 assertEquals(test.toEpochDay(), iso.toEpochDay());
238 }
239
240 //-----------------------------------------------------------------------
241 @DataProvider(name="createByProleptic")
242 Object[][] data_createByProleptic() {
243 return new Object[][] {
244 {1928, 2, 28, 59, LocalDate.of(1928, 2, 28)},
245 {1928, 2, 29, 60, LocalDate.of(1928, 2, 29)},
246
247 {1873, 9, 7, 250, LocalDate.of(1873, 9, 7)},
248 {1873, 9, 8, 251, LocalDate.of(1873, 9, 8)},
249 {1912, 7, 29, 211, LocalDate.of(1912, 7, 29)},
250 {1912, 7, 30, 212, LocalDate.of(1912, 7, 30)},
251 {1926, 12, 24, 358, LocalDate.of(1926, 12, 24)},
252 {1926, 12, 25, 359, LocalDate.of(1926, 12, 25)},
253 {1989, 1, 7, 7, LocalDate.of(1989, 1, 7)},
254 {1989, 1, 8, 8, LocalDate.of(1989, 1, 8)},
255 };
256 }
257
258 @Test(dataProvider="createByProleptic")
259 public void test_createYmd(int y, int moy, int dom, int doy, LocalDate iso) {
260 JapaneseDate dateByChronoFactory = JapaneseChronology.INSTANCE.date(y, moy, dom);
261 JapaneseDate dateByDateFactory = JapaneseDate.of(y, moy, dom);
262 assertEquals(dateByChronoFactory, dateByDateFactory);
263 assertEquals(dateByChronoFactory.hashCode(), dateByDateFactory.hashCode());
264 }
265
266 @Test(dataProvider="createByProleptic")
267 public void test_createYd(int y, int moy, int dom, int doy, LocalDate iso) {
268 JapaneseDate dateByChronoFactory = JapaneseChronology.INSTANCE.dateYearDay(y, doy);
269 JapaneseDate dateByDateFactory = JapaneseDate.of(y, moy, dom);
270 assertEquals(dateByChronoFactory, dateByDateFactory);
271 assertEquals(dateByChronoFactory.hashCode(), dateByDateFactory.hashCode());
272 }
273
274 @Test(dataProvider="createByProleptic")
275 public void test_createByProleptic_isEqual(int y, int moy, int dom, int doy, LocalDate iso) {
276 JapaneseDate test = JapaneseDate.of(y, moy, dom);
277 assertEquals(test.isEqual(iso), true);
278 assertEquals(iso.isEqual(test), true);
279 }
280
281 @Test(dataProvider="createByProleptic")
282 public void test_createByProleptic_chronologyTemporalFactory(int y, int moy, int dom, int doy, LocalDate iso) {
283 JapaneseDate test = JapaneseDate.of(y, moy, dom);
284 assertEquals(IsoChronology.INSTANCE.date(test), iso);
285 assertEquals(JapaneseChronology.INSTANCE.date(iso), test);
286 }
287
288 @Test(dataProvider="createByProleptic")
289 public void test_createByProleptic_dateFrom(int y, int moy, int dom, int doy, LocalDate iso) {
290 JapaneseDate test = JapaneseDate.of(y, moy, dom);
291 assertEquals(LocalDate.from(test), iso);
292 assertEquals(JapaneseDate.from(iso), test);
293 }
294
295 @Test(dataProvider="createByProleptic")
296 public void test_createByProleptic_query(int y, int moy, int dom, int doy, LocalDate iso) {
297 JapaneseDate test = JapaneseDate.of(y, moy, dom);
298 assertEquals(test.query(TemporalQuery.localDate()), iso);
299 }
300
301 @Test(dataProvider="createByProleptic")
302 public void test_createByProleptic_epochDay(int y, int moy, int dom, int doy, LocalDate iso) {
303 JapaneseDate test = JapaneseDate.of(y, moy, dom);
304 assertEquals(test.getLong(EPOCH_DAY), iso.getLong(EPOCH_DAY));
305 assertEquals(test.toEpochDay(), iso.toEpochDay());
306 }
307
308 //-----------------------------------------------------------------------
309 @Test
310 public void test_dateNow(){
311 assertEquals(JapaneseChronology.INSTANCE.dateNow(), JapaneseDate.now()) ;
312 assertEquals(JapaneseChronology.INSTANCE.dateNow(), JapaneseDate.now(ZoneId.systemDefault())) ;
313 assertEquals(JapaneseChronology.INSTANCE.dateNow(), JapaneseDate.now(Clock.systemDefaultZone())) ;
314 assertEquals(JapaneseChronology.INSTANCE.dateNow(), JapaneseDate.now(Clock.systemDefaultZone().getZone())) ;
315
316 assertEquals(JapaneseChronology.INSTANCE.dateNow(), JapaneseChronology.INSTANCE.dateNow(ZoneId.systemDefault())) ;
317 assertEquals(JapaneseChronology.INSTANCE.dateNow(), JapaneseChronology.INSTANCE.dateNow(Clock.systemDefaultZone())) ;
318 assertEquals(JapaneseChronology.INSTANCE.dateNow(), JapaneseChronology.INSTANCE.dateNow(Clock.systemDefaultZone().getZone())) ;
319
320 ZoneId zoneId = ZoneId.of("Europe/Paris");
321 assertEquals(JapaneseChronology.INSTANCE.dateNow(zoneId), JapaneseChronology.INSTANCE.dateNow(Clock.system(zoneId))) ;
322 assertEquals(JapaneseChronology.INSTANCE.dateNow(zoneId), JapaneseChronology.INSTANCE.dateNow(Clock.system(zoneId).getZone())) ;
323 assertEquals(JapaneseChronology.INSTANCE.dateNow(zoneId), JapaneseDate.now(Clock.system(zoneId))) ;
324 assertEquals(JapaneseChronology.INSTANCE.dateNow(zoneId), JapaneseDate.now(Clock.system(zoneId).getZone())) ;
325
326 assertEquals(JapaneseChronology.INSTANCE.dateNow(ZoneId.of(ZoneOffset.UTC.getId())), JapaneseChronology.INSTANCE.dateNow(Clock.systemUTC())) ;
327 }
328
329 //-----------------------------------------------------------------------
330 @DataProvider(name="badDates")
331 Object[][] data_badDates() {
332 return new Object[][] {
333 {1928, 0, 0},
334
335 {1928, -1, 1},
336 {1928, 0, 1},
337 {1928, 14, 1},
338 {1928, 15, 1},
339
340 {1928, 1, -1},
341 {1928, 1, 0},
342 {1928, 1, 32},
343
344 {1928, 12, -1},
345 {1928, 12, 0},
346 {1928, 12, 32},
347
348 {1725, 2, 29},
349 {500, 2, 29},
350 {2100, 2, 29},
351
352 {1872, 12, 31}, // Last day of MEIJI 5
353 };
354 }
355
356 @Test(dataProvider="badDates", expectedExceptions=DateTimeException.class)
357 public void test_badDates(int year, int month, int dom) {
358 JapaneseChronology.INSTANCE.date(year, month, dom);
359 }
360
361 //-----------------------------------------------------------------------
362 // prolepticYear() and is LeapYear()
363 //-----------------------------------------------------------------------
364 @DataProvider(name="prolepticYear")
365 Object[][] data_prolepticYear() {
366 return new Object[][] {
367 {2, JapaneseEra.HEISEI, 1, 1 + YDIFF_HEISEI, false},
368 {2, JapaneseEra.HEISEI, 100, 100 + YDIFF_HEISEI, true},
369
370 {-1, JapaneseEra.MEIJI, 9, 9 + YDIFF_MEIJI, true},
371 {-1, JapaneseEra.MEIJI, 10, 10 + YDIFF_MEIJI, false},
372
373 {1, JapaneseEra.SHOWA, 1, 1 + YDIFF_SHOWA, false},
374 {1, JapaneseEra.SHOWA, 7, 7 + YDIFF_SHOWA, true},
375
376 {0, JapaneseEra.TAISHO, 1, 1 + YDIFF_TAISHO, true},
377 {0, JapaneseEra.TAISHO, 4, 4 + YDIFF_TAISHO, false},
378 };
379 }
380
381 @Test(dataProvider="prolepticYear")
382 public void test_prolepticYear(int eraValue, Era era, int yearOfEra, int expectedProlepticYear, boolean isLeapYear) {
383 Era eraObj = JapaneseChronology.INSTANCE.eraOf(eraValue);
384 assertTrue(JapaneseChronology.INSTANCE.eras().contains(eraObj));
385 assertEquals(eraObj, era);
386 assertEquals(JapaneseChronology.INSTANCE.prolepticYear(era, yearOfEra), expectedProlepticYear);
387 }
388
389 @Test(dataProvider="prolepticYear")
390 public void test_isLeapYear(int eraValue, Era era, int yearOfEra, int expectedProlepticYear, boolean isLeapYear) {
391 assertEquals(JapaneseChronology.INSTANCE.isLeapYear(expectedProlepticYear), isLeapYear);
392 assertEquals(JapaneseChronology.INSTANCE.isLeapYear(expectedProlepticYear), Year.of(expectedProlepticYear).isLeap());
393
394 JapaneseDate jdate = JapaneseDate.now();
395 jdate = jdate.with(ChronoField.YEAR, expectedProlepticYear).with(ChronoField.MONTH_OF_YEAR, 2);
396 if (isLeapYear) {
397 assertEquals(jdate.lengthOfMonth(), 29);
398 } else {
399 assertEquals(jdate.lengthOfMonth(), 28);
400 }
401 }
402
403 @DataProvider(name="prolepticYearError")
404 Object[][] data_prolepticYearError() {
405 return new Object[][] {
406 {JapaneseEra.MEIJI, 100},
407 {JapaneseEra.MEIJI, 0},
408 {JapaneseEra.MEIJI, -10},
409
410 {JapaneseEra.SHOWA, 100},
411 {JapaneseEra.SHOWA, 0},
412 {JapaneseEra.SHOWA, -10},
413
414 {JapaneseEra.TAISHO, 100},
415 {JapaneseEra.TAISHO, 0},
416 {JapaneseEra.TAISHO, -10},
417 };
418 }
419
420 @Test(dataProvider="prolepticYearError", expectedExceptions=DateTimeException.class)
423 }
424
425 //-----------------------------------------------------------------------
426 // Bad Era for Chronology.date(era,...) and Chronology.prolepticYear(Era,...)
427 //-----------------------------------------------------------------------
428 @Test
429 public void test_InvalidEras() {
430 // Verify that the eras from every other Chronology are invalid
431 for (Chronology chrono : Chronology.getAvailableChronologies()) {
432 if (chrono instanceof JapaneseChronology) {
433 continue;
434 }
435 List<Era> eras = chrono.eras();
436 for (Era era : eras) {
437 try {
438 ChronoLocalDate date = JapaneseChronology.INSTANCE.date(era, 1, 1, 1);
439 fail("JapaneseChronology.date did not throw ClassCastException for Era: " + era);
440 } catch (ClassCastException cex) {
441 ; // ignore expected exception
442 }
443 try {
444 @SuppressWarnings("unused")
445 int year = JapaneseChronology.INSTANCE.prolepticYear(era, 1);
446 fail("JapaneseChronology.prolepticYear did not throw ClassCastException for Era: " + era);
447 } catch (ClassCastException cex) {
448 ; // ignore expected exception
449 }
450
451 }
452 }
453 }
454
455 //-----------------------------------------------------------------------
456 // get(TemporalField)
457 //-----------------------------------------------------------------------
458 @Test
459 public void test_getLong() {
460 JapaneseDate base = JapaneseChronology.INSTANCE.date(JapaneseEra.SHOWA, 63, 6, 30);
461 assertEquals(base.getLong(ERA), JapaneseEra.SHOWA.getValue());
462 assertEquals(base.getLong(YEAR), 1988L);
475 assertEquals(test, JapaneseChronology.INSTANCE.date(JapaneseEra.SHOWA, 62, 6, 30));
476
477 test = test.with(YEAR_OF_ERA, 2);
478 assertEquals(test, JapaneseChronology.INSTANCE.date(JapaneseEra.SHOWA, 2, 6, 30));
479
480 test = test.with(ERA, JapaneseEra.HEISEI.getValue());
481 assertEquals(test, JapaneseChronology.INSTANCE.date(JapaneseEra.HEISEI, 2, 6, 30));
482
483 test = test.with(MONTH_OF_YEAR, 3);
484 assertEquals(test, JapaneseChronology.INSTANCE.date(JapaneseEra.HEISEI, 2, 3, 30));
485
486 test = test.with(DAY_OF_MONTH, 4);
487 assertEquals(test, JapaneseChronology.INSTANCE.date(JapaneseEra.HEISEI, 2, 3, 4));
488 }
489
490 //-----------------------------------------------------------------------
491 // with(WithAdjuster)
492 //-----------------------------------------------------------------------
493 @Test
494 public void test_adjust1() {
495 JapaneseDate base = JapaneseChronology.INSTANCE.date(1928, 10, 29);
496 JapaneseDate test = base.with(TemporalAdjuster.lastDayOfMonth());
497 assertEquals(test, JapaneseChronology.INSTANCE.date(1928, 10, 31));
498 }
499
500 @Test
501 public void test_adjust2() {
502 JapaneseDate base = JapaneseChronology.INSTANCE.date(1928, 12, 2);
503 JapaneseDate test = base.with(TemporalAdjuster.lastDayOfMonth());
504 assertEquals(test, JapaneseChronology.INSTANCE.date(1928, 12, 31));
505 }
506
507 //-----------------------------------------------------------------------
508 // JapaneseDate.with(Local*)
509 //-----------------------------------------------------------------------
510 @Test
511 public void test_adjust_toLocalDate() {
512 JapaneseDate jdate = JapaneseChronology.INSTANCE.date(1926, 1, 4);
513 JapaneseDate test = jdate.with(LocalDate.of(2012, 7, 6));
514 assertEquals(test, JapaneseChronology.INSTANCE.date(2012, 7, 6));
515 }
516
517 @Test(expectedExceptions=DateTimeException.class)
518 public void test_adjust_toMonth() {
519 JapaneseDate jdate = JapaneseChronology.INSTANCE.date(1926, 1, 4);
520 jdate.with(Month.APRIL);
521 }
522
523 //-----------------------------------------------------------------------
524 // LocalDate.with(JapaneseDate)
525 //-----------------------------------------------------------------------
526 @Test
527 public void test_LocalDate_adjustToJapaneseDate() {
528 JapaneseDate jdate = JapaneseChronology.INSTANCE.date(1928, 10, 29);
529 LocalDate test = LocalDate.MIN.with(jdate);
530 assertEquals(test, LocalDate.of(1928, 10, 29));
531 }
532
533 @Test
534 public void test_LocalDateTime_adjustToJapaneseDate() {
535 JapaneseDate jdate = JapaneseChronology.INSTANCE.date(1928, 10, 29);
536 LocalDateTime test = LocalDateTime.MIN.with(jdate);
537 assertEquals(test, LocalDateTime.of(1928, 10, 29, 0, 0));
538 }
539
540 //-----------------------------------------------------------------------
541 // Check Japanese Eras
542 //-----------------------------------------------------------------------
543 @DataProvider(name="japaneseEras")
544 Object[][] data_japanseseEras() {
545 return new Object[][] {
546 { JapaneseEra.MEIJI, -1, "Meiji"},
547 { JapaneseEra.TAISHO, 0, "Taisho"},
548 { JapaneseEra.SHOWA, 1, "Showa"},
549 { JapaneseEra.HEISEI, 2, "Heisei"},
550 };
551 }
552
553 @Test(dataProvider="japaneseEras")
554 public void test_Japanese_Eras(Era era, int eraValue, String name) {
555 assertEquals(era.getValue(), eraValue, "EraValue");
556 assertEquals(era.toString(), name, "Era Name");
557 assertEquals(era, JapaneseChronology.INSTANCE.eraOf(eraValue), "JapaneseChronology.eraOf()");
558 List<Era> eras = JapaneseChronology.INSTANCE.eras();
559 assertTrue(eras.contains(era), "Era is not present in JapaneseChronology.INSTANCE.eras()");
560 }
561
562 @Test
563 public void test_Japanese_badEras() {
564 int badEras[] = {-1000, -998, -997, -2, 3, 4, 1000};
565 for (int badEra : badEras) {
598
599 @Test
600 public void test_JapaneseChronology_eras() {
601 List<Era> actualEras = JapaneseChronology.INSTANCE.eras();
602 Object[][] erasInfo = data_japanseseEras();
603 assertEquals(actualEras.size(), erasInfo.length, "Wrong number of Eras");
604
605 for (int i = 0; i < erasInfo.length; i++) {
606 Object[] eraInfo = erasInfo[i];
607 assertEquals(actualEras.get(i), eraInfo[0], "Singleton mismatch");
608 }
609 }
610
611 //-----------------------------------------------------------------------
612 // PeriodUntil()
613 //-----------------------------------------------------------------------
614 @Test
615 public void test_periodUntilDate() {
616 JapaneseDate mdate1 = JapaneseDate.of(1970, 1, 1);
617 JapaneseDate mdate2 = JapaneseDate.of(1971, 2, 2);
618 Period period = mdate1.until(mdate2);
619 assertEquals(period, Period.of(1, 1, 1));
620 }
621
622 @Test
623 public void test_periodUntilUnit() {
624 JapaneseDate mdate1 = JapaneseDate.of(1970, 1, 1);
625 JapaneseDate mdate2 = JapaneseDate.of(1971, 2, 2);
626 long months = mdate1.until(mdate2, ChronoUnit.MONTHS);
627 assertEquals(months, 13);
628 }
629
630 @Test
631 public void test_periodUntilDiffChrono() {
632 JapaneseDate mdate1 = JapaneseDate.of(1970, 1, 1);
633 JapaneseDate mdate2 = JapaneseDate.of(1971, 2, 2);
634 MinguoDate ldate2 = MinguoChronology.INSTANCE.date(mdate2);
635 Period period = mdate1.until(ldate2);
636 assertEquals(period, Period.of(1, 1, 1));
637 }
638
639 //-----------------------------------------------------------------------
640 // JapaneseChronology.dateYearDay, getDayOfYear
641 //-----------------------------------------------------------------------
642 @Test
643 public void test_getDayOfYear() {
644 // Test all the Eras
645 for (JapaneseEra era : JapaneseEra.values()) {
646 int firstYear = (era == JapaneseEra.MEIJI) ? 6 : 1; // Until Era supports range(YEAR_OF_ERA)
647 JapaneseDate hd1 = JapaneseChronology.INSTANCE.dateYearDay(era, firstYear, 1);
648 ValueRange range = hd1.range(DAY_OF_YEAR);
649 assertEquals(range.getMaximum(), hd1.lengthOfYear(), "lengthOfYear should match range.getMaximum()");
650
651 for (int i = 1; i <= hd1.lengthOfYear(); i++) {
652 JapaneseDate hd = JapaneseChronology.INSTANCE.dateYearDay(era, firstYear, i);
653 int doy = hd.get(DAY_OF_YEAR);
654 assertEquals(doy, i, "get(DAY_OF_YEAR) incorrect for " + i + ", of date: " + hd);
655 }
656 }
657 }
658
659 @Test
660 public void test_withDayOfYear() {
661 JapaneseDate hd = JapaneseChronology.INSTANCE.dateYearDay(1990, 1);
662 for (int i = 1; i <= hd.lengthOfYear(); i++) {
663 JapaneseDate hd2 = hd.with(DAY_OF_YEAR, i);
664 int doy = hd2.get(DAY_OF_YEAR);
665 assertEquals(doy, i, "with(DAY_OF_YEAR) incorrect for " + i + " " + hd2);
666 }
667 }
668
669 //-----------------------------------------------------------------------
670 // toString()
671 //-----------------------------------------------------------------------
672 @DataProvider(name="toString")
673 Object[][] data_toString() {
674 return new Object[][] {
675 {JapaneseChronology.INSTANCE.date(1873, 12, 5), "Japanese Meiji 6-12-05"},
676 {JapaneseChronology.INSTANCE.date(1873, 12, 6), "Japanese Meiji 6-12-06"},
677 {JapaneseChronology.INSTANCE.date(1873, 9, 8), "Japanese Meiji 6-09-08"},
678 {JapaneseChronology.INSTANCE.date(1912, 7, 29), "Japanese Meiji 45-07-29"},
679 {JapaneseChronology.INSTANCE.date(1912, 7, 30), "Japanese Taisho 1-07-30"},
680 {JapaneseChronology.INSTANCE.date(1926, 12, 24), "Japanese Taisho 15-12-24"},
681 {JapaneseChronology.INSTANCE.date(1926, 12, 25), "Japanese Showa 1-12-25"},
682 {JapaneseChronology.INSTANCE.date(1989, 1, 7), "Japanese Showa 64-01-07"},
683 {JapaneseChronology.INSTANCE.date(1989, 1, 8), "Japanese Heisei 1-01-08"},
684 {JapaneseChronology.INSTANCE.date(2012, 12, 6), "Japanese Heisei 24-12-06"},
685 };
686 }
687
688 @Test(dataProvider="toString")
689 public void test_toString(JapaneseDate jdate, String expected) {
690 assertEquals(jdate.toString(), expected);
691 }
692
693 //-----------------------------------------------------------------------
694 // equals()
695 //-----------------------------------------------------------------------
696 @Test
697 public void test_equals_true() {
698 assertTrue(JapaneseChronology.INSTANCE.equals(JapaneseChronology.INSTANCE));
699 }
700
701 @Test
702 public void test_equals_false() {
703 assertFalse(JapaneseChronology.INSTANCE.equals(IsoChronology.INSTANCE));
704 }
705
706 //-----------------------------------------------------------------------
707 //-----------------------------------------------------------------------
708 @DataProvider(name = "resolve_styleByEra")
709 Object[][] data_resolve_styleByEra() {
710 Object[][] result = new Object[ResolverStyle.values().length * JapaneseEra.values().length][];
711 int i = 0;
712 for (ResolverStyle style : ResolverStyle.values()) {
713 for (JapaneseEra era : JapaneseEra.values()) {
714 result[i++] = new Object[] {style, era};
715 }
716 }
717 return result;
718 }
719
720 @Test(dataProvider = "resolve_styleByEra")
721 public void test_resolve_yearOfEra_eraOnly_valid(ResolverStyle style, JapaneseEra era) {
722 Map<TemporalField, Long> fieldValues = new HashMap<>();
723 fieldValues.put(ChronoField.ERA, (long) era.getValue());
724 JapaneseDate date = JapaneseChronology.INSTANCE.resolveDate(fieldValues, style);
725 assertEquals(date, null);
726 assertEquals(fieldValues.get(ChronoField.ERA), (Long) (long) era.getValue());
727 assertEquals(fieldValues.size(), 1);
728 }
729
730 @Test(dataProvider = "resolve_styleByEra")
731 public void test_resolve_yearOfEra_eraAndYearOfEraOnly_valid(ResolverStyle style, JapaneseEra era) {
732 Map<TemporalField, Long> fieldValues = new HashMap<>();
733 fieldValues.put(ChronoField.ERA, (long) era.getValue());
734 fieldValues.put(ChronoField.YEAR_OF_ERA, 1L);
735 JapaneseDate date = JapaneseChronology.INSTANCE.resolveDate(fieldValues, style);
736 assertEquals(date, null);
737 assertEquals(fieldValues.get(ChronoField.ERA), (Long) (long) era.getValue());
738 assertEquals(fieldValues.get(ChronoField.YEAR_OF_ERA), (Long) 1L);
739 assertEquals(fieldValues.size(), 2);
740 }
741
742 @Test(dataProvider = "resolve_styleByEra")
743 public void test_resolve_yearOfEra_eraAndYearOnly_valid(ResolverStyle style, JapaneseEra era) {
744 Map<TemporalField, Long> fieldValues = new HashMap<>();
745 fieldValues.put(ChronoField.ERA, (long) era.getValue());
746 fieldValues.put(ChronoField.YEAR, 1L);
747 JapaneseDate date = JapaneseChronology.INSTANCE.resolveDate(fieldValues, style);
748 assertEquals(date, null);
749 assertEquals(fieldValues.get(ChronoField.ERA), (Long) (long) era.getValue());
750 assertEquals(fieldValues.get(ChronoField.YEAR), (Long) 1L);
751 assertEquals(fieldValues.size(), 2);
752 }
753
754 @DataProvider(name = "resolve_styles")
755 Object[][] data_resolve_styles() {
756 Object[][] result = new Object[ResolverStyle.values().length][];
757 int i = 0;
758 for (ResolverStyle style : ResolverStyle.values()) {
759 result[i++] = new Object[] {style};
760 }
761 return result;
762 }
763
764 @Test(dataProvider = "resolve_styles")
765 public void test_resolve_yearOfEra_yearOfEraOnly_valid(ResolverStyle style) {
766 Map<TemporalField, Long> fieldValues = new HashMap<>();
767 fieldValues.put(ChronoField.YEAR_OF_ERA, 1L);
768 JapaneseDate date = JapaneseChronology.INSTANCE.resolveDate(fieldValues, style);
769 assertEquals(date, null);
770 assertEquals(fieldValues.get(ChronoField.YEAR_OF_ERA), (Long) 1L);
771 assertEquals(fieldValues.size(), 1);
772 }
773
774 @Test(dataProvider = "resolve_styles")
775 public void test_resolve_yearOfEra_yearOfEraAndYearOnly_valid(ResolverStyle style) {
776 Map<TemporalField, Long> fieldValues = new HashMap<>();
777 fieldValues.put(ChronoField.YEAR_OF_ERA, 1L);
778 fieldValues.put(ChronoField.YEAR, 2012L);
779 JapaneseDate date = JapaneseChronology.INSTANCE.resolveDate(fieldValues, style);
780 assertEquals(date, null);
781 assertEquals(fieldValues.get(ChronoField.YEAR_OF_ERA), (Long) 1L);
782 assertEquals(fieldValues.get(ChronoField.YEAR), (Long) 2012L);
783 assertEquals(fieldValues.size(), 2);
784 }
785
786 public void test_resolve_yearOfEra_eraOnly_invalidTooSmall() {
787 for (ResolverStyle style : ResolverStyle.values()) {
788 Map<TemporalField, Long> fieldValues = new HashMap<>();
789 fieldValues.put(ChronoField.ERA, JapaneseEra.MEIJI.getValue() - 1L);
790 try {
791 JapaneseChronology.INSTANCE.resolveDate(fieldValues, style);
792 fail("Should have failed: " + style);
793 } catch (DateTimeException ex) {
794 // expected
795 }
796 }
797 }
798
799 public void test_resolve_yearOfEra_eraOnly_invalidTooLarge() {
800 for (ResolverStyle style : ResolverStyle.values()) {
801 Map<TemporalField, Long> fieldValues = new HashMap<>();
802 fieldValues.put(ChronoField.ERA, JapaneseEra.values()[JapaneseEra.values().length - 1].getValue() + 1L);
803 try {
804 JapaneseChronology.INSTANCE.resolveDate(fieldValues, style);
805 fail("Should have failed: " + style);
806 } catch (DateTimeException ex) {
807 // expected
808 }
809 }
810 }
811
812 //-----------------------------------------------------------------------
813 //-----------------------------------------------------------------------
814 @DataProvider(name = "resolve_ymd")
815 Object[][] data_resolve_ymd() {
816 return new Object[][] {
817 {2012, 1, -365, date(2010, 12, 31), false, false},
818 {2012, 1, -364, date(2011, 1, 1), false, false},
819 {2012, 1, -31, date(2011, 11, 30), false, false},
820 {2012, 1, -30, date(2011, 12, 1), false, false},
821 {2012, 1, -12, date(2011, 12, 19), false, false},
822 {2012, 1, 1, date(2012, 1, 1), true, true},
823 {2012, 1, 59, date(2012, 2, 28), false, false},
824 {2012, 1, 60, date(2012, 2, 29), false, false},
825 {2012, 1, 61, date(2012, 3, 1), false, false},
826 {2012, 1, 365, date(2012, 12, 30), false, false},
827 {2012, 1, 366, date(2012, 12, 31), false, false},
828 {2012, 1, 367, date(2013, 1, 1), false, false},
829 {2012, 1, 367 + 364, date(2013, 12, 31), false, false},
830 {2012, 1, 367 + 365, date(2014, 1, 1), false, false},
831
832 {2012, 2, 1, date(2012, 2, 1), true, true},
833 {2012, 2, 28, date(2012, 2, 28), true, true},
834 {2012, 2, 29, date(2012, 2, 29), true, true},
835 {2012, 2, 30, date(2012, 3, 1), date(2012, 2, 29), false},
836 {2012, 2, 31, date(2012, 3, 2), date(2012, 2, 29), false},
837 {2012, 2, 32, date(2012, 3, 3), false, false},
838
839 {2012, -12, 1, date(2010, 12, 1), false, false},
840 {2012, -11, 1, date(2011, 1, 1), false, false},
841 {2012, -1, 1, date(2011, 11, 1), false, false},
842 {2012, 0, 1, date(2011, 12, 1), false, false},
843 {2012, 1, 1, date(2012, 1, 1), true, true},
844 {2012, 12, 1, date(2012, 12, 1), true, true},
845 {2012, 13, 1, date(2013, 1, 1), false, false},
846 {2012, 24, 1, date(2013, 12, 1), false, false},
847 {2012, 25, 1, date(2014, 1, 1), false, false},
848
849 {2012, 6, -31, date(2012, 4, 30), false, false},
850 {2012, 6, -30, date(2012, 5, 1), false, false},
851 {2012, 6, -1, date(2012, 5, 30), false, false},
852 {2012, 6, 0, date(2012, 5, 31), false, false},
853 {2012, 6, 1, date(2012, 6, 1), true, true},
854 {2012, 6, 30, date(2012, 6, 30), true, true},
855 {2012, 6, 31, date(2012, 7, 1), date(2012, 6, 30), false},
856 {2012, 6, 61, date(2012, 7, 31), false, false},
857 {2012, 6, 62, date(2012, 8, 1), false, false},
858
859 {2011, 2, 1, date(2011, 2, 1), true, true},
860 {2011, 2, 28, date(2011, 2, 28), true, true},
861 {2011, 2, 29, date(2011, 3, 1), date(2011, 2, 28), false},
862 {2011, 2, 30, date(2011, 3, 2), date(2011, 2, 28), false},
863 {2011, 2, 31, date(2011, 3, 3), date(2011, 2, 28), false},
864 {2011, 2, 32, date(2011, 3, 4), false, false},
865 };
866 }
867
868 @Test(dataProvider = "resolve_ymd")
869 public void test_resolve_ymd_lenient(int y, int m, int d, JapaneseDate expected, Object smart, boolean strict) {
870 Map<TemporalField, Long> fieldValues = new HashMap<>();
871 fieldValues.put(ChronoField.YEAR, (long) y);
872 fieldValues.put(ChronoField.MONTH_OF_YEAR, (long) m);
873 fieldValues.put(ChronoField.DAY_OF_MONTH, (long) d);
874 JapaneseDate date = JapaneseChronology.INSTANCE.resolveDate(fieldValues, ResolverStyle.LENIENT);
875 assertEquals(date, expected);
876 assertEquals(fieldValues.size(), 0);
877 }
878
879 @Test(dataProvider = "resolve_ymd")
880 public void test_resolve_ymd_smart(int y, int m, int d, JapaneseDate expected, Object smart, boolean strict) {
881 Map<TemporalField, Long> fieldValues = new HashMap<>();
882 fieldValues.put(ChronoField.YEAR, (long) y);
883 fieldValues.put(ChronoField.MONTH_OF_YEAR, (long) m);
884 fieldValues.put(ChronoField.DAY_OF_MONTH, (long) d);
885 if (Boolean.TRUE.equals(smart)) {
886 JapaneseDate date = JapaneseChronology.INSTANCE.resolveDate(fieldValues, ResolverStyle.SMART);
887 assertEquals(date, expected);
888 assertEquals(fieldValues.size(), 0);
889 } else if (smart instanceof JapaneseDate) {
890 JapaneseDate date = JapaneseChronology.INSTANCE.resolveDate(fieldValues, ResolverStyle.SMART);
891 assertEquals(date, smart);
892 } else {
893 try {
894 JapaneseChronology.INSTANCE.resolveDate(fieldValues, ResolverStyle.SMART);
895 fail("Should have failed");
896 } catch (DateTimeException ex) {
897 // expected
898 }
899 }
900 }
901
902 @Test(dataProvider = "resolve_ymd")
903 public void test_resolve_ymd_strict(int y, int m, int d, JapaneseDate expected, Object smart, boolean strict) {
904 Map<TemporalField, Long> fieldValues = new HashMap<>();
905 fieldValues.put(ChronoField.YEAR, (long) y);
906 fieldValues.put(ChronoField.MONTH_OF_YEAR, (long) m);
907 fieldValues.put(ChronoField.DAY_OF_MONTH, (long) d);
908 if (strict) {
909 JapaneseDate date = JapaneseChronology.INSTANCE.resolveDate(fieldValues, ResolverStyle.STRICT);
910 assertEquals(date, expected);
911 assertEquals(fieldValues.size(), 0);
912 } else {
913 try {
914 JapaneseChronology.INSTANCE.resolveDate(fieldValues, ResolverStyle.STRICT);
915 fail("Should have failed");
916 } catch (DateTimeException ex) {
917 // expected
918 }
919 }
920 }
921
922 //-----------------------------------------------------------------------
923 //-----------------------------------------------------------------------
924 @DataProvider(name = "resolve_yd")
925 Object[][] data_resolve_yd() {
926 return new Object[][] {
927 {2012, -365, date(2010, 12, 31), false, false},
928 {2012, -364, date(2011, 1, 1), false, false},
929 {2012, -31, date(2011, 11, 30), false, false},
930 {2012, -30, date(2011, 12, 1), false, false},
931 {2012, -12, date(2011, 12, 19), false, false},
932 {2012, -1, date(2011, 12, 30), false, false},
933 {2012, 0, date(2011, 12, 31), false, false},
934 {2012, 1, date(2012, 1, 1), true, true},
935 {2012, 2, date(2012, 1, 2), true, true},
936 {2012, 31, date(2012, 1, 31), true, true},
937 {2012, 32, date(2012, 2, 1), true, true},
938 {2012, 59, date(2012, 2, 28), true, true},
939 {2012, 60, date(2012, 2, 29), true, true},
940 {2012, 61, date(2012, 3, 1), true, true},
941 {2012, 365, date(2012, 12, 30), true, true},
942 {2012, 366, date(2012, 12, 31), true, true},
943 {2012, 367, date(2013, 1, 1), false, false},
944 {2012, 367 + 364, date(2013, 12, 31), false, false},
945 {2012, 367 + 365, date(2014, 1, 1), false, false},
946
947 {2011, 59, date(2011, 2, 28), true, true},
948 {2011, 60, date(2011, 3, 1), true, true},
949 };
950 }
951
952 @Test(dataProvider = "resolve_yd")
953 public void test_resolve_yd_lenient(int y, int d, JapaneseDate expected, boolean smart, boolean strict) {
954 Map<TemporalField, Long> fieldValues = new HashMap<>();
955 fieldValues.put(ChronoField.YEAR, (long) y);
956 fieldValues.put(ChronoField.DAY_OF_YEAR, (long) d);
957 JapaneseDate date = JapaneseChronology.INSTANCE.resolveDate(fieldValues, ResolverStyle.LENIENT);
958 assertEquals(date, expected);
959 assertEquals(fieldValues.size(), 0);
960 }
961
962 @Test(dataProvider = "resolve_yd")
963 public void test_resolve_yd_smart(int y, int d, JapaneseDate expected, boolean smart, boolean strict) {
964 Map<TemporalField, Long> fieldValues = new HashMap<>();
965 fieldValues.put(ChronoField.YEAR, (long) y);
966 fieldValues.put(ChronoField.DAY_OF_YEAR, (long) d);
967 if (smart) {
968 JapaneseDate date = JapaneseChronology.INSTANCE.resolveDate(fieldValues, ResolverStyle.SMART);
969 assertEquals(date, expected);
970 assertEquals(fieldValues.size(), 0);
971 } else {
972 try {
973 JapaneseChronology.INSTANCE.resolveDate(fieldValues, ResolverStyle.SMART);
974 fail("Should have failed");
975 } catch (DateTimeException ex) {
976 // expected
977 }
978 }
979 }
980
981 @Test(dataProvider = "resolve_yd")
982 public void test_resolve_yd_strict(int y, int d, JapaneseDate expected, boolean smart, boolean strict) {
983 Map<TemporalField, Long> fieldValues = new HashMap<>();
984 fieldValues.put(ChronoField.YEAR, (long) y);
985 fieldValues.put(ChronoField.DAY_OF_YEAR, (long) d);
986 if (strict) {
987 JapaneseDate date = JapaneseChronology.INSTANCE.resolveDate(fieldValues, ResolverStyle.STRICT);
988 assertEquals(date, expected);
989 assertEquals(fieldValues.size(), 0);
990 } else {
991 try {
992 JapaneseChronology.INSTANCE.resolveDate(fieldValues, ResolverStyle.STRICT);
993 fail("Should have failed");
994 } catch (DateTimeException ex) {
995 // expected
996 }
997 }
998 }
999
1000 //-----------------------------------------------------------------------
1001 //-----------------------------------------------------------------------
1002 @DataProvider(name = "resolve_eymd")
1003 Object[][] data_resolve_eymd() {
1004 return new Object[][] {
1005 // lenient
1006 {ResolverStyle.LENIENT, JapaneseEra.HEISEI, 1, 1, 1, date(1989, 1, 1)}, // SHOWA, not HEISEI
1007 {ResolverStyle.LENIENT, JapaneseEra.HEISEI, 1, 1, 7, date(1989, 1, 7)}, // SHOWA, not HEISEI
1008 {ResolverStyle.LENIENT, JapaneseEra.HEISEI, 1, 1, 8, date(1989, 1, 8)},
1009 {ResolverStyle.LENIENT, JapaneseEra.HEISEI, 1, 12, 31, date(1989, 12, 31)},
1010 {ResolverStyle.LENIENT, JapaneseEra.HEISEI, 2, 1, 1, date(1990, 1, 1)},
1011
1012 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 64, 1, 1, date(1989, 1, 1)},
1013 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 64, 1, 7, date(1989, 1, 7)},
1014 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 64, 1, 8, date(1989, 1, 8)}, // HEISEI, not SHOWA
1015 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 64, 12, 31, date(1989, 12, 31)}, // HEISEI, not SHOWA
1016 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 65, 1, 1, date(1990, 1, 1)}, // HEISEI, not SHOWA
1017
1018 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 64, 1, -366, date(1987, 12, 31)},
1019 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 64, 1, -365, date(1988, 1, 1)},
1020 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 64, 1, -31, date(1988, 11, 30)},
1021 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 64, 1, -30, date(1988, 12, 1)},
1022 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 64, 1, 0, date(1988, 12, 31)},
1023 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 64, 1, 1, date(1989, 1, 1)},
1024 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 64, 1, 27, date(1989, 1, 27)},
1025 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 64, 1, 28, date(1989, 1, 28)},
1026 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 64, 1, 29, date(1989, 1, 29)},
1027 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 64, 1, 30, date(1989, 1, 30)},
1028 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 64, 1, 31, date(1989, 1, 31)},
1029 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 64, 1, 32, date(1989, 2, 1)},
1030 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 64, 1, 58, date(1989, 2, 27)},
1031 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 64, 1, 59, date(1989, 2, 28)},
1032 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 64, 1, 60, date(1989, 3, 1)},
1033 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 64, 1, 365, date(1989, 12, 31)},
1034 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 64, 1, 366, date(1990, 1, 1)},
1035
1036 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 63, 1, 1, date(1988, 1, 1)},
1037 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 63, 1, 31, date(1988, 1, 31)},
1038 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 63, 1, 32, date(1988, 2, 1)},
1039 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 63, 1, 58, date(1988, 2, 27)},
1040 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 63, 1, 59, date(1988, 2, 28)},
1041 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 63, 1, 60, date(1988, 2, 29)},
1042 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 63, 1, 61, date(1988, 3, 1)},
1043
1044 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 64, 2, 1, date(1989, 2, 1)},
1045 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 64, 2, 28, date(1989, 2, 28)},
1046 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 64, 2, 29, date(1989, 3, 1)},
1047
1048 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 63, 2, 1, date(1988, 2, 1)},
1049 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 63, 2, 28, date(1988, 2, 28)},
1050 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 63, 2, 29, date(1988, 2, 29)},
1051 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 63, 2, 30, date(1988, 3, 1)},
1052
1053 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 62, -11, 1, date(1986, 1, 1)},
1054 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 62, -1, 1, date(1986, 11, 1)},
1055 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 62, 0, 1, date(1986, 12, 1)},
1056 {ResolverStyle.LENIENT, JapaneseEra.SHOWA, 62, 13, 1, date(1988, 1, 1)},
1057
1058 // smart
1059 {ResolverStyle.SMART, JapaneseEra.HEISEI, 0, 1, 1, null},
1060 {ResolverStyle.SMART, JapaneseEra.HEISEI, 1, 1, 1, date(1989, 1, 1)}, // SHOWA, not HEISEI
1061 {ResolverStyle.SMART, JapaneseEra.HEISEI, 1, 1, 7, date(1989, 1, 7)}, // SHOWA, not HEISEI
1062 {ResolverStyle.SMART, JapaneseEra.HEISEI, 1, 1, 8, date(1989, 1, 8)},
1063 {ResolverStyle.SMART, JapaneseEra.HEISEI, 1, 12, 31, date(1989, 12, 31)},
1064 {ResolverStyle.SMART, JapaneseEra.HEISEI, 2, 1, 1, date(1990, 1, 1)},
1065
1066 {ResolverStyle.SMART, JapaneseEra.SHOWA, 64, 1, 1, date(1989, 1, 1)},
1067 {ResolverStyle.SMART, JapaneseEra.SHOWA, 64, 1, 7, date(1989, 1, 7)},
1068 {ResolverStyle.SMART, JapaneseEra.SHOWA, 64, 1, 8, date(1989, 1, 8)}, // HEISEI, not SHOWA
1069 {ResolverStyle.SMART, JapaneseEra.SHOWA, 64, 12, 31, date(1989, 12, 31)}, // HEISEI, not SHOWA
1070 {ResolverStyle.SMART, JapaneseEra.SHOWA, 65, 1, 1, null}, // HEISEI, not SHOWA
1071
1072 {ResolverStyle.SMART, JapaneseEra.SHOWA, 62, 1, 0, null},
1073 {ResolverStyle.SMART, JapaneseEra.SHOWA, 62, 1, 1, date(1987, 1, 1)},
1074 {ResolverStyle.SMART, JapaneseEra.SHOWA, 62, 1, 27, date(1987, 1, 27)},
1075 {ResolverStyle.SMART, JapaneseEra.SHOWA, 62, 1, 28, date(1987, 1, 28)},
1076 {ResolverStyle.SMART, JapaneseEra.SHOWA, 62, 1, 29, date(1987, 1, 29)},
1077 {ResolverStyle.SMART, JapaneseEra.SHOWA, 62, 1, 30, date(1987, 1, 30)},
1078 {ResolverStyle.SMART, JapaneseEra.SHOWA, 62, 1, 31, date(1987, 1, 31)},
1079 {ResolverStyle.SMART, JapaneseEra.SHOWA, 62, 1, 32, null},
1080
1081 {ResolverStyle.SMART, JapaneseEra.SHOWA, 62, 2, 0, null},
1082 {ResolverStyle.SMART, JapaneseEra.SHOWA, 62, 2, 1, date(1987, 2, 1)},
1083 {ResolverStyle.SMART, JapaneseEra.SHOWA, 62, 2, 27, date(1987, 2, 27)},
1084 {ResolverStyle.SMART, JapaneseEra.SHOWA, 62, 2, 28, date(1987, 2, 28)},
1085 {ResolverStyle.SMART, JapaneseEra.SHOWA, 62, 2, 29, date(1987, 2, 28)},
1086 {ResolverStyle.SMART, JapaneseEra.SHOWA, 62, 2, 30, date(1987, 2, 28)},
1087 {ResolverStyle.SMART, JapaneseEra.SHOWA, 62, 2, 31, date(1987, 2, 28)},
1088 {ResolverStyle.SMART, JapaneseEra.SHOWA, 62, 2, 32, null},
1089
1090 {ResolverStyle.SMART, JapaneseEra.SHOWA, 63, 2, 0, null},
1091 {ResolverStyle.SMART, JapaneseEra.SHOWA, 63, 2, 1, date(1988, 2, 1)},
1092 {ResolverStyle.SMART, JapaneseEra.SHOWA, 63, 2, 27, date(1988, 2, 27)},
1093 {ResolverStyle.SMART, JapaneseEra.SHOWA, 63, 2, 28, date(1988, 2, 28)},
1094 {ResolverStyle.SMART, JapaneseEra.SHOWA, 63, 2, 29, date(1988, 2, 29)},
1095 {ResolverStyle.SMART, JapaneseEra.SHOWA, 63, 2, 30, date(1988, 2, 29)},
1096 {ResolverStyle.SMART, JapaneseEra.SHOWA, 63, 2, 31, date(1988, 2, 29)},
1097 {ResolverStyle.SMART, JapaneseEra.SHOWA, 63, 2, 32, null},
1098
1099 {ResolverStyle.SMART, JapaneseEra.SHOWA, 62, -12, 1, null},
1100 {ResolverStyle.SMART, JapaneseEra.SHOWA, 62, -1, 1, null},
1101 {ResolverStyle.SMART, JapaneseEra.SHOWA, 62, 0, 1, null},
1102 {ResolverStyle.SMART, JapaneseEra.SHOWA, 62, 13, 1, null},
1103
1104 // strict
1105 {ResolverStyle.STRICT, JapaneseEra.HEISEI, 0, 1, 1, null},
1106 {ResolverStyle.STRICT, JapaneseEra.HEISEI, 1, 1, 1, null}, // SHOWA, not HEISEI
1107 {ResolverStyle.STRICT, JapaneseEra.HEISEI, 1, 1, 7, null}, // SHOWA, not HEISEI
1108 {ResolverStyle.STRICT, JapaneseEra.HEISEI, 1, 1, 8, date(1989, 1, 8)},
1109 {ResolverStyle.STRICT, JapaneseEra.HEISEI, 1, 12, 31, date(1989, 12, 31)},
1110 {ResolverStyle.STRICT, JapaneseEra.HEISEI, 2, 1, 1, date(1990, 1, 1)},
1111
1112 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 64, 1, 1, date(1989, 1, 1)},
1113 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 64, 1, 7, date(1989, 1, 7)},
1114 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 64, 1, 8, null}, // HEISEI, not SHOWA
1115 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 64, 12, 31, null}, // HEISEI, not SHOWA
1116 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 65, 1, 1, null}, // HEISEI, not SHOWA
1117
1118 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 62, 1, 0, null},
1119 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 62, 1, 1, date(1987, 1, 1)},
1120 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 62, 1, 27, date(1987, 1, 27)},
1121 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 62, 1, 28, date(1987, 1, 28)},
1122 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 62, 1, 29, date(1987, 1, 29)},
1123 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 62, 1, 30, date(1987, 1, 30)},
1124 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 62, 1, 31, date(1987, 1, 31)},
1125 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 62, 1, 32, null},
1126
1127 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 62, 2, 0, null},
1128 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 62, 2, 1, date(1987, 2, 1)},
1129 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 62, 2, 27, date(1987, 2, 27)},
1130 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 62, 2, 28, date(1987, 2, 28)},
1131 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 62, 2, 29, null},
1132 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 62, 2, 30, null},
1133 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 62, 2, 31, null},
1134 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 62, 2, 32, null},
1135
1136 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 63, 2, 0, null},
1137 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 63, 2, 1, date(1988, 2, 1)},
1138 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 63, 2, 27, date(1988, 2, 27)},
1139 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 63, 2, 28, date(1988, 2, 28)},
1140 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 63, 2, 29, date(1988, 2, 29)},
1141 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 63, 2, 30, null},
1142 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 63, 2, 31, null},
1143 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 63, 2, 32, null},
1144
1145 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 62, -12, 1, null},
1146 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 62, -1, 1, null},
1147 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 62, 0, 1, null},
1148 {ResolverStyle.STRICT, JapaneseEra.SHOWA, 62, 13, 1, null},
1149 };
1150 }
1151
1152 @Test(dataProvider = "resolve_eymd")
1153 public void test_resolve_eymd(ResolverStyle style, JapaneseEra era, int yoe, int m, int d, JapaneseDate expected) {
1154 Map<TemporalField, Long> fieldValues = new HashMap<>();
1155 fieldValues.put(ChronoField.ERA, (long) era.getValue());
1156 fieldValues.put(ChronoField.YEAR_OF_ERA, (long) yoe);
1157 fieldValues.put(ChronoField.MONTH_OF_YEAR, (long) m);
1158 fieldValues.put(ChronoField.DAY_OF_MONTH, (long) d);
1159 if (expected != null) {
1160 JapaneseDate date = JapaneseChronology.INSTANCE.resolveDate(fieldValues, style);
1161 assertEquals(date, expected);
1162 assertEquals(fieldValues.size(), 0);
1163 } else {
1164 try {
1165 JapaneseChronology.INSTANCE.resolveDate(fieldValues, style);
1166 fail("Should have failed");
1167 } catch (DateTimeException ex) {
1168 // expected
1169 }
1170 }
1171 }
1172
1173 //-----------------------------------------------------------------------
1174 private static JapaneseDate date(int y, int m, int d) {
1175 return JapaneseDate.of(y, m, d);
1176 }
1177
1178 }
|