1 /*
   2  * Copyright (c) 2013, 2018, 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")
  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.of(3),      1,  5,  1, 2019 },
  64         };
  65     }
  66 
  67     @DataProvider(name="day_year_data")
  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.of(3),   1,    1,  5,  1 },
  82         };
  83     }
  84 
  85     @DataProvider(name="range_data")
  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")
  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.of(3),      1,  4, 30 },
 115             { JapaneseEra.of(3), Year.MAX_VALUE,  12, 31 },
 116         };
 117     }
 118 
 119     @DataProvider(name="invalid_eraYear")
 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.of(3),     -1 },
 136             { JapaneseEra.of(3),      0 },
 137             { JapaneseEra.of(3), Year.MAX_VALUE },
 138         };
 139     }
 140 
 141     @DataProvider(name="invalid_day_year_data")
 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.of(3),   1, 246 },
 156             { JapaneseEra.of(3),   2, 367 },
 157         };
 158     }
 159 
 160     @DataProvider
 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.of(3),       null },
 169             { "NewEra", null,                   IllegalArgumentException.class},
 170         };
 171     }
 172 
 173     @Test
 174     public void test_ofLocale() {
 175         // must be a singleton
 176         assertEquals(Chronology.ofLocale(jaJPJP) == JAPANESE, true);
 177     }
 178 
 179     @Test(dataProvider="transitions")
 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")
 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")
 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)
 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)
 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)
 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")
 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 }