1 /* 2 * Copyright (c) 2012, 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 /* 27 * Copyright (c) 2008-2012, Stephen Colebourne & Michael Nascimento Santos 28 * 29 * All rights reserved. 30 * 31 * Redistribution and use in source and binary forms, with or without 32 * modification, are permitted provided that the following conditions are met: 33 * 34 * * Redistributions of source code must retain the above copyright notice, 35 * this list of conditions and the following disclaimer. 36 * 37 * * Redistributions in binary form must reproduce the above copyright notice, 38 * this list of conditions and the following disclaimer in the documentation 39 * and/or other materials provided with the distribution. 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 org.testng.Assert.assertEquals; 60 import static org.testng.Assert.assertFalse; 61 import static org.testng.Assert.assertTrue; 62 import static org.testng.Assert.fail; 63 64 import java.time.Clock; 65 import java.time.DateTimeException; 66 import java.time.LocalDate; 67 import java.time.LocalDateTime; 68 import java.time.LocalTime; 69 import java.time.Month; 70 import java.time.OffsetDateTime; 71 import java.time.Period; 72 import java.time.Year; 73 import java.time.ZoneId; 74 import java.time.ZoneOffset; 75 import java.time.ZonedDateTime; 76 import java.time.chrono.ChronoLocalDate; 77 import java.time.chrono.ChronoLocalDateTime; 78 import java.time.chrono.ChronoZonedDateTime; 79 import java.time.chrono.Chronology; 80 import java.time.chrono.Era; 81 import java.time.chrono.IsoChronology; 82 import java.time.chrono.JapaneseDate; 83 import java.time.chrono.MinguoChronology; 84 import java.time.chrono.MinguoDate; 85 import java.time.chrono.MinguoEra; 86 import java.time.chrono.ThaiBuddhistChronology; 87 import java.time.chrono.ThaiBuddhistDate; 88 import java.time.temporal.ChronoUnit; 89 import java.time.temporal.TemporalAccessor; 90 import java.time.temporal.TemporalAdjuster; 91 import java.util.List; 92 93 import org.testng.Assert; 94 import org.testng.annotations.DataProvider; 95 import org.testng.annotations.Test; 96 97 /** 98 * Test. 99 */ 100 @Test 101 public class TCKMinguoChronology { 102 103 private static final ZoneOffset OFFSET_PTWO = ZoneOffset.ofHours(2); 104 private static final ZoneId ZONE_PARIS = ZoneId.of("Europe/Paris"); 105 private static final int YDIFF = 1911; 106 //----------------------------------------------------------------------- 107 // Chronology.ofName("Minguo") Lookup by name 108 //----------------------------------------------------------------------- 109 @Test 110 public void test_chrono_byName() { 111 Chronology c = MinguoChronology.INSTANCE; 112 Chronology test = Chronology.of("Minguo"); 113 Assert.assertNotNull(test, "The Minguo calendar could not be found byName"); 114 Assert.assertEquals(test.getId(), "Minguo", "ID mismatch"); 115 Assert.assertEquals(test.getCalendarType(), "roc", "Type mismatch"); 116 Assert.assertEquals(test, c); 117 } 118 119 //----------------------------------------------------------------------- 120 // creation, toLocalDate() 121 //----------------------------------------------------------------------- 122 @DataProvider(name="samples") 123 Object[][] data_samples() { 124 return new Object[][] { 125 {MinguoChronology.INSTANCE.date(1, 1, 1), LocalDate.of(1 + YDIFF, 1, 1)}, 126 {MinguoChronology.INSTANCE.date(1, 1, 2), LocalDate.of(1 + YDIFF, 1, 2)}, 127 {MinguoChronology.INSTANCE.date(1, 1, 3), LocalDate.of(1 + YDIFF, 1, 3)}, 128 129 {MinguoChronology.INSTANCE.date(2, 1, 1), LocalDate.of(2 + YDIFF, 1, 1)}, 130 {MinguoChronology.INSTANCE.date(3, 1, 1), LocalDate.of(3 + YDIFF, 1, 1)}, 131 {MinguoChronology.INSTANCE.date(3, 12, 6), LocalDate.of(3 + YDIFF, 12, 6)}, 132 {MinguoChronology.INSTANCE.date(4, 1, 1), LocalDate.of(4 + YDIFF, 1, 1)}, 133 {MinguoChronology.INSTANCE.date(4, 7, 3), LocalDate.of(4 + YDIFF, 7, 3)}, 134 {MinguoChronology.INSTANCE.date(4, 7, 4), LocalDate.of(4 + YDIFF, 7, 4)}, 135 {MinguoChronology.INSTANCE.date(5, 1, 1), LocalDate.of(5 + YDIFF, 1, 1)}, 136 {MinguoChronology.INSTANCE.date(100, 3, 3), LocalDate.of(100 + YDIFF, 3, 3)}, 137 {MinguoChronology.INSTANCE.date(101, 10, 28), LocalDate.of(101 + YDIFF, 10, 28)}, 138 {MinguoChronology.INSTANCE.date(101, 10, 29), LocalDate.of(101 + YDIFF, 10, 29)}, 139 140 {MinguoChronology.INSTANCE.dateYearDay(1916 - YDIFF, 60), LocalDate.of(1916, 2, 29)}, 141 {MinguoChronology.INSTANCE.dateYearDay(1908 - YDIFF, 60), LocalDate.of(1908, 2, 29)}, 142 {MinguoChronology.INSTANCE.dateYearDay(2000 - YDIFF, 60), LocalDate.of(2000, 2, 29)}, 143 {MinguoChronology.INSTANCE.dateYearDay(2400 - YDIFF, 60), LocalDate.of(2400, 2, 29)}, 144 145 {MinguoChronology.INSTANCE.dateYearDay(MinguoEra.ROC, 1916 - YDIFF, 60), LocalDate.of(1916, 2, 29)}, 146 {MinguoChronology.INSTANCE.dateYearDay(MinguoEra.BEFORE_ROC, 4, 60), LocalDate.of(1908, 2, 29)}, 147 {MinguoChronology.INSTANCE.dateYearDay(MinguoEra.ROC, 2000 - YDIFF, 60), LocalDate.of(2000, 2, 29)}, 148 {MinguoChronology.INSTANCE.dateYearDay(MinguoEra.ROC, 2400 - YDIFF, 60), LocalDate.of(2400, 2, 29)}, 149 150 {MinguoChronology.INSTANCE.date(MinguoEra.ROC, 1916 - YDIFF, 2, 29 ), LocalDate.of(1916, 2, 29)}, 151 {MinguoChronology.INSTANCE.date(MinguoEra.BEFORE_ROC, 4, 2, 29), LocalDate.of(1908, 2, 29)}, 152 {MinguoChronology.INSTANCE.date(MinguoEra.ROC, 2000 - YDIFF, 2, 29), LocalDate.of(2000, 2, 29)}, 153 {MinguoChronology.INSTANCE.date(MinguoEra.ROC, 2400 - YDIFF, 2, 29), LocalDate.of(2400, 2, 29)}, 154 }; 155 } 156 157 @Test(dataProvider="samples") 158 public void test_toLocalDate(MinguoDate minguo, LocalDate iso) { 159 assertEquals(LocalDate.from(minguo), iso); 160 } 161 162 @Test(dataProvider="samples") 163 public void test_fromCalendrical(MinguoDate minguo, LocalDate iso) { 164 assertEquals(MinguoChronology.INSTANCE.date(iso), minguo); 165 } 166 167 @Test 168 public void test_dateNow(){ 169 assertEquals(MinguoChronology.INSTANCE.dateNow(), MinguoDate.now()) ; 170 assertEquals(MinguoChronology.INSTANCE.dateNow(), MinguoDate.now(ZoneId.systemDefault())) ; 171 assertEquals(MinguoChronology.INSTANCE.dateNow(), MinguoDate.now(Clock.systemDefaultZone())) ; 172 assertEquals(MinguoChronology.INSTANCE.dateNow(), MinguoDate.now(Clock.systemDefaultZone().getZone())) ; 173 174 assertEquals(MinguoChronology.INSTANCE.dateNow(), MinguoChronology.INSTANCE.dateNow(ZoneId.systemDefault())) ; 175 assertEquals(MinguoChronology.INSTANCE.dateNow(), MinguoChronology.INSTANCE.dateNow(Clock.systemDefaultZone())) ; 176 assertEquals(MinguoChronology.INSTANCE.dateNow(), MinguoChronology.INSTANCE.dateNow(Clock.systemDefaultZone().getZone())) ; 177 178 ZoneId zoneId = ZoneId.of("Europe/Paris"); 179 assertEquals(MinguoChronology.INSTANCE.dateNow(zoneId), MinguoChronology.INSTANCE.dateNow(Clock.system(zoneId))) ; 180 assertEquals(MinguoChronology.INSTANCE.dateNow(zoneId), MinguoChronology.INSTANCE.dateNow(Clock.system(zoneId).getZone())) ; 181 assertEquals(MinguoChronology.INSTANCE.dateNow(zoneId), MinguoDate.now(Clock.system(zoneId))) ; 182 assertEquals(MinguoChronology.INSTANCE.dateNow(zoneId), MinguoDate.now(Clock.system(zoneId).getZone())) ; 183 184 assertEquals(MinguoChronology.INSTANCE.dateNow(ZoneId.of(ZoneOffset.UTC.getId())), MinguoChronology.INSTANCE.dateNow(Clock.systemUTC())) ; 185 } 186 187 @SuppressWarnings("unused") 188 @Test(dataProvider="samples") 189 public void test_MinguoDate(MinguoDate minguoDate, LocalDate iso) { 190 MinguoDate hd = minguoDate; 191 ChronoLocalDateTime<MinguoDate> hdt = hd.atTime(LocalTime.NOON); 192 ZoneOffset zo = ZoneOffset.ofHours(1); 193 ChronoZonedDateTime<MinguoDate> hzdt = hdt.atZone(zo); 194 hdt = hdt.plus(1, ChronoUnit.YEARS); 195 hdt = hdt.plus(1, ChronoUnit.MONTHS); 196 hdt = hdt.plus(1, ChronoUnit.DAYS); 197 hdt = hdt.plus(1, ChronoUnit.HOURS); 198 hdt = hdt.plus(1, ChronoUnit.MINUTES); 199 hdt = hdt.plus(1, ChronoUnit.SECONDS); 200 hdt = hdt.plus(1, ChronoUnit.NANOS); 201 ChronoLocalDateTime<MinguoDate> a2 = hzdt.toLocalDateTime(); 202 MinguoDate a3 = a2.toLocalDate(); 203 MinguoDate a5 = hzdt.toLocalDate(); 204 //System.out.printf(" d: %s, dt: %s; odt: %s; zodt: %s; a4: %s%n", date, hdt, hodt, hzdt, a5); 205 } 206 207 @Test() 208 public void test_MinguoChrono() { 209 MinguoDate h1 = MinguoChronology.INSTANCE.date(MinguoEra.ROC, 1, 2, 3); 210 MinguoDate h2 = h1; 211 ChronoLocalDateTime<MinguoDate> h3 = h2.atTime(LocalTime.NOON); 212 @SuppressWarnings("unused") 213 ChronoZonedDateTime<MinguoDate> h4 = h3.atZone(ZoneOffset.UTC); 214 } 215 216 @DataProvider(name="badDates") 217 Object[][] data_badDates() { 218 return new Object[][] { 219 {1912, 0, 0}, 220 221 {1912, -1, 1}, 222 {1912, 0, 1}, 223 {1912, 14, 1}, 224 {1912, 15, 1}, 225 226 {1912, 1, -1}, 227 {1912, 1, 0}, 228 {1912, 1, 32}, 229 {1912, 2, 29}, 230 {1912, 2, 30}, 231 232 {1912, 12, -1}, 233 {1912, 12, 0}, 234 {1912, 12, 32}, 235 236 {1907 - YDIFF, 2, 29}, 237 {100 - YDIFF, 2, 29}, 238 {2100 - YDIFF, 2, 29}, 239 {2101 - YDIFF, 2, 29}, 240 }; 241 } 242 243 @Test(dataProvider="badDates", expectedExceptions=DateTimeException.class) 244 public void test_badDates(int year, int month, int dom) { 245 MinguoChronology.INSTANCE.date(year, month, dom); 246 } 247 248 //----------------------------------------------------------------------- 249 // prolepticYear() and is LeapYear() 250 //----------------------------------------------------------------------- 251 @DataProvider(name="prolepticYear") 252 Object[][] data_prolepticYear() { 253 return new Object[][] { 254 {1, MinguoEra.ROC, 1912 - YDIFF, 1912 - YDIFF, true}, 255 {1, MinguoEra.ROC, 1916 - YDIFF, 1916 - YDIFF, true}, 256 {1, MinguoEra.ROC, 1914 - YDIFF, 1914 - YDIFF, false}, 257 {1, MinguoEra.ROC, 2000 - YDIFF, 2000 - YDIFF, true}, 258 {1, MinguoEra.ROC, 2100 - YDIFF, 2100 - YDIFF, false}, 259 {1, MinguoEra.ROC, 0, 0, false}, 260 {1, MinguoEra.ROC, 1908 - YDIFF, 1908 - YDIFF, true}, 261 {1, MinguoEra.ROC, 1900 - YDIFF, 1900 - YDIFF, false}, 262 {1, MinguoEra.ROC, 1600 - YDIFF, 1600 - YDIFF, true}, 263 264 {0, MinguoEra.BEFORE_ROC, YDIFF - 1911, 1912 - YDIFF, true}, 265 {0, MinguoEra.BEFORE_ROC, YDIFF - 1915, 1916 - YDIFF, true}, 266 {0, MinguoEra.BEFORE_ROC, YDIFF - 1913, 1914 - YDIFF, false}, 267 {0, MinguoEra.BEFORE_ROC, YDIFF - 1999, 2000 - YDIFF, true}, 268 {0, MinguoEra.BEFORE_ROC, YDIFF - 2099, 2100 - YDIFF, false}, 269 {0, MinguoEra.BEFORE_ROC, 1, 0, false}, 270 {0, MinguoEra.BEFORE_ROC, YDIFF - 1907, 1908 - YDIFF, true}, 271 {0, MinguoEra.BEFORE_ROC, YDIFF - 1899, 1900 - YDIFF, false}, 272 {0, MinguoEra.BEFORE_ROC, YDIFF - 1599, 1600 - YDIFF, true}, 273 274 }; 275 } 276 277 @Test(dataProvider="prolepticYear") 278 public void test_prolepticYear(int eraValue, Era era, int yearOfEra, int expectedProlepticYear, boolean isLeapYear) { 279 Era eraObj = MinguoChronology.INSTANCE.eraOf(eraValue) ; 280 assertTrue(MinguoChronology.INSTANCE.eras().contains(eraObj)); 281 assertEquals(eraObj, era); 282 assertEquals(MinguoChronology.INSTANCE.prolepticYear(era, yearOfEra), expectedProlepticYear); 283 assertEquals(MinguoChronology.INSTANCE.isLeapYear(expectedProlepticYear), isLeapYear) ; 284 assertEquals(MinguoChronology.INSTANCE.isLeapYear(expectedProlepticYear), Year.of(expectedProlepticYear + YDIFF).isLeap()) ; 285 } 286 287 //----------------------------------------------------------------------- 288 // Bad Era for Chronology.date(era,...) and Chronology.prolepticYear(Era,...) 289 //----------------------------------------------------------------------- 290 @Test 291 public void test_InvalidEras() { 292 // Verify that the eras from every other Chronology are invalid 293 for (Chronology chrono : Chronology.getAvailableChronologies()) { 294 if (chrono instanceof MinguoChronology) { 295 continue; 296 } 297 List<Era> eras = chrono.eras(); 298 for (Era era : eras) { 299 try { 300 ChronoLocalDate date = MinguoChronology.INSTANCE.date(era, 1, 1, 1); 301 fail("MinguoChronology.date did not throw ClassCastException for Era: " + era); 302 } catch (ClassCastException cex) { 303 ; // ignore expected exception 304 } 305 306 /* Test for missing MinguoDate.of(Era, y, m, d) method. 307 try { 308 @SuppressWarnings("unused") 309 MinguoDate jdate = MinguoDate.of(era, 1, 1, 1); 310 fail("MinguoDate.of did not throw ClassCastException for Era: " + era); 311 } catch (ClassCastException cex) { 312 ; // ignore expected exception 313 } 314 */ 315 316 try { 317 @SuppressWarnings("unused") 318 int year = MinguoChronology.INSTANCE.prolepticYear(era, 1); 319 fail("MinguoChronology.prolepticYear did not throw ClassCastException for Era: " + era); 320 } catch (ClassCastException cex) { 321 ; // ignore expected exception 322 } 323 } 324 } 325 } 326 327 //----------------------------------------------------------------------- 328 // with(DateTimeAdjuster) 329 //----------------------------------------------------------------------- 330 @Test 331 public void test_adjust1() { 332 MinguoDate base = MinguoChronology.INSTANCE.date(2012, 10, 29); 333 MinguoDate test = base.with(TemporalAdjuster.lastDayOfMonth()); 334 assertEquals(test, MinguoChronology.INSTANCE.date(2012, 10, 31)); 335 } 336 337 @Test 338 public void test_adjust2() { 339 MinguoDate base = MinguoChronology.INSTANCE.date(1728, 12, 2); 340 MinguoDate test = base.with(TemporalAdjuster.lastDayOfMonth()); 341 assertEquals(test, MinguoChronology.INSTANCE.date(1728, 12, 31)); 342 } 343 344 //----------------------------------------------------------------------- 345 // MinguoDate.with(Local*) 346 //----------------------------------------------------------------------- 347 @Test 348 public void test_adjust_toLocalDate() { 349 MinguoDate minguo = MinguoChronology.INSTANCE.date(99, 1, 4); 350 MinguoDate test = minguo.with(LocalDate.of(2012, 7, 6)); 351 assertEquals(test, MinguoChronology.INSTANCE.date(101, 7, 6)); 352 } 353 354 @Test(expectedExceptions=DateTimeException.class) 355 public void test_adjust_toMonth() { 356 MinguoDate minguo = MinguoChronology.INSTANCE.date(1726, 1, 4); 357 minguo.with(Month.APRIL); 358 } 359 360 //----------------------------------------------------------------------- 361 // LocalDate.with(MinguoDate) 362 //----------------------------------------------------------------------- 363 @Test 364 public void test_LocalDate_adjustToMinguoDate() { 365 MinguoDate minguo = MinguoChronology.INSTANCE.date(101, 10, 29); 366 LocalDate test = LocalDate.MIN.with(minguo); 367 assertEquals(test, LocalDate.of(2012, 10, 29)); 368 } 369 370 @Test 371 public void test_LocalDateTime_adjustToMinguoDate() { 372 MinguoDate minguo = MinguoChronology.INSTANCE.date(101, 10, 29); 373 LocalDateTime test = LocalDateTime.MIN.with(minguo); 374 assertEquals(test, LocalDateTime.of(2012, 10, 29, 0, 0)); 375 } 376 377 //----------------------------------------------------------------------- 378 // localDateTime() 379 //----------------------------------------------------------------------- 380 @DataProvider(name="localDateTime") 381 Object[][] data_localDateTime() { 382 return new Object[][] { 383 {LocalDateTime.of(2012, 2, 29, 2, 7), MinguoChronology.INSTANCE.date(MinguoEra.ROC, 2012 - YDIFF, 2, 29), LocalTime.of(2, 7), null}, 384 {ZonedDateTime.of(2012, 2, 29, 2, 7, 1, 1, ZONE_PARIS), MinguoChronology.INSTANCE.date(MinguoEra.ROC, 2012 - YDIFF, 2, 29), LocalTime.of(2, 7, 1, 1), null}, 385 {OffsetDateTime.of(2012, 2, 29, 2, 7, 1, 1, OFFSET_PTWO), MinguoChronology.INSTANCE.date(MinguoEra.ROC, 2012 - YDIFF, 2, 29), LocalTime.of(2, 7, 1, 1), null}, 386 387 {JapaneseDate.of(2012, 2, 29), null, null, DateTimeException.class}, 388 {ThaiBuddhistDate.of(2012 + 543, 2, 29), null, null, DateTimeException.class}, 389 {LocalDate.of(2012, 2, 29), null, null, DateTimeException.class}, 390 {LocalTime.of(20, 30, 29, 0), null, null, DateTimeException.class}, 391 }; 392 } 393 394 @Test(dataProvider="localDateTime") 395 public void test_localDateTime(TemporalAccessor accessor, MinguoDate expectedDate, LocalTime expectedTime, Class<?> expectedEx) { 396 if (expectedEx == null) { 397 ChronoLocalDateTime<MinguoDate> result = MinguoChronology.INSTANCE.localDateTime(accessor); 398 assertEquals(result.toLocalDate(), expectedDate); 399 assertEquals(MinguoDate.from(accessor), expectedDate); 400 assertEquals(result.toLocalTime(), expectedTime); 401 } else { 402 try { 403 ChronoLocalDateTime<MinguoDate> result = MinguoChronology.INSTANCE.localDateTime(accessor); 404 fail(); 405 } catch (Exception ex) { 406 assertTrue(expectedEx.isInstance(ex)); 407 } 408 } 409 } 410 411 //----------------------------------------------------------------------- 412 // zonedDateTime(TemporalAccessor) 413 //----------------------------------------------------------------------- 414 @DataProvider(name="zonedDateTime") 415 Object[][] data_zonedDateTime() { 416 return new Object[][] { 417 {ZonedDateTime.of(2012, 2, 29, 2, 7, 1, 1, ZONE_PARIS), MinguoChronology.INSTANCE.date(MinguoEra.ROC, 2012 - YDIFF, 2, 29), LocalTime.of(2, 7, 1, 1), null}, 418 {OffsetDateTime.of(2012, 2, 29, 2, 7, 1, 1, OFFSET_PTWO), MinguoChronology.INSTANCE.date(MinguoEra.ROC, 2012 - YDIFF, 2, 29), LocalTime.of(2, 7, 1, 1), null}, 419 420 {LocalDateTime.of(2012, 2, 29, 2, 7), null, null, DateTimeException.class}, 421 {JapaneseDate.of(2012, 2, 29), null, null, DateTimeException.class}, 422 {ThaiBuddhistDate.of(2012 + 543, 2, 29), null, null, DateTimeException.class}, 423 {LocalDate.of(2012, 2, 29), null, null, DateTimeException.class}, 424 {LocalTime.of(20, 30, 29, 0), null, null, DateTimeException.class}, 425 }; 426 } 427 428 @Test(dataProvider="zonedDateTime") 429 public void test_zonedDateTime(TemporalAccessor accessor, MinguoDate expectedDate, LocalTime expectedTime, Class<?> expectedEx) { 430 if (expectedEx == null) { 431 ChronoZonedDateTime<MinguoDate> result = MinguoChronology.INSTANCE.zonedDateTime(accessor); 432 assertEquals(result.toLocalDate(), expectedDate); 433 assertEquals(MinguoDate.from(accessor), expectedDate); 434 assertEquals(result.toLocalTime(), expectedTime); 435 436 } else { 437 try { 438 ChronoZonedDateTime<MinguoDate> result = MinguoChronology.INSTANCE.zonedDateTime(accessor); 439 fail(); 440 } catch (Exception ex) { 441 assertTrue(expectedEx.isInstance(ex)); 442 } 443 } 444 } 445 446 //----------------------------------------------------------------------- 447 // zonedDateTime(Instant, ZoneId ) 448 //----------------------------------------------------------------------- 449 @Test 450 public void test_Instant_zonedDateTime() { 451 OffsetDateTime offsetDateTime = OffsetDateTime.of(2012, 2, 29, 2, 7, 1, 1, OFFSET_PTWO); 452 ZonedDateTime zonedDateTime = ZonedDateTime.of(2012, 2, 29, 2, 7, 1, 1, ZONE_PARIS); 453 454 ChronoZonedDateTime<MinguoDate> result = MinguoChronology.INSTANCE.zonedDateTime(offsetDateTime.toInstant(), offsetDateTime.getOffset()); 455 assertEquals(result.toLocalDate(), MinguoChronology.INSTANCE.date(MinguoEra.ROC, 2012 - YDIFF, 2, 29)); 456 assertEquals(result.toLocalTime(), LocalTime.of(2, 7, 1, 1)); 457 458 result = MinguoChronology.INSTANCE.zonedDateTime(zonedDateTime.toInstant(), zonedDateTime.getOffset()); 459 assertEquals(result.toLocalDate(), MinguoChronology.INSTANCE.date(MinguoEra.ROC, 2012 - YDIFF, 2, 29)); 460 assertEquals(result.toLocalTime(), LocalTime.of(2, 7, 1, 1)); 461 } 462 463 //----------------------------------------------------------------------- 464 // PeriodUntil() 465 //----------------------------------------------------------------------- 466 @Test 467 public void test_periodUntilDate() { 468 MinguoDate mdate1 = MinguoDate.of(1970, 1, 1); 469 MinguoDate mdate2 = MinguoDate.of(1971, 2, 2); 470 Period period = mdate1.periodUntil(mdate2); 471 assertEquals(period, Period.of(1, 1, 1)); 472 } 473 474 @Test 475 public void test_periodUntilUnit() { 476 MinguoDate mdate1 = MinguoDate.of(1970, 1, 1); 477 MinguoDate mdate2 = MinguoDate.of(1971, 2, 2); 478 long months = mdate1.periodUntil(mdate2, ChronoUnit.MONTHS); 479 assertEquals(months, 13); 480 } 481 482 @Test 483 public void test_periodUntilDiffChrono() { 484 MinguoDate mdate1 = MinguoDate.of(1970, 1, 1); 485 MinguoDate mdate2 = MinguoDate.of(1971, 2, 2); 486 ThaiBuddhistDate ldate2 = ThaiBuddhistChronology.INSTANCE.date(mdate2); 487 Period period = mdate1.periodUntil(ldate2); 488 assertEquals(period, Period.of(1, 1, 1)); 489 } 490 491 //----------------------------------------------------------------------- 492 // toString() 493 //----------------------------------------------------------------------- 494 @DataProvider(name="toString") 495 Object[][] data_toString() { 496 return new Object[][] { 497 {MinguoChronology.INSTANCE.date(1, 1, 1), "Minguo ROC 1-01-01"}, 498 {MinguoChronology.INSTANCE.date(1728, 10, 28), "Minguo ROC 1728-10-28"}, 499 {MinguoChronology.INSTANCE.date(1728, 10, 29), "Minguo ROC 1728-10-29"}, 500 {MinguoChronology.INSTANCE.date(1727, 12, 5), "Minguo ROC 1727-12-05"}, 501 {MinguoChronology.INSTANCE.date(1727, 12, 6), "Minguo ROC 1727-12-06"}, 502 }; 503 } 504 505 @Test(dataProvider="toString") 506 public void test_toString(MinguoDate minguo, String expected) { 507 assertEquals(minguo.toString(), expected); 508 } 509 510 //----------------------------------------------------------------------- 511 // equals() 512 //----------------------------------------------------------------------- 513 @Test 514 public void test_equals_true() { 515 assertTrue(MinguoChronology.INSTANCE.equals(MinguoChronology.INSTANCE)); 516 } 517 518 @Test 519 public void test_equals_false() { 520 assertFalse(MinguoChronology.INSTANCE.equals(IsoChronology.INSTANCE)); 521 } 522 523 }