1 /*
2 * Copyright (c) 2013, 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
38 /**
39 * Tests for the Japanese chronology
40 */
41 @Test
42 public class TestJapaneseChronology {
43 private static final JapaneseChronology JAPANESE = JapaneseChronology.INSTANCE;
44 private static final Locale jaJPJP = Locale.forLanguageTag("ja-JP-u-ca-japanese");
45
46 @DataProvider(name="transitions")
47 Object[][] transitionData() {
48 return new Object[][] {
49 // Japanese era, yearOfEra, month, dayOfMonth, gregorianYear
50 { JapaneseEra.MEIJI, 6, 1, 1, 1873 },
51 // Meiji-Taisho transition isn't accurate. 1912-07-30 is the last day of Meiji
52 // and the first day of Taisho.
53 { JapaneseEra.MEIJI, 45, 7, 29, 1912 },
54 { JapaneseEra.TAISHO, 1, 7, 30, 1912 },
55 // Same for Taisho-Showa transition. 1926-12-25 is the last day of Taisho
56 // and the first day of Showa.
57 { JapaneseEra.TAISHO, 15, 12, 24, 1926 },
58 { JapaneseEra.SHOWA, 1, 12, 25, 1926 },
59 { JapaneseEra.SHOWA, 64, 1, 7, 1989 },
60 { JapaneseEra.HEISEI, 1, 1, 8, 1989 },
61 };
62 }
63
64 @DataProvider(name="day_year_data")
65 Object[][] dayYearData() {
66 return new Object[][] {
67 // Japanese era, yearOfEra, dayOfYear, month, dayOfMonth
68 { JapaneseEra.MEIJI, 45, 211, 7, 29 },
69 { JapaneseEra.TAISHO, 1, 1, 7, 30 },
70 { JapaneseEra.TAISHO, 2, 60, 3, 1 },
71 { JapaneseEra.TAISHO, 15, 358, 12, 24 },
72 { JapaneseEra.SHOWA, 1, 1, 12, 25 },
73 { JapaneseEra.SHOWA, 2, 8, 1, 8 },
74 { JapaneseEra.SHOWA, 64, 7, 1, 7 },
75 { JapaneseEra.HEISEI, 1, 1, 1, 8 },
76 { JapaneseEra.HEISEI, 2, 8, 1, 8 },
77 };
78 }
79
80 @DataProvider(name="range_data")
81 Object[][] rangeData() {
82 return new Object[][] {
83 // field, minSmallest, minLargest, maxSmallest, maxLargest
84 { ChronoField.ERA, -1, -1, 2, 2},
85 { ChronoField.YEAR_OF_ERA, 1, 1, 15, 999999999-1989 }, // depends on the current era
86 { ChronoField.DAY_OF_YEAR, 1, 1, 7, 366},
87 { ChronoField.YEAR, 1873, 1873, 999999999, 999999999},
88 };
89 }
90
91 @DataProvider(name="invalid_dates")
92 Object[][] invalidDatesData() {
93 return new Object[][] {
94 // Japanese era, yearOfEra, month, dayOfMonth
95 { JapaneseEra.MEIJI, 6, 2, 29 },
96 { JapaneseEra.MEIJI, 45, 7, 30 },
97 { JapaneseEra.MEIJI, 46, 1, 1 },
98 { JapaneseEra.TAISHO, 1, 7, 29 },
99 { JapaneseEra.TAISHO, 2, 2, 29 },
100 { JapaneseEra.TAISHO, 15, 12, 25 },
101 { JapaneseEra.TAISHO, 16, 1, 1 },
102 { JapaneseEra.SHOWA, 1, 12, 24 },
103 { JapaneseEra.SHOWA, 2, 2, 29 },
104 { JapaneseEra.SHOWA, 64, 1, 8 },
105 { JapaneseEra.SHOWA, 65, 1, 1 },
106 { JapaneseEra.HEISEI, 1, 1, 7 },
107 { JapaneseEra.HEISEI, 1, 2, 29 },
108 { JapaneseEra.HEISEI, Year.MAX_VALUE, 12, 31 },
109 };
110 }
111
112 @DataProvider(name="invalid_eraYear")
113 Object[][] invalidEraYearData() {
114 return new Object[][] {
115 // Japanese era, yearOfEra
116 { JapaneseEra.MEIJI, -1 },
117 { JapaneseEra.MEIJI, 0 },
118 { JapaneseEra.MEIJI, 46 },
119 { JapaneseEra.TAISHO, -1 },
120 { JapaneseEra.TAISHO, 0 },
121 { JapaneseEra.TAISHO, 16 },
122 { JapaneseEra.SHOWA, -1 },
123 { JapaneseEra.SHOWA, 0 },
124 { JapaneseEra.SHOWA, 65 },
125 { JapaneseEra.HEISEI, -1 },
126 { JapaneseEra.HEISEI, 0 },
127 { JapaneseEra.HEISEI, Year.MAX_VALUE },
128 };
129 }
130
131 @DataProvider(name="invalid_day_year_data")
132 Object[][] invalidDayYearData() {
133 return new Object[][] {
134 // Japanese era, yearOfEra, dayOfYear
135 { JapaneseEra.MEIJI, 45, 240 },
136 { JapaneseEra.TAISHO, 1, 365 },
137 { JapaneseEra.TAISHO, 2, 366 },
138 { JapaneseEra.TAISHO, 15, 359 },
139 { JapaneseEra.SHOWA, 1, 8 },
140 { JapaneseEra.SHOWA, 2, 366 },
141 { JapaneseEra.SHOWA, 64, 8 },
142 { JapaneseEra.HEISEI, 1, 360 },
143 { JapaneseEra.HEISEI, 2, 366 },
144 };
145 }
146
147 @Test
148 public void test_ofLocale() {
149 // must be a singleton
150 assertEquals(Chronology.ofLocale(jaJPJP) == JAPANESE, true);
151 }
152
153 @Test(dataProvider="transitions")
154 public void test_transitions(JapaneseEra era, int yearOfEra, int month, int dayOfMonth, int gregorianYear) {
155 assertEquals(JAPANESE.prolepticYear(era, yearOfEra), gregorianYear);
156
157 JapaneseDate jdate1 = JapaneseDate.of(era, yearOfEra, month, dayOfMonth);
158 JapaneseDate jdate2 = JapaneseDate.of(gregorianYear, month, dayOfMonth);
159 assertEquals(jdate1, jdate2);
160 }
161
162 @Test(dataProvider="range_data")
163 public void test_range(ChronoField field, int minSmallest, int minLargest, int maxSmallest, int maxLargest) {
164 ValueRange range = JAPANESE.range(field);
165 assertEquals(range.getMinimum(), minSmallest);
166 assertEquals(range.getLargestMinimum(), minLargest);
167 assertEquals(range.getSmallestMaximum(), maxSmallest);
168 assertEquals(range.getMaximum(), maxLargest);
169 }
170
171 @Test(dataProvider="day_year_data")
172 public void test_firstDayOfEra(JapaneseEra era, int yearOfEra, int dayOfYear, int month, int dayOfMonth) {
173 JapaneseDate date1 = JAPANESE.dateYearDay(era, yearOfEra, dayOfYear);
174 JapaneseDate date2 = JAPANESE.date(era, yearOfEra, month, dayOfMonth);
175 assertEquals(date1, date2);
176 }
177
178 @Test(dataProvider="invalid_dates", expectedExceptions=DateTimeException.class)
179 public void test_invalidDate(JapaneseEra era, int yearOfEra, int month, int dayOfMonth) {
180 JapaneseDate jdate = JapaneseDate.of(era, yearOfEra, month, dayOfMonth);
181 System.out.printf("No DateTimeException with %s %d.%02d.%02d%n", era, yearOfEra, month, dayOfMonth);
182 }
183
184 @Test(dataProvider="invalid_eraYear", expectedExceptions=DateTimeException.class)
185 public void test_invalidEraYear(JapaneseEra era, int yearOfEra) {
186 int year = JAPANESE.prolepticYear(era, yearOfEra);
187 System.out.printf("No DateTimeException with era=%s, year=%d%n", era, yearOfEra);
188 }
189
190 @Test(dataProvider="invalid_day_year_data", expectedExceptions=DateTimeException.class)
191 public void test_invalidDayYear(JapaneseEra era, int yearOfEra, int dayOfYear) {
192 JapaneseDate date = JAPANESE.dateYearDay(era, yearOfEra, dayOfYear);
193 System.out.printf("No DateTimeException with era=%s, year=%d, dayOfYear=%d%n", era, yearOfEra, dayOfYear);
194 }
195 }