1 /*
2  * Copyright (c) 2013, 2019, Oracle and/or its affiliates. All rights reserved.
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * This code is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License version 2 only, as
7  * published by the Free Software Foundation.  Oracle designates this
8  * particular file as subject to the "Classpath" exception as provided
9  * by Oracle in the LICENSE file that accompanied this code.
10  *
11  * This code is distributed in the hope that it will be useful, but WITHOUT
12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14  * version 2 for more details (a copy is included in the LICENSE file that
15  * accompanied this code).
16  *
17  * You should have received a copy of the GNU General Public License version
18  * 2 along with this work; if not, write to the Free Software Foundation,
19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20  *
21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22  * or visit www.oracle.com if you need additional information or have any
23  * questions.
24  */
25 
26 package test.java.time.chrono;
27 
28 import java.time.*;
29 import java.time.chrono.*;
30 import java.time.temporal.*;
31 import java.util.List;
32 import java.util.Locale;
33 
34 import org.testng.annotations.DataProvider;
35 import org.testng.annotations.Test;
36 import static org.testng.Assert.assertEquals;
37 import static org.testng.Assert.assertTrue;
38 
39 /**
40  * Tests for the Japanese chronology
41  */
42 @Test
43 public class TestJapaneseChronology {
44     private static final JapaneseChronology JAPANESE = JapaneseChronology.INSTANCE;
45     private static final Locale jaJPJP = Locale.forLanguageTag("ja-JP-u-ca-japanese");
46 
47     @DataProvider(name="transitions")
transitionData()48     Object[][] transitionData() {
49         return new Object[][] {
50             // Japanese era, yearOfEra, month, dayOfMonth, gregorianYear
51             { JapaneseEra.MEIJI,      6,  1,  1, 1873 },
52             // Meiji-Taisho transition isn't accurate. 1912-07-30 is the last day of Meiji
53             // and the first day of Taisho.
54             { JapaneseEra.MEIJI,     45,  7, 29, 1912 },
55             { JapaneseEra.TAISHO,     1,  7, 30, 1912 },
56             // Same for Taisho-Showa transition. 1926-12-25 is the last day of Taisho
57             // and the first day of Showa.
58             { JapaneseEra.TAISHO,    15, 12, 24, 1926 },
59             { JapaneseEra.SHOWA,      1, 12, 25, 1926 },
60             { JapaneseEra.SHOWA,     64,  1,  7, 1989 },
61             { JapaneseEra.HEISEI,     1,  1,  8, 1989 },
62             { JapaneseEra.HEISEI,    31,  4, 30, 2019 },
63             { JapaneseEra.REIWA,      1,  5,  1, 2019 },
64         };
65     }
66 
67     @DataProvider(name="day_year_data")
dayYearData()68     Object[][] dayYearData() {
69         return new Object[][] {
70             // Japanese era, yearOfEra, dayOfYear, month, dayOfMonth
71             { JapaneseEra.MEIJI,  45,  211,  7, 29 },
72             { JapaneseEra.TAISHO,  1,    1,  7, 30 },
73             { JapaneseEra.TAISHO,  2,   60,  3,  1 },
74             { JapaneseEra.TAISHO, 15,  358, 12, 24 },
75             { JapaneseEra.SHOWA,   1,    1, 12, 25 },
76             { JapaneseEra.SHOWA,   2,    8,  1,  8 },
77             { JapaneseEra.SHOWA,  64,    7,  1,  7 },
78             { JapaneseEra.HEISEI,  1,    1,  1,  8 },
79             { JapaneseEra.HEISEI,  2,    8,  1,  8 },
80             { JapaneseEra.HEISEI, 31,  120,  4, 30 },
81             { JapaneseEra.REIWA,   1,    1,  5,  1 },
82         };
83     }
84 
85     @DataProvider(name="range_data")
rangeData()86     Object[][] rangeData() {
87         return new Object[][] {
88             // field, minSmallest, minLargest, maxSmallest, maxLargest
89             { ChronoField.ERA,         -1, -1, 3, 3},
90             { ChronoField.YEAR_OF_ERA, 1, 1, 15, 999999999-2019}, // depends on the current era
91             { ChronoField.DAY_OF_YEAR, 1, 1, 7, 366},
92             { ChronoField.YEAR, 1873, 1873, 999999999, 999999999},
93         };
94     }
95 
96     @DataProvider(name="invalid_dates")
invalidDatesData()97     Object[][] invalidDatesData() {
98         return new Object[][] {
99             // Japanese era, yearOfEra, month, dayOfMonth
100             { JapaneseEra.MEIJI,      6,  2, 29 },
101             { JapaneseEra.MEIJI,     45,  7, 30 },
102             { JapaneseEra.MEIJI,     46,  1,  1 },
103             { JapaneseEra.TAISHO,     1,  7, 29 },
104             { JapaneseEra.TAISHO,     2,  2, 29 },
105             { JapaneseEra.TAISHO,    15, 12, 25 },
106             { JapaneseEra.TAISHO,    16,  1,  1 },
107             { JapaneseEra.SHOWA,      1, 12, 24 },
108             { JapaneseEra.SHOWA,      2,  2, 29 },
109             { JapaneseEra.SHOWA,     64,  1,  8 },
110             { JapaneseEra.SHOWA,     65,  1,  1 },
111             { JapaneseEra.HEISEI,     1,  1,  7 },
112             { JapaneseEra.HEISEI,     1,  2, 29 },
113             { JapaneseEra.HEISEI,    31,  5,  1 },
114             { JapaneseEra.REIWA,      1,  4, 30 },
115             { JapaneseEra.REIWA, Year.MAX_VALUE,  12, 31 },
116         };
117     }
118 
119     @DataProvider(name="invalid_eraYear")
invalidEraYearData()120     Object[][] invalidEraYearData() {
121         return new Object[][] {
122             // Japanese era, yearOfEra
123             { JapaneseEra.MEIJI,     -1 },
124             { JapaneseEra.MEIJI,      0 },
125             { JapaneseEra.MEIJI,     46 },
126             { JapaneseEra.TAISHO,    -1 },
127             { JapaneseEra.TAISHO,     0 },
128             { JapaneseEra.TAISHO,    16 },
129             { JapaneseEra.SHOWA,     -1 },
130             { JapaneseEra.SHOWA,      0 },
131             { JapaneseEra.SHOWA,     65 },
132             { JapaneseEra.HEISEI,    -1 },
133             { JapaneseEra.HEISEI,     0 },
134             { JapaneseEra.HEISEI,    32 },
135             { JapaneseEra.REIWA,     -1 },
136             { JapaneseEra.REIWA,      0 },
137             { JapaneseEra.REIWA, Year.MAX_VALUE },
138         };
139     }
140 
141     @DataProvider(name="invalid_day_year_data")
invalidDayYearData()142     Object[][] invalidDayYearData() {
143         return new Object[][] {
144             // Japanese era, yearOfEra, dayOfYear
145             { JapaneseEra.MEIJI,  45, 240 },
146             { JapaneseEra.TAISHO,  1, 365 },
147             { JapaneseEra.TAISHO,  2, 366 },
148             { JapaneseEra.TAISHO, 15, 359 },
149             { JapaneseEra.SHOWA,   1,   8 },
150             { JapaneseEra.SHOWA,   2, 366 },
151             { JapaneseEra.SHOWA,  64,   8 },
152             { JapaneseEra.HEISEI,  1, 360 },
153             { JapaneseEra.HEISEI,  2, 366 },
154             { JapaneseEra.HEISEI, 31, 121 },
155             { JapaneseEra.REIWA,   1, 246 },
156             { JapaneseEra.REIWA,   2, 367 },
157         };
158     }
159 
160     @DataProvider
eraNameData()161     Object[][] eraNameData() {
162         return new Object[][] {
163             // Japanese era, name, exception
164             { "Meiji",  JapaneseEra.MEIJI,      null },
165             { "Taisho", JapaneseEra.TAISHO,     null },
166             { "Showa",  JapaneseEra.SHOWA,      null },
167             { "Heisei", JapaneseEra.HEISEI,     null },
168             { "Reiwa", JapaneseEra.REIWA,       null },
169             { "NewEra", null,                   IllegalArgumentException.class},
170         };
171     }
172 
173     @Test
test_ofLocale()174     public void test_ofLocale() {
175         // must be a singleton
176         assertEquals(Chronology.ofLocale(jaJPJP) == JAPANESE, true);
177     }
178 
179     @Test(dataProvider="transitions")
test_transitions(JapaneseEra era, int yearOfEra, int month, int dayOfMonth, int gregorianYear)180     public void test_transitions(JapaneseEra era, int yearOfEra, int month, int dayOfMonth, int gregorianYear) {
181         assertEquals(JAPANESE.prolepticYear(era, yearOfEra), gregorianYear);
182 
183         JapaneseDate jdate1 = JapaneseDate.of(era, yearOfEra, month, dayOfMonth);
184         JapaneseDate jdate2 = JapaneseDate.of(gregorianYear, month, dayOfMonth);
185         assertEquals(jdate1, jdate2);
186     }
187 
188     @Test(dataProvider="range_data")
test_range(ChronoField field, int minSmallest, int minLargest, int maxSmallest, int maxLargest)189     public void test_range(ChronoField field, int minSmallest, int minLargest, int maxSmallest, int maxLargest) {
190         ValueRange range = JAPANESE.range(field);
191         assertEquals(range.getMinimum(), minSmallest);
192         assertEquals(range.getLargestMinimum(), minLargest);
193         assertEquals(range.getSmallestMaximum(), maxSmallest);
194         assertEquals(range.getMaximum(), maxLargest);
195     }
196 
197     @Test(dataProvider="day_year_data")
test_firstDayOfEra(JapaneseEra era, int yearOfEra, int dayOfYear, int month, int dayOfMonth)198     public void test_firstDayOfEra(JapaneseEra era, int yearOfEra, int dayOfYear, int month, int dayOfMonth) {
199         JapaneseDate date1 = JAPANESE.dateYearDay(era, yearOfEra, dayOfYear);
200         JapaneseDate date2 = JAPANESE.date(era, yearOfEra, month, dayOfMonth);
201         assertEquals(date1, date2);
202     }
203 
204     @Test(dataProvider="invalid_dates", expectedExceptions=DateTimeException.class)
test_invalidDate(JapaneseEra era, int yearOfEra, int month, int dayOfMonth)205     public void test_invalidDate(JapaneseEra era, int yearOfEra, int month, int dayOfMonth) {
206         JapaneseDate jdate = JapaneseDate.of(era, yearOfEra, month, dayOfMonth);
207         System.out.printf("No DateTimeException with %s %d.%02d.%02d%n", era, yearOfEra, month, dayOfMonth);
208     }
209 
210     @Test(dataProvider="invalid_eraYear", expectedExceptions=DateTimeException.class)
test_invalidEraYear(JapaneseEra era, int yearOfEra)211     public void test_invalidEraYear(JapaneseEra era, int yearOfEra) {
212         int year = JAPANESE.prolepticYear(era, yearOfEra);
213         System.out.printf("No DateTimeException with era=%s, year=%d%n", era, yearOfEra);
214     }
215 
216     @Test(dataProvider="invalid_day_year_data", expectedExceptions=DateTimeException.class)
test_invalidDayYear(JapaneseEra era, int yearOfEra, int dayOfYear)217     public void test_invalidDayYear(JapaneseEra era, int yearOfEra, int dayOfYear) {
218         JapaneseDate date = JAPANESE.dateYearDay(era, yearOfEra, dayOfYear);
219         System.out.printf("No DateTimeException with era=%s, year=%d, dayOfYear=%d%n", era, yearOfEra, dayOfYear);
220     }
221 
222     @Test(dataProvider="eraNameData")
test_eraName(String eraName, JapaneseEra era, Class expectedEx)223     public void test_eraName(String eraName, JapaneseEra era, Class expectedEx) {
224         try {
225             assertEquals(JapaneseEra.valueOf(eraName), era);
226         } catch (Exception ex) {
227             assertTrue(expectedEx.isInstance(ex));
228         }
229     }
230 }
231