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. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24 /* 25 * This file is available under and governed by the GNU General Public 26 * License version 2 only, as published by the Free Software Foundation. 27 * However, the following notice accompanied the original version of this 28 * file: 29 * 30 * Copyright (c) 2007-2012, Stephen Colebourne & Michael Nascimento Santos 31 * 32 * All rights reserved. 33 * 34 * Redistribution and use in source and binary forms, with or without 35 * modification, are permitted provided that the following conditions are met: 36 * 37 * * Redistributions of source code must retain the above copyright notice, 38 * this list of conditions and the following disclaimer. 39 * 40 * * Redistributions in binary form must reproduce the above copyright notice, 41 * this list of conditions and the following disclaimer in the documentation 42 * and/or other materials provided with the distribution. 43 * 44 * * Neither the name of JSR-310 nor the names of its contributors 45 * may be used to endorse or promote products derived from this software 46 * without specific prior written permission. 47 * 48 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 49 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 50 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 51 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 52 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 53 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 54 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 55 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 56 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 57 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 58 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 59 */ 60 package tck.java.time; 61 62 import static java.time.temporal.ChronoField.ALIGNED_DAY_OF_WEEK_IN_MONTH; 63 import static java.time.temporal.ChronoField.ALIGNED_DAY_OF_WEEK_IN_YEAR; 64 import static java.time.temporal.ChronoField.ALIGNED_WEEK_OF_MONTH; 65 import static java.time.temporal.ChronoField.ALIGNED_WEEK_OF_YEAR; 66 import static java.time.temporal.ChronoField.DAY_OF_MONTH; 67 import static java.time.temporal.ChronoField.DAY_OF_WEEK; 68 import static java.time.temporal.ChronoField.DAY_OF_YEAR; 69 import static java.time.temporal.ChronoField.EPOCH_DAY; 70 import static java.time.temporal.ChronoField.EPOCH_MONTH; 71 import static java.time.temporal.ChronoField.ERA; 72 import static java.time.temporal.ChronoField.MONTH_OF_YEAR; 73 import static java.time.temporal.ChronoField.YEAR; 74 import static java.time.temporal.ChronoField.YEAR_OF_ERA; 75 import static org.testng.Assert.assertEquals; 76 import static org.testng.Assert.assertFalse; 77 import static org.testng.Assert.assertNotNull; 78 import static org.testng.Assert.assertSame; 79 import static org.testng.Assert.assertTrue; 80 81 import java.io.ByteArrayOutputStream; 82 import java.io.DataOutputStream; 83 import java.time.Clock; 84 import java.time.DateTimeException; 85 import java.time.DayOfWeek; 86 import java.time.Instant; 87 import java.time.LocalDate; 88 import java.time.LocalDateTime; 89 import java.time.LocalTime; 90 import java.time.Month; 91 import java.time.OffsetDateTime; 92 import java.time.OffsetTime; 93 import java.time.Period; 94 import java.time.Year; 95 import java.time.ZoneId; 96 import java.time.ZoneOffset; 97 import java.time.ZonedDateTime; 98 import java.time.chrono.IsoChronology; 99 import java.time.format.DateTimeFormatter; 100 import java.time.format.DateTimeParseException; 101 import java.time.temporal.ChronoField; 102 import java.time.temporal.ChronoUnit; 103 import java.time.temporal.JulianFields; 104 import java.time.temporal.Queries; 105 import java.time.temporal.Temporal; 106 import java.time.temporal.TemporalAccessor; 107 import java.time.temporal.TemporalAdjuster; 108 import java.time.temporal.TemporalField; 109 import java.time.temporal.TemporalQuery; 110 import java.time.temporal.TemporalUnit; 111 import java.util.ArrayList; 112 import java.util.Arrays; 113 import java.util.List; 114 115 import org.testng.annotations.BeforeMethod; 116 import org.testng.annotations.DataProvider; 117 import org.testng.annotations.Test; 118 import test.java.time.MockSimplePeriod; 119 import test.java.time.temporal.MockFieldNoValue; 120 121 /** 122 * Test LocalDate. 123 */ 124 @Test 125 public class TCKLocalDate extends AbstractDateTimeTest { 126 127 private static final ZoneOffset OFFSET_PONE = ZoneOffset.ofHours(1); 128 private static final ZoneOffset OFFSET_PTWO = ZoneOffset.ofHours(2); 129 private static final ZoneId ZONE_PARIS = ZoneId.of("Europe/Paris"); 130 private static final ZoneId ZONE_GAZA = ZoneId.of("Asia/Gaza"); 131 132 private LocalDate TEST_2007_07_15; 133 private long MAX_VALID_EPOCHDAYS; 134 private long MIN_VALID_EPOCHDAYS; 135 private LocalDate MAX_DATE; 136 private LocalDate MIN_DATE; 137 private Instant MAX_INSTANT; 138 private Instant MIN_INSTANT; 139 140 @BeforeMethod(groups={"tck", "implementation"}) 141 public void setUp() { 142 TEST_2007_07_15 = LocalDate.of(2007, 7, 15); 143 144 LocalDate max = LocalDate.MAX; 145 LocalDate min = LocalDate.MIN; 146 MAX_VALID_EPOCHDAYS = max.toEpochDay(); 147 MIN_VALID_EPOCHDAYS = min.toEpochDay(); 148 MAX_DATE = max; 149 MIN_DATE = min; 150 MAX_INSTANT = max.atStartOfDay(ZoneOffset.UTC).toInstant(); 151 MIN_INSTANT = min.atStartOfDay(ZoneOffset.UTC).toInstant(); 152 } 153 154 //----------------------------------------------------------------------- 155 @Override 156 protected List<TemporalAccessor> samples() { 157 TemporalAccessor[] array = {TEST_2007_07_15, LocalDate.MAX, LocalDate.MIN, }; 158 return Arrays.asList(array); 159 } 160 161 @Override 162 protected List<TemporalField> validFields() { 163 TemporalField[] array = { 164 DAY_OF_WEEK, 165 ALIGNED_DAY_OF_WEEK_IN_MONTH, 166 ALIGNED_DAY_OF_WEEK_IN_YEAR, 167 DAY_OF_MONTH, 168 DAY_OF_YEAR, 169 EPOCH_DAY, 170 ALIGNED_WEEK_OF_MONTH, 171 ALIGNED_WEEK_OF_YEAR, 172 MONTH_OF_YEAR, 173 EPOCH_MONTH, 174 YEAR_OF_ERA, 175 YEAR, 176 ERA, 177 JulianFields.JULIAN_DAY, 178 JulianFields.MODIFIED_JULIAN_DAY, 179 JulianFields.RATA_DIE, 180 }; 181 return Arrays.asList(array); 182 } 183 184 @Override 185 protected List<TemporalField> invalidFields() { 186 List<TemporalField> list = new ArrayList<>(Arrays.<TemporalField>asList(ChronoField.values())); 187 list.removeAll(validFields()); 188 return list; 189 } 190 191 192 //----------------------------------------------------------------------- 193 @Test 194 public void test_serialization() throws Exception { 195 assertSerializable(TEST_2007_07_15); 196 assertSerializable(LocalDate.MIN); 197 assertSerializable(LocalDate.MAX); 198 } 199 200 @Test 201 public void test_serialization_format() throws Exception { 202 ByteArrayOutputStream baos = new ByteArrayOutputStream(); 203 try (DataOutputStream dos = new DataOutputStream(baos) ) { 204 dos.writeByte(3); 205 dos.writeInt(2012); 206 dos.writeByte(9); 207 dos.writeByte(16); 208 } 209 byte[] bytes = baos.toByteArray(); 210 assertSerializedBySer(LocalDate.of(2012, 9, 16), bytes); 211 } 212 213 //----------------------------------------------------------------------- 214 private void check(LocalDate test, int y, int m, int d) { 215 assertEquals(test.getYear(), y); 216 assertEquals(test.getMonth().getValue(), m); 217 assertEquals(test.getDayOfMonth(), d); 218 assertEquals(test, test); 219 assertEquals(test.hashCode(), test.hashCode()); 220 assertEquals(LocalDate.of(y, m, d), test); 221 } 222 223 //----------------------------------------------------------------------- 224 // constants 225 //----------------------------------------------------------------------- 226 @Test 227 public void constant_MIN() { 228 check(LocalDate.MIN, Year.MIN_VALUE, 1, 1); 229 } 230 231 @Test 232 public void constant_MAX() { 233 check(LocalDate.MAX, Year.MAX_VALUE, 12, 31); 234 } 235 236 //----------------------------------------------------------------------- 237 // now() 238 //----------------------------------------------------------------------- 239 @Test(groups={"tck"}) 240 public void now() { 241 LocalDate expected = LocalDate.now(Clock.systemDefaultZone()); 242 LocalDate test = LocalDate.now(); 243 for (int i = 0; i < 100; i++) { 244 if (expected.equals(test)) { 245 return; 246 } 247 expected = LocalDate.now(Clock.systemDefaultZone()); 248 test = LocalDate.now(); 249 } 250 assertEquals(test, expected); 251 } 252 253 //----------------------------------------------------------------------- 254 // now(ZoneId) 255 //----------------------------------------------------------------------- 256 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 257 public void now_ZoneId_nullZoneId() { 258 LocalDate.now((ZoneId) null); 259 } 260 261 @Test(groups={"tck"}) 262 public void now_ZoneId() { 263 ZoneId zone = ZoneId.of("UTC+01:02:03"); 264 LocalDate expected = LocalDate.now(Clock.system(zone)); 265 LocalDate test = LocalDate.now(zone); 266 for (int i = 0; i < 100; i++) { 267 if (expected.equals(test)) { 268 return; 269 } 270 expected = LocalDate.now(Clock.system(zone)); 271 test = LocalDate.now(zone); 272 } 273 assertEquals(test, expected); 274 } 275 276 //----------------------------------------------------------------------- 277 // now(Clock) 278 //----------------------------------------------------------------------- 279 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 280 public void now_Clock_nullClock() { 281 LocalDate.now((Clock) null); 282 } 283 284 @Test(groups={"tck"}) 285 public void now_Clock_allSecsInDay_utc() { 286 for (int i = 0; i < (2 * 24 * 60 * 60); i++) { 287 Instant instant = Instant.ofEpochSecond(i); 288 Clock clock = Clock.fixed(instant, ZoneOffset.UTC); 289 LocalDate test = LocalDate.now(clock); 290 assertEquals(test.getYear(), 1970); 291 assertEquals(test.getMonth(), Month.JANUARY); 292 assertEquals(test.getDayOfMonth(), (i < 24 * 60 * 60 ? 1 : 2)); 293 } 294 } 295 296 @Test(groups={"tck"}) 297 public void now_Clock_allSecsInDay_offset() { 298 for (int i = 0; i < (2 * 24 * 60 * 60); i++) { 299 Instant instant = Instant.ofEpochSecond(i); 300 Clock clock = Clock.fixed(instant.minusSeconds(OFFSET_PONE.getTotalSeconds()), OFFSET_PONE); 301 LocalDate test = LocalDate.now(clock); 302 assertEquals(test.getYear(), 1970); 303 assertEquals(test.getMonth(), Month.JANUARY); 304 assertEquals(test.getDayOfMonth(), (i < 24 * 60 * 60) ? 1 : 2); 305 } 306 } 307 308 @Test(groups={"tck"}) 309 public void now_Clock_allSecsInDay_beforeEpoch() { 310 for (int i =-1; i >= -(2 * 24 * 60 * 60); i--) { 311 Instant instant = Instant.ofEpochSecond(i); 312 Clock clock = Clock.fixed(instant, ZoneOffset.UTC); 313 LocalDate test = LocalDate.now(clock); 314 assertEquals(test.getYear(), 1969); 315 assertEquals(test.getMonth(), Month.DECEMBER); 316 assertEquals(test.getDayOfMonth(), (i >= -24 * 60 * 60 ? 31 : 30)); 317 } 318 } 319 320 //----------------------------------------------------------------------- 321 @Test(groups={"tck"}) 322 public void now_Clock_maxYear() { 323 Clock clock = Clock.fixed(MAX_INSTANT, ZoneOffset.UTC); 324 LocalDate test = LocalDate.now(clock); 325 assertEquals(test, MAX_DATE); 326 } 327 328 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 329 public void now_Clock_tooBig() { 330 Clock clock = Clock.fixed(MAX_INSTANT.plusSeconds(24 * 60 * 60), ZoneOffset.UTC); 331 LocalDate.now(clock); 332 } 333 334 @Test(groups={"tck"}) 335 public void now_Clock_minYear() { 336 Clock clock = Clock.fixed(MIN_INSTANT, ZoneOffset.UTC); 337 LocalDate test = LocalDate.now(clock); 338 assertEquals(test, MIN_DATE); 339 } 340 341 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 342 public void now_Clock_tooLow() { 343 Clock clock = Clock.fixed(MIN_INSTANT.minusNanos(1), ZoneOffset.UTC); 344 LocalDate.now(clock); 345 } 346 347 //----------------------------------------------------------------------- 348 // of() factories 349 //----------------------------------------------------------------------- 350 @Test(groups={"tck"}) 351 public void factory_of_intsMonth() { 352 assertEquals(TEST_2007_07_15, LocalDate.of(2007, Month.JULY, 15)); 353 } 354 355 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 356 public void factory_of_intsMonth_29febNonLeap() { 357 LocalDate.of(2007, Month.FEBRUARY, 29); 358 } 359 360 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 361 public void factory_of_intsMonth_31apr() { 362 LocalDate.of(2007, Month.APRIL, 31); 363 } 364 365 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 366 public void factory_of_intsMonth_dayTooLow() { 367 LocalDate.of(2007, Month.JANUARY, 0); 368 } 369 370 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 371 public void factory_of_intsMonth_dayTooHigh() { 372 LocalDate.of(2007, Month.JANUARY, 32); 373 } 374 375 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 376 public void factory_of_intsMonth_nullMonth() { 377 LocalDate.of(2007, null, 30); 378 } 379 380 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 381 public void factory_of_intsMonth_yearTooLow() { 382 LocalDate.of(Integer.MIN_VALUE, Month.JANUARY, 1); 383 } 384 385 //----------------------------------------------------------------------- 386 @Test(groups={"tck"}) 387 public void factory_of_ints() { 388 check(TEST_2007_07_15, 2007, 7, 15); 389 } 390 391 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 392 public void factory_of_ints_29febNonLeap() { 393 LocalDate.of(2007, 2, 29); 394 } 395 396 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 397 public void factory_of_ints_31apr() { 398 LocalDate.of(2007, 4, 31); 399 } 400 401 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 402 public void factory_of_ints_dayTooLow() { 403 LocalDate.of(2007, 1, 0); 404 } 405 406 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 407 public void factory_of_ints_dayTooHigh() { 408 LocalDate.of(2007, 1, 32); 409 } 410 411 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 412 public void factory_of_ints_monthTooLow() { 413 LocalDate.of(2007, 0, 1); 414 } 415 416 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 417 public void factory_of_ints_monthTooHigh() { 418 LocalDate.of(2007, 13, 1); 419 } 420 421 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 422 public void factory_of_ints_yearTooLow() { 423 LocalDate.of(Integer.MIN_VALUE, 1, 1); 424 } 425 426 //----------------------------------------------------------------------- 427 @Test(groups={"tck"}) 428 public void factory_ofYearDay_ints_nonLeap() { 429 LocalDate date = LocalDate.of(2007, 1, 1); 430 for (int i = 1; i < 365; i++) { 431 assertEquals(LocalDate.ofYearDay(2007, i), date); 432 date = next(date); 433 } 434 } 435 436 @Test(groups={"tck"}) 437 public void factory_ofYearDay_ints_leap() { 438 LocalDate date = LocalDate.of(2008, 1, 1); 439 for (int i = 1; i < 366; i++) { 440 assertEquals(LocalDate.ofYearDay(2008, i), date); 441 date = next(date); 442 } 443 } 444 445 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 446 public void factory_ofYearDay_ints_366nonLeap() { 447 LocalDate.ofYearDay(2007, 366); 448 } 449 450 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 451 public void factory_ofYearDay_ints_dayTooLow() { 452 LocalDate.ofYearDay(2007, 0); 453 } 454 455 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 456 public void factory_ofYearDay_ints_dayTooHigh() { 457 LocalDate.ofYearDay(2007, 367); 458 } 459 460 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 461 public void factory_ofYearDay_ints_yearTooLow() { 462 LocalDate.ofYearDay(Integer.MIN_VALUE, 1); 463 } 464 465 //----------------------------------------------------------------------- 466 // Since plusDays/minusDays actually depends on MJDays, it cannot be used for testing 467 private LocalDate next(LocalDate date) { 468 int newDayOfMonth = date.getDayOfMonth() + 1; 469 if (newDayOfMonth <= date.getMonth().length(isIsoLeap(date.getYear()))) { 470 return date.withDayOfMonth(newDayOfMonth); 471 } 472 date = date.withDayOfMonth(1); 473 if (date.getMonth() == Month.DECEMBER) { 474 date = date.withYear(date.getYear() + 1); 475 } 476 return date.with(date.getMonth().plus(1)); 477 } 478 479 private LocalDate previous(LocalDate date) { 480 int newDayOfMonth = date.getDayOfMonth() - 1; 481 if (newDayOfMonth > 0) { 482 return date.withDayOfMonth(newDayOfMonth); 483 } 484 date = date.with(date.getMonth().minus(1)); 485 if (date.getMonth() == Month.DECEMBER) { 486 date = date.withYear(date.getYear() - 1); 487 } 488 return date.withDayOfMonth(date.getMonth().length(isIsoLeap(date.getYear()))); 489 } 490 491 //----------------------------------------------------------------------- 492 // ofEpochDay() 493 //----------------------------------------------------------------------- 494 @Test(groups={"tck"}) 495 public void factory_ofEpochDay() { 496 long date_0000_01_01 = -678941 - 40587; 497 assertEquals(LocalDate.ofEpochDay(0), LocalDate.of(1970, 1, 1)); 498 assertEquals(LocalDate.ofEpochDay(date_0000_01_01), LocalDate.of(0, 1, 1)); 499 assertEquals(LocalDate.ofEpochDay(date_0000_01_01 - 1), LocalDate.of(-1, 12, 31)); 500 assertEquals(LocalDate.ofEpochDay(MAX_VALID_EPOCHDAYS), LocalDate.of(Year.MAX_VALUE, 12, 31)); 501 assertEquals(LocalDate.ofEpochDay(MIN_VALID_EPOCHDAYS), LocalDate.of(Year.MIN_VALUE, 1, 1)); 502 503 LocalDate test = LocalDate.of(0, 1, 1); 504 for (long i = date_0000_01_01; i < 700000; i++) { 505 assertEquals(LocalDate.ofEpochDay(i), test); 506 test = next(test); 507 } 508 test = LocalDate.of(0, 1, 1); 509 for (long i = date_0000_01_01; i > -2000000; i--) { 510 assertEquals(LocalDate.ofEpochDay(i), test); 511 test = previous(test); 512 } 513 } 514 515 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 516 public void factory_ofEpochDay_aboveMax() { 517 LocalDate.ofEpochDay(MAX_VALID_EPOCHDAYS + 1); 518 } 519 520 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 521 public void factory_ofEpochDay_belowMin() { 522 LocalDate.ofEpochDay(MIN_VALID_EPOCHDAYS - 1); 523 } 524 525 //----------------------------------------------------------------------- 526 // from() 527 //----------------------------------------------------------------------- 528 @Test(groups={"tck"}) 529 public void test_from_TemporalAccessor() { 530 assertEquals(LocalDate.from(LocalDate.of(2007, 7, 15)), LocalDate.of(2007, 7, 15)); 531 assertEquals(LocalDate.from(LocalDateTime.of(2007, 7, 15, 12, 30)), LocalDate.of(2007, 7, 15)); 532 } 533 534 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 535 public void test_from_TemporalAccessor_invalid_noDerive() { 536 LocalDate.from(LocalTime.of(12, 30)); 537 } 538 539 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 540 public void test_from_TemporalAccessor_null() { 541 LocalDate.from((TemporalAccessor) null); 542 } 543 544 //----------------------------------------------------------------------- 545 // parse() 546 //----------------------------------------------------------------------- 547 @Test(dataProvider="sampleToString", groups={"tck"}) 548 public void factory_parse_validText(int y, int m, int d, String parsable) { 549 LocalDate t = LocalDate.parse(parsable); 550 assertNotNull(t, parsable); 551 assertEquals(t.getYear(), y, parsable); 552 assertEquals(t.getMonth().getValue(), m, parsable); 553 assertEquals(t.getDayOfMonth(), d, parsable); 554 } 555 556 @DataProvider(name="sampleBadParse") 557 Object[][] provider_sampleBadParse() { 558 return new Object[][]{ 559 {"2008/07/05"}, 560 {"10000-01-01"}, 561 {"2008-1-1"}, 562 {"2008--01"}, 563 {"ABCD-02-01"}, 564 {"2008-AB-01"}, 565 {"2008-02-AB"}, 566 {"-0000-02-01"}, 567 {"2008-02-01Z"}, 568 {"2008-02-01+01:00"}, 569 {"2008-02-01+01:00[Europe/Paris]"}, 570 }; 571 } 572 573 @Test(dataProvider="sampleBadParse", expectedExceptions={DateTimeParseException.class}, groups={"tck"}) 574 public void factory_parse_invalidText(String unparsable) { 575 LocalDate.parse(unparsable); 576 } 577 578 @Test(expectedExceptions=DateTimeParseException.class, groups={"tck"}) 579 public void factory_parse_illegalValue() { 580 LocalDate.parse("2008-06-32"); 581 } 582 583 @Test(expectedExceptions=DateTimeParseException.class, groups={"tck"}) 584 public void factory_parse_invalidValue() { 585 LocalDate.parse("2008-06-31"); 586 } 587 588 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 589 public void factory_parse_nullText() { 590 LocalDate.parse((String) null); 591 } 592 593 //----------------------------------------------------------------------- 594 // parse(DateTimeFormatter) 595 //----------------------------------------------------------------------- 596 @Test(groups={"tck"}) 597 public void factory_parse_formatter() { 598 DateTimeFormatter f = DateTimeFormatter.ofPattern("y M d"); 599 LocalDate test = LocalDate.parse("2010 12 3", f); 600 assertEquals(test, LocalDate.of(2010, 12, 3)); 601 } 602 603 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 604 public void factory_parse_formatter_nullText() { 605 DateTimeFormatter f = DateTimeFormatter.ofPattern("y M d"); 606 LocalDate.parse((String) null, f); 607 } 608 609 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 610 public void factory_parse_formatter_nullFormatter() { 611 LocalDate.parse("ANY", null); 612 } 613 614 //----------------------------------------------------------------------- 615 // get(TemporalField) 616 //----------------------------------------------------------------------- 617 @Test 618 public void test_get_TemporalField() { 619 LocalDate test = LocalDate.of(2008, 6, 30); 620 assertEquals(test.get(ChronoField.YEAR), 2008); 621 assertEquals(test.get(ChronoField.MONTH_OF_YEAR), 6); 622 assertEquals(test.get(ChronoField.DAY_OF_MONTH), 30); 623 assertEquals(test.get(ChronoField.DAY_OF_WEEK), 1); 624 assertEquals(test.get(ChronoField.DAY_OF_YEAR), 182); 625 } 626 627 @Test 628 public void test_getLong_TemporalField() { 629 LocalDate test = LocalDate.of(2008, 6, 30); 630 assertEquals(test.getLong(ChronoField.YEAR), 2008); 631 assertEquals(test.getLong(ChronoField.MONTH_OF_YEAR), 6); 632 assertEquals(test.getLong(ChronoField.DAY_OF_MONTH), 30); 633 assertEquals(test.getLong(ChronoField.DAY_OF_WEEK), 1); 634 assertEquals(test.getLong(ChronoField.DAY_OF_YEAR), 182); 635 } 636 637 //----------------------------------------------------------------------- 638 // query(TemporalQuery) 639 //----------------------------------------------------------------------- 640 @DataProvider(name="query") 641 Object[][] data_query() { 642 return new Object[][] { 643 {TEST_2007_07_15, Queries.chronology(), IsoChronology.INSTANCE}, 644 {TEST_2007_07_15, Queries.zoneId(), null}, 645 {TEST_2007_07_15, Queries.precision(), ChronoUnit.DAYS}, 646 {TEST_2007_07_15, Queries.zone(), null}, 647 {TEST_2007_07_15, Queries.offset(), null}, 648 {TEST_2007_07_15, Queries.localDate(), TEST_2007_07_15}, 649 {TEST_2007_07_15, Queries.localTime(), null}, 650 }; 651 } 652 653 @Test(dataProvider="query") 654 public <T> void test_query(TemporalAccessor temporal, TemporalQuery<T> query, T expected) { 655 assertEquals(temporal.query(query), expected); 656 } 657 658 @Test(dataProvider="query") 659 public <T> void test_queryFrom(TemporalAccessor temporal, TemporalQuery<T> query, T expected) { 660 assertEquals(query.queryFrom(temporal), expected); 661 } 662 663 @Test(expectedExceptions=NullPointerException.class) 664 public void test_query_null() { 665 TEST_2007_07_15.query(null); 666 } 667 668 //----------------------------------------------------------------------- 669 // get*() 670 //----------------------------------------------------------------------- 671 @DataProvider(name="sampleDates") 672 Object[][] provider_sampleDates() { 673 return new Object[][] { 674 {2008, 7, 5}, 675 {2007, 7, 5}, 676 {2006, 7, 5}, 677 {2005, 7, 5}, 678 {2004, 1, 1}, 679 {-1, 1, 2}, 680 }; 681 } 682 683 //----------------------------------------------------------------------- 684 @Test(dataProvider="sampleDates", groups={"tck"}) 685 public void test_get(int y, int m, int d) { 686 LocalDate a = LocalDate.of(y, m, d); 687 assertEquals(a.getYear(), y); 688 assertEquals(a.getMonth(), Month.of(m)); 689 assertEquals(a.getDayOfMonth(), d); 690 } 691 692 @Test(dataProvider="sampleDates", groups={"tck"}) 693 public void test_getDOY(int y, int m, int d) { 694 LocalDate a = LocalDate.of(y, m, d); 695 int total = 0; 696 for (int i = 1; i < m; i++) { 697 total += Month.of(i).length(isIsoLeap(y)); 698 } 699 int doy = total + d; 700 assertEquals(a.getDayOfYear(), doy); 701 } 702 703 @Test(groups={"tck"}) 704 public void test_getDayOfWeek() { 705 DayOfWeek dow = DayOfWeek.MONDAY; 706 for (Month month : Month.values()) { 707 int length = month.length(false); 708 for (int i = 1; i <= length; i++) { 709 LocalDate d = LocalDate.of(2007, month, i); 710 assertSame(d.getDayOfWeek(), dow); 711 dow = dow.plus(1); 712 } 713 } 714 } 715 716 //----------------------------------------------------------------------- 717 // isLeapYear() 718 //----------------------------------------------------------------------- 719 @Test(groups={"tck"}) 720 public void test_isLeapYear() { 721 assertEquals(LocalDate.of(1999, 1, 1).isLeapYear(), false); 722 assertEquals(LocalDate.of(2000, 1, 1).isLeapYear(), true); 723 assertEquals(LocalDate.of(2001, 1, 1).isLeapYear(), false); 724 assertEquals(LocalDate.of(2002, 1, 1).isLeapYear(), false); 725 assertEquals(LocalDate.of(2003, 1, 1).isLeapYear(), false); 726 assertEquals(LocalDate.of(2004, 1, 1).isLeapYear(), true); 727 assertEquals(LocalDate.of(2005, 1, 1).isLeapYear(), false); 728 729 assertEquals(LocalDate.of(1500, 1, 1).isLeapYear(), false); 730 assertEquals(LocalDate.of(1600, 1, 1).isLeapYear(), true); 731 assertEquals(LocalDate.of(1700, 1, 1).isLeapYear(), false); 732 assertEquals(LocalDate.of(1800, 1, 1).isLeapYear(), false); 733 assertEquals(LocalDate.of(1900, 1, 1).isLeapYear(), false); 734 } 735 736 //----------------------------------------------------------------------- 737 // lengthOfMonth() 738 //----------------------------------------------------------------------- 739 @Test(groups={"tck"}) 740 public void test_lengthOfMonth_notLeapYear() { 741 assertEquals(LocalDate.of(2007, 1, 1).lengthOfMonth(), 31); 742 assertEquals(LocalDate.of(2007, 2, 1).lengthOfMonth(), 28); 743 assertEquals(LocalDate.of(2007, 3, 1).lengthOfMonth(), 31); 744 assertEquals(LocalDate.of(2007, 4, 1).lengthOfMonth(), 30); 745 assertEquals(LocalDate.of(2007, 5, 1).lengthOfMonth(), 31); 746 assertEquals(LocalDate.of(2007, 6, 1).lengthOfMonth(), 30); 747 assertEquals(LocalDate.of(2007, 7, 1).lengthOfMonth(), 31); 748 assertEquals(LocalDate.of(2007, 8, 1).lengthOfMonth(), 31); 749 assertEquals(LocalDate.of(2007, 9, 1).lengthOfMonth(), 30); 750 assertEquals(LocalDate.of(2007, 10, 1).lengthOfMonth(), 31); 751 assertEquals(LocalDate.of(2007, 11, 1).lengthOfMonth(), 30); 752 assertEquals(LocalDate.of(2007, 12, 1).lengthOfMonth(), 31); 753 } 754 755 @Test(groups={"tck"}) 756 public void test_lengthOfMonth_leapYear() { 757 assertEquals(LocalDate.of(2008, 1, 1).lengthOfMonth(), 31); 758 assertEquals(LocalDate.of(2008, 2, 1).lengthOfMonth(), 29); 759 assertEquals(LocalDate.of(2008, 3, 1).lengthOfMonth(), 31); 760 assertEquals(LocalDate.of(2008, 4, 1).lengthOfMonth(), 30); 761 assertEquals(LocalDate.of(2008, 5, 1).lengthOfMonth(), 31); 762 assertEquals(LocalDate.of(2008, 6, 1).lengthOfMonth(), 30); 763 assertEquals(LocalDate.of(2008, 7, 1).lengthOfMonth(), 31); 764 assertEquals(LocalDate.of(2008, 8, 1).lengthOfMonth(), 31); 765 assertEquals(LocalDate.of(2008, 9, 1).lengthOfMonth(), 30); 766 assertEquals(LocalDate.of(2008, 10, 1).lengthOfMonth(), 31); 767 assertEquals(LocalDate.of(2008, 11, 1).lengthOfMonth(), 30); 768 assertEquals(LocalDate.of(2008, 12, 1).lengthOfMonth(), 31); 769 } 770 771 //----------------------------------------------------------------------- 772 // lengthOfYear() 773 //----------------------------------------------------------------------- 774 @Test(groups={"tck"}) 775 public void test_lengthOfYear() { 776 assertEquals(LocalDate.of(2007, 1, 1).lengthOfYear(), 365); 777 assertEquals(LocalDate.of(2008, 1, 1).lengthOfYear(), 366); 778 } 779 780 //----------------------------------------------------------------------- 781 // with() 782 //----------------------------------------------------------------------- 783 @Test(groups={"tck"}) 784 public void test_with_adjustment() { 785 final LocalDate sample = LocalDate.of(2012, 3, 4); 786 TemporalAdjuster adjuster = new TemporalAdjuster() { 787 @Override 788 public Temporal adjustInto(Temporal dateTime) { 789 return sample; 790 } 791 }; 792 assertEquals(TEST_2007_07_15.with(adjuster), sample); 793 } 794 795 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 796 public void test_with_adjustment_null() { 797 TEST_2007_07_15.with((TemporalAdjuster) null); 798 } 799 800 //----------------------------------------------------------------------- 801 // with(TemporalField,long) 802 //----------------------------------------------------------------------- 803 @Test(groups={"tck"}) 804 public void test_with_TemporalField_long_normal() { 805 LocalDate t = TEST_2007_07_15.with(YEAR, 2008); 806 assertEquals(t, LocalDate.of(2008, 7, 15)); 807 } 808 809 @Test(expectedExceptions=NullPointerException.class, groups={"tck"} ) 810 public void test_with_TemporalField_long_null() { 811 TEST_2007_07_15.with((TemporalField) null, 1); 812 } 813 814 @Test(expectedExceptions=DateTimeException.class, groups={"tck"} ) 815 public void test_with_TemporalField_long_invalidField() { 816 TEST_2007_07_15.with(MockFieldNoValue.INSTANCE, 1); 817 } 818 819 @Test(expectedExceptions=DateTimeException.class, groups={"tck"} ) 820 public void test_with_TemporalField_long_timeField() { 821 TEST_2007_07_15.with(ChronoField.AMPM_OF_DAY, 1); 822 } 823 824 @Test(expectedExceptions=DateTimeException.class, groups={"tck"} ) 825 public void test_with_TemporalField_long_invalidValue() { 826 TEST_2007_07_15.with(ChronoField.DAY_OF_WEEK, -1); 827 } 828 829 //----------------------------------------------------------------------- 830 // withYear() 831 //----------------------------------------------------------------------- 832 @Test(groups={"tck"}) 833 public void test_withYear_int_normal() { 834 LocalDate t = TEST_2007_07_15.withYear(2008); 835 assertEquals(t, LocalDate.of(2008, 7, 15)); 836 } 837 838 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 839 public void test_withYear_int_invalid() { 840 TEST_2007_07_15.withYear(Year.MIN_VALUE - 1); 841 } 842 843 @Test(groups={"tck"}) 844 public void test_withYear_int_adjustDay() { 845 LocalDate t = LocalDate.of(2008, 2, 29).withYear(2007); 846 LocalDate expected = LocalDate.of(2007, 2, 28); 847 assertEquals(t, expected); 848 } 849 850 //----------------------------------------------------------------------- 851 // withMonth() 852 //----------------------------------------------------------------------- 853 @Test(groups={"tck"}) 854 public void test_withMonth_int_normal() { 855 LocalDate t = TEST_2007_07_15.withMonth(1); 856 assertEquals(t, LocalDate.of(2007, 1, 15)); 857 } 858 859 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 860 public void test_withMonth_int_invalid() { 861 TEST_2007_07_15.withMonth(13); 862 } 863 864 @Test(groups={"tck"}) 865 public void test_withMonth_int_adjustDay() { 866 LocalDate t = LocalDate.of(2007, 12, 31).withMonth(11); 867 LocalDate expected = LocalDate.of(2007, 11, 30); 868 assertEquals(t, expected); 869 } 870 871 //----------------------------------------------------------------------- 872 // withDayOfMonth() 873 //----------------------------------------------------------------------- 874 @Test(groups={"tck"}) 875 public void test_withDayOfMonth_normal() { 876 LocalDate t = TEST_2007_07_15.withDayOfMonth(1); 877 assertEquals(t, LocalDate.of(2007, 7, 1)); 878 } 879 880 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 881 public void test_withDayOfMonth_illegal() { 882 TEST_2007_07_15.withDayOfMonth(32); 883 } 884 885 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 886 public void test_withDayOfMonth_invalid() { 887 LocalDate.of(2007, 11, 30).withDayOfMonth(31); 888 } 889 890 //----------------------------------------------------------------------- 891 // withDayOfYear(int) 892 //----------------------------------------------------------------------- 893 @Test(groups={"tck"}) 894 public void test_withDayOfYear_normal() { 895 LocalDate t = TEST_2007_07_15.withDayOfYear(33); 896 assertEquals(t, LocalDate.of(2007, 2, 2)); 897 } 898 899 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 900 public void test_withDayOfYear_illegal() { 901 TEST_2007_07_15.withDayOfYear(367); 902 } 903 904 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 905 public void test_withDayOfYear_invalid() { 906 TEST_2007_07_15.withDayOfYear(366); 907 } 908 909 //----------------------------------------------------------------------- 910 // plus(Period) 911 //----------------------------------------------------------------------- 912 @Test(groups={"tck"}) 913 public void test_plus_Period_positiveMonths() { 914 MockSimplePeriod period = MockSimplePeriod.of(7, ChronoUnit.MONTHS); 915 LocalDate t = TEST_2007_07_15.plus(period); 916 assertEquals(t, LocalDate.of(2008, 2, 15)); 917 } 918 919 @Test(groups={"tck"}) 920 public void test_plus_Period_negativeDays() { 921 MockSimplePeriod period = MockSimplePeriod.of(-25, ChronoUnit.DAYS); 922 LocalDate t = TEST_2007_07_15.plus(period); 923 assertEquals(t, LocalDate.of(2007, 6, 20)); 924 } 925 926 @Test(groups={"tck"}, expectedExceptions=DateTimeException.class) 927 public void test_plus_Period_timeNotAllowed() { 928 MockSimplePeriod period = MockSimplePeriod.of(7, ChronoUnit.HOURS); 929 TEST_2007_07_15.plus(period); 930 } 931 932 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 933 public void test_plus_Period_null() { 934 TEST_2007_07_15.plus((MockSimplePeriod) null); 935 } 936 937 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 938 public void test_plus_Period_invalidTooLarge() { 939 MockSimplePeriod period = MockSimplePeriod.of(1, ChronoUnit.YEARS); 940 LocalDate.of(Year.MAX_VALUE, 1, 1).plus(period); 941 } 942 943 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 944 public void test_plus_Period_invalidTooSmall() { 945 MockSimplePeriod period = MockSimplePeriod.of(-1, ChronoUnit.YEARS); 946 LocalDate.of(Year.MIN_VALUE, 1, 1).plus(period); 947 } 948 949 //----------------------------------------------------------------------- 950 // plus(long,TemporalUnit) 951 //----------------------------------------------------------------------- 952 @Test(groups={"tck"}) 953 public void test_plus_longTemporalUnit_positiveMonths() { 954 LocalDate t = TEST_2007_07_15.plus(7, ChronoUnit.MONTHS); 955 assertEquals(t, LocalDate.of(2008, 2, 15)); 956 } 957 958 @Test(groups={"tck"}) 959 public void test_plus_longTemporalUnit_negativeDays() { 960 LocalDate t = TEST_2007_07_15.plus(-25, ChronoUnit.DAYS); 961 assertEquals(t, LocalDate.of(2007, 6, 20)); 962 } 963 964 @Test(groups={"tck"}, expectedExceptions=DateTimeException.class) 965 public void test_plus_longTemporalUnit_timeNotAllowed() { 966 TEST_2007_07_15.plus(7, ChronoUnit.HOURS); 967 } 968 969 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 970 public void test_plus_longTemporalUnit_null() { 971 TEST_2007_07_15.plus(1, (TemporalUnit) null); 972 } 973 974 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 975 public void test_plus_longTemporalUnit_invalidTooLarge() { 976 LocalDate.of(Year.MAX_VALUE, 1, 1).plus(1, ChronoUnit.YEARS); 977 } 978 979 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 980 public void test_plus_longTemporalUnit_invalidTooSmall() { 981 LocalDate.of(Year.MIN_VALUE, 1, 1).plus(-1, ChronoUnit.YEARS); 982 } 983 984 //----------------------------------------------------------------------- 985 // plusYears() 986 //----------------------------------------------------------------------- 987 @Test(groups={"tck"}) 988 public void test_plusYears_long_normal() { 989 LocalDate t = TEST_2007_07_15.plusYears(1); 990 assertEquals(t, LocalDate.of(2008, 7, 15)); 991 } 992 993 @Test(groups={"tck"}) 994 public void test_plusYears_long_negative() { 995 LocalDate t = TEST_2007_07_15.plusYears(-1); 996 assertEquals(t, LocalDate.of(2006, 7, 15)); 997 } 998 999 @Test(groups={"tck"}) 1000 public void test_plusYears_long_adjustDay() { 1001 LocalDate t = LocalDate.of(2008, 2, 29).plusYears(1); 1002 LocalDate expected = LocalDate.of(2009, 2, 28); 1003 assertEquals(t, expected); 1004 } 1005 1006 @Test(groups={"tck"}) 1007 public void test_plusYears_long_big() { 1008 long years = 20L + Year.MAX_VALUE; 1009 LocalDate test = LocalDate.of(-40, 6, 1).plusYears(years); 1010 assertEquals(test, LocalDate.of((int) (-40L + years), 6, 1)); 1011 } 1012 1013 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1014 public void test_plusYears_long_invalidTooLarge() { 1015 LocalDate test = LocalDate.of(Year.MAX_VALUE, 6, 1); 1016 test.plusYears(1); 1017 } 1018 1019 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1020 public void test_plusYears_long_invalidTooLargeMaxAddMax() { 1021 LocalDate test = LocalDate.of(Year.MAX_VALUE, 12, 1); 1022 test.plusYears(Long.MAX_VALUE); 1023 } 1024 1025 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1026 public void test_plusYears_long_invalidTooLargeMaxAddMin() { 1027 LocalDate test = LocalDate.of(Year.MAX_VALUE, 12, 1); 1028 test.plusYears(Long.MIN_VALUE); 1029 } 1030 1031 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1032 public void test_plusYears_long_invalidTooSmall_validInt() { 1033 LocalDate.of(Year.MIN_VALUE, 1, 1).plusYears(-1); 1034 } 1035 1036 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1037 public void test_plusYears_long_invalidTooSmall_invalidInt() { 1038 LocalDate.of(Year.MIN_VALUE, 1, 1).plusYears(-10); 1039 } 1040 1041 //----------------------------------------------------------------------- 1042 // plusMonths() 1043 //----------------------------------------------------------------------- 1044 @Test(groups={"tck"}) 1045 public void test_plusMonths_long_normal() { 1046 LocalDate t = TEST_2007_07_15.plusMonths(1); 1047 assertEquals(t, LocalDate.of(2007, 8, 15)); 1048 } 1049 1050 @Test(groups={"tck"}) 1051 public void test_plusMonths_long_overYears() { 1052 LocalDate t = TEST_2007_07_15.plusMonths(25); 1053 assertEquals(t, LocalDate.of(2009, 8, 15)); 1054 } 1055 1056 @Test(groups={"tck"}) 1057 public void test_plusMonths_long_negative() { 1058 LocalDate t = TEST_2007_07_15.plusMonths(-1); 1059 assertEquals(t, LocalDate.of(2007, 6, 15)); 1060 } 1061 1062 @Test(groups={"tck"}) 1063 public void test_plusMonths_long_negativeAcrossYear() { 1064 LocalDate t = TEST_2007_07_15.plusMonths(-7); 1065 assertEquals(t, LocalDate.of(2006, 12, 15)); 1066 } 1067 1068 @Test(groups={"tck"}) 1069 public void test_plusMonths_long_negativeOverYears() { 1070 LocalDate t = TEST_2007_07_15.plusMonths(-31); 1071 assertEquals(t, LocalDate.of(2004, 12, 15)); 1072 } 1073 1074 @Test(groups={"tck"}) 1075 public void test_plusMonths_long_adjustDayFromLeapYear() { 1076 LocalDate t = LocalDate.of(2008, 2, 29).plusMonths(12); 1077 LocalDate expected = LocalDate.of(2009, 2, 28); 1078 assertEquals(t, expected); 1079 } 1080 1081 @Test(groups={"tck"}) 1082 public void test_plusMonths_long_adjustDayFromMonthLength() { 1083 LocalDate t = LocalDate.of(2007, 3, 31).plusMonths(1); 1084 LocalDate expected = LocalDate.of(2007, 4, 30); 1085 assertEquals(t, expected); 1086 } 1087 1088 @Test(groups={"tck"}) 1089 public void test_plusMonths_long_big() { 1090 long months = 20L + Integer.MAX_VALUE; 1091 LocalDate test = LocalDate.of(-40, 6, 1).plusMonths(months); 1092 assertEquals(test, LocalDate.of((int) (-40L + months / 12), 6 + (int) (months % 12), 1)); 1093 } 1094 1095 @Test(expectedExceptions={DateTimeException.class}, groups={"tck"}) 1096 public void test_plusMonths_long_invalidTooLarge() { 1097 LocalDate.of(Year.MAX_VALUE, 12, 1).plusMonths(1); 1098 } 1099 1100 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1101 public void test_plusMonths_long_invalidTooLargeMaxAddMax() { 1102 LocalDate test = LocalDate.of(Year.MAX_VALUE, 12, 1); 1103 test.plusMonths(Long.MAX_VALUE); 1104 } 1105 1106 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1107 public void test_plusMonths_long_invalidTooLargeMaxAddMin() { 1108 LocalDate test = LocalDate.of(Year.MAX_VALUE, 12, 1); 1109 test.plusMonths(Long.MIN_VALUE); 1110 } 1111 1112 @Test(expectedExceptions={DateTimeException.class}, groups={"tck"}) 1113 public void test_plusMonths_long_invalidTooSmall() { 1114 LocalDate.of(Year.MIN_VALUE, 1, 1).plusMonths(-1); 1115 } 1116 1117 @Test(groups={"tck"}) 1118 public void test_plusWeeks_normal() { 1119 LocalDate t = TEST_2007_07_15.plusWeeks(1); 1120 assertEquals(t, LocalDate.of(2007, 7, 22)); 1121 } 1122 1123 @Test(groups={"tck"}) 1124 public void test_plusWeeks_overMonths() { 1125 LocalDate t = TEST_2007_07_15.plusWeeks(9); 1126 assertEquals(t, LocalDate.of(2007, 9, 16)); 1127 } 1128 1129 @Test(groups={"tck"}) 1130 public void test_plusWeeks_overYears() { 1131 LocalDate t = LocalDate.of(2006, 7, 16).plusWeeks(52); 1132 assertEquals(t, TEST_2007_07_15); 1133 } 1134 1135 @Test(groups={"tck"}) 1136 public void test_plusWeeks_overLeapYears() { 1137 LocalDate t = TEST_2007_07_15.plusYears(-1).plusWeeks(104); 1138 assertEquals(t, LocalDate.of(2008, 7, 12)); 1139 } 1140 1141 @Test(groups={"tck"}) 1142 public void test_plusWeeks_negative() { 1143 LocalDate t = TEST_2007_07_15.plusWeeks(-1); 1144 assertEquals(t, LocalDate.of(2007, 7, 8)); 1145 } 1146 1147 @Test(groups={"tck"}) 1148 public void test_plusWeeks_negativeAcrossYear() { 1149 LocalDate t = TEST_2007_07_15.plusWeeks(-28); 1150 assertEquals(t, LocalDate.of(2006, 12, 31)); 1151 } 1152 1153 @Test(groups={"tck"}) 1154 public void test_plusWeeks_negativeOverYears() { 1155 LocalDate t = TEST_2007_07_15.plusWeeks(-104); 1156 assertEquals(t, LocalDate.of(2005, 7, 17)); 1157 } 1158 1159 @Test(groups={"tck"}) 1160 public void test_plusWeeks_maximum() { 1161 LocalDate t = LocalDate.of(Year.MAX_VALUE, 12, 24).plusWeeks(1); 1162 LocalDate expected = LocalDate.of(Year.MAX_VALUE, 12, 31); 1163 assertEquals(t, expected); 1164 } 1165 1166 @Test(groups={"tck"}) 1167 public void test_plusWeeks_minimum() { 1168 LocalDate t = LocalDate.of(Year.MIN_VALUE, 1, 8).plusWeeks(-1); 1169 LocalDate expected = LocalDate.of(Year.MIN_VALUE, 1, 1); 1170 assertEquals(t, expected); 1171 } 1172 1173 @Test(expectedExceptions={DateTimeException.class}, groups={"tck"}) 1174 public void test_plusWeeks_invalidTooLarge() { 1175 LocalDate.of(Year.MAX_VALUE, 12, 25).plusWeeks(1); 1176 } 1177 1178 @Test(expectedExceptions={DateTimeException.class}, groups={"tck"}) 1179 public void test_plusWeeks_invalidTooSmall() { 1180 LocalDate.of(Year.MIN_VALUE, 1, 7).plusWeeks(-1); 1181 } 1182 1183 @Test(expectedExceptions={ArithmeticException.class}, groups={"tck"}) 1184 public void test_plusWeeks_invalidMaxMinusMax() { 1185 LocalDate.of(Year.MAX_VALUE, 12, 25).plusWeeks(Long.MAX_VALUE); 1186 } 1187 1188 @Test(expectedExceptions={ArithmeticException.class}, groups={"tck"}) 1189 public void test_plusWeeks_invalidMaxMinusMin() { 1190 LocalDate.of(Year.MAX_VALUE, 12, 25).plusWeeks(Long.MIN_VALUE); 1191 } 1192 1193 @Test(groups={"tck"}) 1194 public void test_plusDays_normal() { 1195 LocalDate t = TEST_2007_07_15.plusDays(1); 1196 assertEquals(t, LocalDate.of(2007, 7, 16)); 1197 } 1198 1199 @Test(groups={"tck"}) 1200 public void test_plusDays_overMonths() { 1201 LocalDate t = TEST_2007_07_15.plusDays(62); 1202 assertEquals(t, LocalDate.of(2007, 9, 15)); 1203 } 1204 1205 @Test(groups={"tck"}) 1206 public void test_plusDays_overYears() { 1207 LocalDate t = LocalDate.of(2006, 7, 14).plusDays(366); 1208 assertEquals(t, TEST_2007_07_15); 1209 } 1210 1211 @Test(groups={"tck"}) 1212 public void test_plusDays_overLeapYears() { 1213 LocalDate t = TEST_2007_07_15.plusYears(-1).plusDays(365 + 366); 1214 assertEquals(t, LocalDate.of(2008, 7, 15)); 1215 } 1216 1217 @Test(groups={"tck"}) 1218 public void test_plusDays_negative() { 1219 LocalDate t = TEST_2007_07_15.plusDays(-1); 1220 assertEquals(t, LocalDate.of(2007, 7, 14)); 1221 } 1222 1223 @Test(groups={"tck"}) 1224 public void test_plusDays_negativeAcrossYear() { 1225 LocalDate t = TEST_2007_07_15.plusDays(-196); 1226 assertEquals(t, LocalDate.of(2006, 12, 31)); 1227 } 1228 1229 @Test(groups={"tck"}) 1230 public void test_plusDays_negativeOverYears() { 1231 LocalDate t = TEST_2007_07_15.plusDays(-730); 1232 assertEquals(t, LocalDate.of(2005, 7, 15)); 1233 } 1234 1235 @Test(groups={"tck"}) 1236 public void test_plusDays_maximum() { 1237 LocalDate t = LocalDate.of(Year.MAX_VALUE, 12, 30).plusDays(1); 1238 LocalDate expected = LocalDate.of(Year.MAX_VALUE, 12, 31); 1239 assertEquals(t, expected); 1240 } 1241 1242 @Test(groups={"tck"}) 1243 public void test_plusDays_minimum() { 1244 LocalDate t = LocalDate.of(Year.MIN_VALUE, 1, 2).plusDays(-1); 1245 LocalDate expected = LocalDate.of(Year.MIN_VALUE, 1, 1); 1246 assertEquals(t, expected); 1247 } 1248 1249 @Test(expectedExceptions={DateTimeException.class}, groups={"tck"}) 1250 public void test_plusDays_invalidTooLarge() { 1251 LocalDate.of(Year.MAX_VALUE, 12, 31).plusDays(1); 1252 } 1253 1254 @Test(expectedExceptions={DateTimeException.class}, groups={"tck"}) 1255 public void test_plusDays_invalidTooSmall() { 1256 LocalDate.of(Year.MIN_VALUE, 1, 1).plusDays(-1); 1257 } 1258 1259 @Test(expectedExceptions=ArithmeticException.class, groups={"tck"}) 1260 public void test_plusDays_overflowTooLarge() { 1261 LocalDate.of(Year.MAX_VALUE, 12, 31).plusDays(Long.MAX_VALUE); 1262 } 1263 1264 @Test(expectedExceptions=ArithmeticException.class, groups={"tck"}) 1265 public void test_plusDays_overflowTooSmall() { 1266 LocalDate.of(Year.MIN_VALUE, 1, 1).plusDays(Long.MIN_VALUE); 1267 } 1268 1269 //----------------------------------------------------------------------- 1270 // minus(Period) 1271 //----------------------------------------------------------------------- 1272 @Test(groups={"tck"}) 1273 public void test_minus_Period_positiveMonths() { 1274 MockSimplePeriod period = MockSimplePeriod.of(7, ChronoUnit.MONTHS); 1275 LocalDate t = TEST_2007_07_15.minus(period); 1276 assertEquals(t, LocalDate.of(2006, 12, 15)); 1277 } 1278 1279 @Test(groups={"tck"}) 1280 public void test_minus_Period_negativeDays() { 1281 MockSimplePeriod period = MockSimplePeriod.of(-25, ChronoUnit.DAYS); 1282 LocalDate t = TEST_2007_07_15.minus(period); 1283 assertEquals(t, LocalDate.of(2007, 8, 9)); 1284 } 1285 1286 @Test(groups={"tck"}, expectedExceptions=DateTimeException.class) 1287 public void test_minus_Period_timeNotAllowed() { 1288 MockSimplePeriod period = MockSimplePeriod.of(7, ChronoUnit.HOURS); 1289 TEST_2007_07_15.minus(period); 1290 } 1291 1292 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 1293 public void test_minus_Period_null() { 1294 TEST_2007_07_15.minus((MockSimplePeriod) null); 1295 } 1296 1297 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1298 public void test_minus_Period_invalidTooLarge() { 1299 MockSimplePeriod period = MockSimplePeriod.of(-1, ChronoUnit.YEARS); 1300 LocalDate.of(Year.MAX_VALUE, 1, 1).minus(period); 1301 } 1302 1303 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1304 public void test_minus_Period_invalidTooSmall() { 1305 MockSimplePeriod period = MockSimplePeriod.of(1, ChronoUnit.YEARS); 1306 LocalDate.of(Year.MIN_VALUE, 1, 1).minus(period); 1307 } 1308 1309 //----------------------------------------------------------------------- 1310 // minus(long,TemporalUnit) 1311 //----------------------------------------------------------------------- 1312 @Test(groups={"tck"}) 1313 public void test_minus_longTemporalUnit_positiveMonths() { 1314 LocalDate t = TEST_2007_07_15.minus(7, ChronoUnit.MONTHS); 1315 assertEquals(t, LocalDate.of(2006, 12, 15)); 1316 } 1317 1318 @Test(groups={"tck"}) 1319 public void test_minus_longTemporalUnit_negativeDays() { 1320 LocalDate t = TEST_2007_07_15.minus(-25, ChronoUnit.DAYS); 1321 assertEquals(t, LocalDate.of(2007, 8, 9)); 1322 } 1323 1324 @Test(groups={"tck"}, expectedExceptions=DateTimeException.class) 1325 public void test_minus_longTemporalUnit_timeNotAllowed() { 1326 TEST_2007_07_15.minus(7, ChronoUnit.HOURS); 1327 } 1328 1329 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 1330 public void test_minus_longTemporalUnit_null() { 1331 TEST_2007_07_15.minus(1, (TemporalUnit) null); 1332 } 1333 1334 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1335 public void test_minus_longTemporalUnit_invalidTooLarge() { 1336 LocalDate.of(Year.MAX_VALUE, 1, 1).minus(-1, ChronoUnit.YEARS); 1337 } 1338 1339 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1340 public void test_minus_longTemporalUnit_invalidTooSmall() { 1341 LocalDate.of(Year.MIN_VALUE, 1, 1).minus(1, ChronoUnit.YEARS); 1342 } 1343 1344 //----------------------------------------------------------------------- 1345 // minusYears() 1346 //----------------------------------------------------------------------- 1347 @Test(groups={"tck"}) 1348 public void test_minusYears_long_normal() { 1349 LocalDate t = TEST_2007_07_15.minusYears(1); 1350 assertEquals(t, LocalDate.of(2006, 7, 15)); 1351 } 1352 1353 @Test(groups={"tck"}) 1354 public void test_minusYears_long_negative() { 1355 LocalDate t = TEST_2007_07_15.minusYears(-1); 1356 assertEquals(t, LocalDate.of(2008, 7, 15)); 1357 } 1358 1359 @Test(groups={"tck"}) 1360 public void test_minusYears_long_adjustDay() { 1361 LocalDate t = LocalDate.of(2008, 2, 29).minusYears(1); 1362 LocalDate expected = LocalDate.of(2007, 2, 28); 1363 assertEquals(t, expected); 1364 } 1365 1366 @Test(groups={"tck"}) 1367 public void test_minusYears_long_big() { 1368 long years = 20L + Year.MAX_VALUE; 1369 LocalDate test = LocalDate.of(40, 6, 1).minusYears(years); 1370 assertEquals(test, LocalDate.of((int) (40L - years), 6, 1)); 1371 } 1372 1373 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1374 public void test_minusYears_long_invalidTooLarge() { 1375 LocalDate test = LocalDate.of(Year.MAX_VALUE, 6, 1); 1376 test.minusYears(-1); 1377 } 1378 1379 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1380 public void test_minusYears_long_invalidTooLargeMaxAddMax() { 1381 LocalDate test = LocalDate.of(Year.MAX_VALUE, 12, 1); 1382 test.minusYears(Long.MAX_VALUE); 1383 } 1384 1385 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1386 public void test_minusYears_long_invalidTooLargeMaxAddMin() { 1387 LocalDate test = LocalDate.of(Year.MAX_VALUE, 12, 1); 1388 test.minusYears(Long.MIN_VALUE); 1389 } 1390 1391 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1392 public void test_minusYears_long_invalidTooSmall() { 1393 LocalDate.of(Year.MIN_VALUE, 1, 1).minusYears(1); 1394 } 1395 1396 //----------------------------------------------------------------------- 1397 // minusMonths() 1398 //----------------------------------------------------------------------- 1399 @Test(groups={"tck"}) 1400 public void test_minusMonths_long_normal() { 1401 LocalDate t = TEST_2007_07_15.minusMonths(1); 1402 assertEquals(t, LocalDate.of(2007, 6, 15)); 1403 } 1404 1405 @Test(groups={"tck"}) 1406 public void test_minusMonths_long_overYears() { 1407 LocalDate t = TEST_2007_07_15.minusMonths(25); 1408 assertEquals(t, LocalDate.of(2005, 6, 15)); 1409 } 1410 1411 @Test(groups={"tck"}) 1412 public void test_minusMonths_long_negative() { 1413 LocalDate t = TEST_2007_07_15.minusMonths(-1); 1414 assertEquals(t, LocalDate.of(2007, 8, 15)); 1415 } 1416 1417 @Test(groups={"tck"}) 1418 public void test_minusMonths_long_negativeAcrossYear() { 1419 LocalDate t = TEST_2007_07_15.minusMonths(-7); 1420 assertEquals(t, LocalDate.of(2008, 2, 15)); 1421 } 1422 1423 @Test(groups={"tck"}) 1424 public void test_minusMonths_long_negativeOverYears() { 1425 LocalDate t = TEST_2007_07_15.minusMonths(-31); 1426 assertEquals(t, LocalDate.of(2010, 2, 15)); 1427 } 1428 1429 @Test(groups={"tck"}) 1430 public void test_minusMonths_long_adjustDayFromLeapYear() { 1431 LocalDate t = LocalDate.of(2008, 2, 29).minusMonths(12); 1432 LocalDate expected = LocalDate.of(2007, 2, 28); 1433 assertEquals(t, expected); 1434 } 1435 1436 @Test(groups={"tck"}) 1437 public void test_minusMonths_long_adjustDayFromMonthLength() { 1438 LocalDate t = LocalDate.of(2007, 3, 31).minusMonths(1); 1439 LocalDate expected = LocalDate.of(2007, 2, 28); 1440 assertEquals(t, expected); 1441 } 1442 1443 @Test(groups={"tck"}) 1444 public void test_minusMonths_long_big() { 1445 long months = 20L + Integer.MAX_VALUE; 1446 LocalDate test = LocalDate.of(40, 6, 1).minusMonths(months); 1447 assertEquals(test, LocalDate.of((int) (40L - months / 12), 6 - (int) (months % 12), 1)); 1448 } 1449 1450 @Test(expectedExceptions={DateTimeException.class}, groups={"tck"}) 1451 public void test_minusMonths_long_invalidTooLarge() { 1452 LocalDate.of(Year.MAX_VALUE, 12, 1).minusMonths(-1); 1453 } 1454 1455 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1456 public void test_minusMonths_long_invalidTooLargeMaxAddMax() { 1457 LocalDate test = LocalDate.of(Year.MAX_VALUE, 12, 1); 1458 test.minusMonths(Long.MAX_VALUE); 1459 } 1460 1461 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1462 public void test_minusMonths_long_invalidTooLargeMaxAddMin() { 1463 LocalDate test = LocalDate.of(Year.MAX_VALUE, 12, 1); 1464 test.minusMonths(Long.MIN_VALUE); 1465 } 1466 1467 @Test(expectedExceptions={DateTimeException.class}, groups={"tck"}) 1468 public void test_minusMonths_long_invalidTooSmall() { 1469 LocalDate.of(Year.MIN_VALUE, 1, 1).minusMonths(1); 1470 } 1471 1472 @Test(groups={"tck"}) 1473 public void test_minusWeeks_normal() { 1474 LocalDate t = TEST_2007_07_15.minusWeeks(1); 1475 assertEquals(t, LocalDate.of(2007, 7, 8)); 1476 } 1477 1478 @Test(groups={"tck"}) 1479 public void test_minusWeeks_overMonths() { 1480 LocalDate t = TEST_2007_07_15.minusWeeks(9); 1481 assertEquals(t, LocalDate.of(2007, 5, 13)); 1482 } 1483 1484 @Test(groups={"tck"}) 1485 public void test_minusWeeks_overYears() { 1486 LocalDate t = LocalDate.of(2008, 7, 13).minusWeeks(52); 1487 assertEquals(t, TEST_2007_07_15); 1488 } 1489 1490 @Test(groups={"tck"}) 1491 public void test_minusWeeks_overLeapYears() { 1492 LocalDate t = TEST_2007_07_15.minusYears(-1).minusWeeks(104); 1493 assertEquals(t, LocalDate.of(2006, 7, 18)); 1494 } 1495 1496 @Test(groups={"tck"}) 1497 public void test_minusWeeks_negative() { 1498 LocalDate t = TEST_2007_07_15.minusWeeks(-1); 1499 assertEquals(t, LocalDate.of(2007, 7, 22)); 1500 } 1501 1502 @Test(groups={"tck"}) 1503 public void test_minusWeeks_negativeAcrossYear() { 1504 LocalDate t = TEST_2007_07_15.minusWeeks(-28); 1505 assertEquals(t, LocalDate.of(2008, 1, 27)); 1506 } 1507 1508 @Test(groups={"tck"}) 1509 public void test_minusWeeks_negativeOverYears() { 1510 LocalDate t = TEST_2007_07_15.minusWeeks(-104); 1511 assertEquals(t, LocalDate.of(2009, 7, 12)); 1512 } 1513 1514 @Test(groups={"tck"}) 1515 public void test_minusWeeks_maximum() { 1516 LocalDate t = LocalDate.of(Year.MAX_VALUE, 12, 24).minusWeeks(-1); 1517 LocalDate expected = LocalDate.of(Year.MAX_VALUE, 12, 31); 1518 assertEquals(t, expected); 1519 } 1520 1521 @Test(groups={"tck"}) 1522 public void test_minusWeeks_minimum() { 1523 LocalDate t = LocalDate.of(Year.MIN_VALUE, 1, 8).minusWeeks(1); 1524 LocalDate expected = LocalDate.of(Year.MIN_VALUE, 1, 1); 1525 assertEquals(t, expected); 1526 } 1527 1528 @Test(expectedExceptions={DateTimeException.class}, groups={"tck"}) 1529 public void test_minusWeeks_invalidTooLarge() { 1530 LocalDate.of(Year.MAX_VALUE, 12, 25).minusWeeks(-1); 1531 } 1532 1533 @Test(expectedExceptions={DateTimeException.class}, groups={"tck"}) 1534 public void test_minusWeeks_invalidTooSmall() { 1535 LocalDate.of(Year.MIN_VALUE, 1, 7).minusWeeks(1); 1536 } 1537 1538 @Test(expectedExceptions={ArithmeticException.class}, groups={"tck"}) 1539 public void test_minusWeeks_invalidMaxMinusMax() { 1540 LocalDate.of(Year.MAX_VALUE, 12, 25).minusWeeks(Long.MAX_VALUE); 1541 } 1542 1543 @Test(expectedExceptions={ArithmeticException.class}, groups={"tck"}) 1544 public void test_minusWeeks_invalidMaxMinusMin() { 1545 LocalDate.of(Year.MAX_VALUE, 12, 25).minusWeeks(Long.MIN_VALUE); 1546 } 1547 1548 @Test(groups={"tck"}) 1549 public void test_minusDays_normal() { 1550 LocalDate t = TEST_2007_07_15.minusDays(1); 1551 assertEquals(t, LocalDate.of(2007, 7, 14)); 1552 } 1553 1554 @Test(groups={"tck"}) 1555 public void test_minusDays_overMonths() { 1556 LocalDate t = TEST_2007_07_15.minusDays(62); 1557 assertEquals(t, LocalDate.of(2007, 5, 14)); 1558 } 1559 1560 @Test(groups={"tck"}) 1561 public void test_minusDays_overYears() { 1562 LocalDate t = LocalDate.of(2008, 7, 16).minusDays(367); 1563 assertEquals(t, TEST_2007_07_15); 1564 } 1565 1566 @Test(groups={"tck"}) 1567 public void test_minusDays_overLeapYears() { 1568 LocalDate t = TEST_2007_07_15.plusYears(2).minusDays(365 + 366); 1569 assertEquals(t, TEST_2007_07_15); 1570 } 1571 1572 @Test(groups={"tck"}) 1573 public void test_minusDays_negative() { 1574 LocalDate t = TEST_2007_07_15.minusDays(-1); 1575 assertEquals(t, LocalDate.of(2007, 7, 16)); 1576 } 1577 1578 @Test(groups={"tck"}) 1579 public void test_minusDays_negativeAcrossYear() { 1580 LocalDate t = TEST_2007_07_15.minusDays(-169); 1581 assertEquals(t, LocalDate.of(2007, 12, 31)); 1582 } 1583 1584 @Test(groups={"tck"}) 1585 public void test_minusDays_negativeOverYears() { 1586 LocalDate t = TEST_2007_07_15.minusDays(-731); 1587 assertEquals(t, LocalDate.of(2009, 7, 15)); 1588 } 1589 1590 @Test(groups={"tck"}) 1591 public void test_minusDays_maximum() { 1592 LocalDate t = LocalDate.of(Year.MAX_VALUE, 12, 30).minusDays(-1); 1593 LocalDate expected = LocalDate.of(Year.MAX_VALUE, 12, 31); 1594 assertEquals(t, expected); 1595 } 1596 1597 @Test(groups={"tck"}) 1598 public void test_minusDays_minimum() { 1599 LocalDate t = LocalDate.of(Year.MIN_VALUE, 1, 2).minusDays(1); 1600 LocalDate expected = LocalDate.of(Year.MIN_VALUE, 1, 1); 1601 assertEquals(t, expected); 1602 } 1603 1604 @Test(expectedExceptions={DateTimeException.class}, groups={"tck"}) 1605 public void test_minusDays_invalidTooLarge() { 1606 LocalDate.of(Year.MAX_VALUE, 12, 31).minusDays(-1); 1607 } 1608 1609 @Test(expectedExceptions={DateTimeException.class}, groups={"tck"}) 1610 public void test_minusDays_invalidTooSmall() { 1611 LocalDate.of(Year.MIN_VALUE, 1, 1).minusDays(1); 1612 } 1613 1614 @Test(expectedExceptions=ArithmeticException.class, groups={"tck"}) 1615 public void test_minusDays_overflowTooLarge() { 1616 LocalDate.of(Year.MAX_VALUE, 12, 31).minusDays(Long.MIN_VALUE); 1617 } 1618 1619 @Test(expectedExceptions=ArithmeticException.class, groups={"tck"}) 1620 public void test_minusDays_overflowTooSmall() { 1621 LocalDate.of(Year.MIN_VALUE, 1, 1).minusDays(Long.MAX_VALUE); 1622 } 1623 1624 //----------------------------------------------------------------------- 1625 // periodUntil(ChronoLocalDate) 1626 //----------------------------------------------------------------------- 1627 @DataProvider(name="periodUntil") 1628 Object[][] data_periodUntil() { 1629 return new Object[][] { 1630 {2010, 1, 1, 2010, 1, 1, 0, 0, 0}, 1631 {2010, 1, 1, 2010, 1, 2, 0, 0, 1}, 1632 {2010, 1, 1, 2010, 1, 31, 0, 0, 30}, 1633 {2010, 1, 1, 2010, 2, 1, 0, 1, 0}, 1634 {2010, 1, 1, 2010, 2, 28, 0, 1, 27}, 1635 {2010, 1, 1, 2010, 3, 1, 0, 2, 0}, 1636 {2010, 1, 1, 2010, 12, 31, 0, 11, 30}, 1637 {2010, 1, 1, 2011, 1, 1, 1, 0, 0}, 1638 {2010, 1, 1, 2011, 12, 31, 1, 11, 30}, 1639 {2010, 1, 1, 2012, 1, 1, 2, 0, 0}, 1640 1641 {2010, 1, 10, 2010, 1, 1, 0, 0, -9}, 1642 {2010, 1, 10, 2010, 1, 2, 0, 0, -8}, 1643 {2010, 1, 10, 2010, 1, 9, 0, 0, -1}, 1644 {2010, 1, 10, 2010, 1, 10, 0, 0, 0}, 1645 {2010, 1, 10, 2010, 1, 11, 0, 0, 1}, 1646 {2010, 1, 10, 2010, 1, 31, 0, 0, 21}, 1647 {2010, 1, 10, 2010, 2, 1, 0, 0, 22}, 1648 {2010, 1, 10, 2010, 2, 9, 0, 0, 30}, 1649 {2010, 1, 10, 2010, 2, 10, 0, 1, 0}, 1650 {2010, 1, 10, 2010, 2, 28, 0, 1, 18}, 1651 {2010, 1, 10, 2010, 3, 1, 0, 1, 19}, 1652 {2010, 1, 10, 2010, 3, 9, 0, 1, 27}, 1653 {2010, 1, 10, 2010, 3, 10, 0, 2, 0}, 1654 {2010, 1, 10, 2010, 12, 31, 0, 11, 21}, 1655 {2010, 1, 10, 2011, 1, 1, 0, 11, 22}, 1656 {2010, 1, 10, 2011, 1, 9, 0, 11, 30}, 1657 {2010, 1, 10, 2011, 1, 10, 1, 0, 0}, 1658 1659 {2010, 3, 30, 2011, 5, 1, 1, 1, 1}, 1660 {2010, 4, 30, 2011, 5, 1, 1, 0, 1}, 1661 1662 {2010, 2, 28, 2012, 2, 27, 1, 11, 30}, 1663 {2010, 2, 28, 2012, 2, 28, 2, 0, 0}, 1664 {2010, 2, 28, 2012, 2, 29, 2, 0, 1}, 1665 1666 {2012, 2, 28, 2014, 2, 27, 1, 11, 30}, 1667 {2012, 2, 28, 2014, 2, 28, 2, 0, 0}, 1668 {2012, 2, 28, 2014, 3, 1, 2, 0, 1}, 1669 1670 {2012, 2, 29, 2014, 2, 28, 1, 11, 30}, 1671 {2012, 2, 29, 2014, 3, 1, 2, 0, 1}, 1672 {2012, 2, 29, 2014, 3, 2, 2, 0, 2}, 1673 1674 {2012, 2, 29, 2016, 2, 28, 3, 11, 30}, 1675 {2012, 2, 29, 2016, 2, 29, 4, 0, 0}, 1676 {2012, 2, 29, 2016, 3, 1, 4, 0, 1}, 1677 1678 {2010, 1, 1, 2009, 12, 31, 0, 0, -1}, 1679 {2010, 1, 1, 2009, 12, 30, 0, 0, -2}, 1680 {2010, 1, 1, 2009, 12, 2, 0, 0, -30}, 1681 {2010, 1, 1, 2009, 12, 1, 0, -1, 0}, 1682 {2010, 1, 1, 2009, 11, 30, 0, -1, -1}, 1683 {2010, 1, 1, 2009, 11, 2, 0, -1, -29}, 1684 {2010, 1, 1, 2009, 11, 1, 0, -2, 0}, 1685 {2010, 1, 1, 2009, 1, 2, 0, -11, -30}, 1686 {2010, 1, 1, 2009, 1, 1, -1, 0, 0}, 1687 1688 {2010, 1, 15, 2010, 1, 15, 0, 0, 0}, 1689 {2010, 1, 15, 2010, 1, 14, 0, 0, -1}, 1690 {2010, 1, 15, 2010, 1, 1, 0, 0, -14}, 1691 {2010, 1, 15, 2009, 12, 31, 0, 0, -15}, 1692 {2010, 1, 15, 2009, 12, 16, 0, 0, -30}, 1693 {2010, 1, 15, 2009, 12, 15, 0, -1, 0}, 1694 {2010, 1, 15, 2009, 12, 14, 0, -1, -1}, 1695 1696 {2010, 2, 28, 2009, 3, 1, 0, -11, -27}, 1697 {2010, 2, 28, 2009, 2, 28, -1, 0, 0}, 1698 {2010, 2, 28, 2009, 2, 27, -1, 0, -1}, 1699 1700 {2010, 2, 28, 2008, 2, 29, -1, -11, -28}, 1701 {2010, 2, 28, 2008, 2, 28, -2, 0, 0}, 1702 {2010, 2, 28, 2008, 2, 27, -2, 0, -1}, 1703 1704 {2012, 2, 29, 2009, 3, 1, -2, -11, -28}, 1705 {2012, 2, 29, 2009, 2, 28, -3, 0, -1}, 1706 {2012, 2, 29, 2009, 2, 27, -3, 0, -2}, 1707 1708 {2012, 2, 29, 2008, 3, 1, -3, -11, -28}, 1709 {2012, 2, 29, 2008, 2, 29, -4, 0, 0}, 1710 {2012, 2, 29, 2008, 2, 28, -4, 0, -1}, 1711 }; 1712 } 1713 1714 @Test(dataProvider="periodUntil") 1715 public void test_periodUntil_LocalDate(int y1, int m1, int d1, int y2, int m2, int d2, int ye, int me, int de) { 1716 LocalDate start = LocalDate.of(y1, m1, d1); 1717 LocalDate end = LocalDate.of(y2, m2, d2); 1718 Period test = start.periodUntil(end); 1719 assertEquals(test.getYears(), ye); 1720 assertEquals(test.getMonths(), me); 1721 assertEquals(test.getDays(), de); 1722 } 1723 1724 @Test 1725 public void test_periodUntil_LocalDate_max() { 1726 int years = Math.toIntExact((long) Year.MAX_VALUE - (long) Year.MIN_VALUE); 1727 assertEquals(LocalDate.MIN.periodUntil(LocalDate.MAX), Period.of(years, 11, 30)); 1728 } 1729 1730 @Test(expectedExceptions=NullPointerException.class) 1731 public void test_periodUntil_LocalDate_null() { 1732 TEST_2007_07_15.periodUntil(null); 1733 } 1734 1735 //----------------------------------------------------------------------- 1736 // atTime() 1737 //----------------------------------------------------------------------- 1738 @Test(groups={"tck"}) 1739 public void test_atTime_LocalTime() { 1740 LocalDate t = LocalDate.of(2008, 6, 30); 1741 assertEquals(t.atTime(LocalTime.of(11, 30)), LocalDateTime.of(2008, 6, 30, 11, 30)); 1742 } 1743 1744 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 1745 public void test_atTime_LocalTime_null() { 1746 LocalDate t = LocalDate.of(2008, 6, 30); 1747 t.atTime((LocalTime) null); 1748 } 1749 1750 //------------------------------------------------------------------------- 1751 @Test(groups={"tck"}) 1752 public void test_atTime_int_int() { 1753 LocalDate t = LocalDate.of(2008, 6, 30); 1754 assertEquals(t.atTime(11, 30), LocalDateTime.of(2008, 6, 30, 11, 30)); 1755 } 1756 1757 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1758 public void test_atTime_int_int_hourTooSmall() { 1759 LocalDate t = LocalDate.of(2008, 6, 30); 1760 t.atTime(-1, 30); 1761 } 1762 1763 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1764 public void test_atTime_int_int_hourTooBig() { 1765 LocalDate t = LocalDate.of(2008, 6, 30); 1766 t.atTime(24, 30); 1767 } 1768 1769 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1770 public void test_atTime_int_int_minuteTooSmall() { 1771 LocalDate t = LocalDate.of(2008, 6, 30); 1772 t.atTime(11, -1); 1773 } 1774 1775 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1776 public void test_atTime_int_int_minuteTooBig() { 1777 LocalDate t = LocalDate.of(2008, 6, 30); 1778 t.atTime(11, 60); 1779 } 1780 1781 @Test(groups={"tck"}) 1782 public void test_atTime_int_int_int() { 1783 LocalDate t = LocalDate.of(2008, 6, 30); 1784 assertEquals(t.atTime(11, 30, 40), LocalDateTime.of(2008, 6, 30, 11, 30, 40)); 1785 } 1786 1787 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1788 public void test_atTime_int_int_int_hourTooSmall() { 1789 LocalDate t = LocalDate.of(2008, 6, 30); 1790 t.atTime(-1, 30, 40); 1791 } 1792 1793 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1794 public void test_atTime_int_int_int_hourTooBig() { 1795 LocalDate t = LocalDate.of(2008, 6, 30); 1796 t.atTime(24, 30, 40); 1797 } 1798 1799 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1800 public void test_atTime_int_int_int_minuteTooSmall() { 1801 LocalDate t = LocalDate.of(2008, 6, 30); 1802 t.atTime(11, -1, 40); 1803 } 1804 1805 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1806 public void test_atTime_int_int_int_minuteTooBig() { 1807 LocalDate t = LocalDate.of(2008, 6, 30); 1808 t.atTime(11, 60, 40); 1809 } 1810 1811 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1812 public void test_atTime_int_int_int_secondTooSmall() { 1813 LocalDate t = LocalDate.of(2008, 6, 30); 1814 t.atTime(11, 30, -1); 1815 } 1816 1817 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1818 public void test_atTime_int_int_int_secondTooBig() { 1819 LocalDate t = LocalDate.of(2008, 6, 30); 1820 t.atTime(11, 30, 60); 1821 } 1822 1823 @Test(groups={"tck"}) 1824 public void test_atTime_int_int_int_int() { 1825 LocalDate t = LocalDate.of(2008, 6, 30); 1826 assertEquals(t.atTime(11, 30, 40, 50), LocalDateTime.of(2008, 6, 30, 11, 30, 40, 50)); 1827 } 1828 1829 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1830 public void test_atTime_int_int_int_int_hourTooSmall() { 1831 LocalDate t = LocalDate.of(2008, 6, 30); 1832 t.atTime(-1, 30, 40, 50); 1833 } 1834 1835 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1836 public void test_atTime_int_int_int_int_hourTooBig() { 1837 LocalDate t = LocalDate.of(2008, 6, 30); 1838 t.atTime(24, 30, 40, 50); 1839 } 1840 1841 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1842 public void test_atTime_int_int_int_int_minuteTooSmall() { 1843 LocalDate t = LocalDate.of(2008, 6, 30); 1844 t.atTime(11, -1, 40, 50); 1845 } 1846 1847 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1848 public void test_atTime_int_int_int_int_minuteTooBig() { 1849 LocalDate t = LocalDate.of(2008, 6, 30); 1850 t.atTime(11, 60, 40, 50); 1851 } 1852 1853 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1854 public void test_atTime_int_int_int_int_secondTooSmall() { 1855 LocalDate t = LocalDate.of(2008, 6, 30); 1856 t.atTime(11, 30, -1, 50); 1857 } 1858 1859 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1860 public void test_atTime_int_int_int_int_secondTooBig() { 1861 LocalDate t = LocalDate.of(2008, 6, 30); 1862 t.atTime(11, 30, 60, 50); 1863 } 1864 1865 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1866 public void test_atTime_int_int_int_int_nanoTooSmall() { 1867 LocalDate t = LocalDate.of(2008, 6, 30); 1868 t.atTime(11, 30, 40, -1); 1869 } 1870 1871 @Test(expectedExceptions=DateTimeException.class, groups={"tck"}) 1872 public void test_atTime_int_int_int_int_nanoTooBig() { 1873 LocalDate t = LocalDate.of(2008, 6, 30); 1874 t.atTime(11, 30, 40, 1000000000); 1875 } 1876 1877 //----------------------------------------------------------------------- 1878 @Test(groups={"tck"}) 1879 public void test_atTime_OffsetTime() { 1880 LocalDate t = LocalDate.of(2008, 6, 30); 1881 assertEquals(t.atTime(OffsetTime.of(11, 30, 0, 0, OFFSET_PONE)), OffsetDateTime.of(2008, 6, 30, 11, 30, 0, 0, OFFSET_PONE)); 1882 } 1883 1884 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 1885 public void test_atTime_OffsetTime_null() { 1886 LocalDate t = LocalDate.of(2008, 6, 30); 1887 t.atTime((OffsetTime) null); 1888 } 1889 1890 //----------------------------------------------------------------------- 1891 // atStartOfDay() 1892 //----------------------------------------------------------------------- 1893 @DataProvider(name="atStartOfDay") 1894 Object[][] data_atStartOfDay() { 1895 return new Object[][] { 1896 {LocalDate.of(2008, 6, 30), LocalDateTime.of(2008, 6, 30, 0, 0)}, 1897 {LocalDate.of(-12, 6, 30), LocalDateTime.of(-12, 6, 30, 0, 0)}, 1898 }; 1899 } 1900 1901 @Test(dataProvider="atStartOfDay") 1902 public void test_atStartOfDay(LocalDate test, LocalDateTime expected) { 1903 assertEquals(test.atStartOfDay(), expected); 1904 } 1905 1906 //----------------------------------------------------------------------- 1907 // atStartOfDay(ZoneId) 1908 //----------------------------------------------------------------------- 1909 @DataProvider(name="atStartOfDayZoneId") 1910 Object[][] data_atStartOfDayZoneId() { 1911 return new Object[][] { 1912 {LocalDate.of(2008, 6, 30), ZONE_PARIS, ZonedDateTime.of(LocalDateTime.of(2008, 6, 30, 0, 0), ZONE_PARIS)}, 1913 {LocalDate.of(2008, 6, 30), OFFSET_PONE, ZonedDateTime.of(LocalDateTime.of(2008, 6, 30, 0, 0), OFFSET_PONE)}, 1914 {LocalDate.of(2007, 4, 1), ZONE_GAZA, ZonedDateTime.of(LocalDateTime.of(2007, 4, 1, 1, 0), ZONE_GAZA)}, 1915 }; 1916 } 1917 1918 @Test(dataProvider="atStartOfDayZoneId") 1919 public void test_atStartOfDay_ZoneId(LocalDate test, ZoneId zone, ZonedDateTime expected) { 1920 assertEquals(test.atStartOfDay(zone), expected); 1921 } 1922 1923 @Test(expectedExceptions=NullPointerException.class) 1924 public void test_atStartOfDay_ZoneId_null() { 1925 LocalDate t = LocalDate.of(2008, 6, 30); 1926 t.atStartOfDay((ZoneId) null); 1927 } 1928 1929 //----------------------------------------------------------------------- 1930 // toEpochDay() 1931 //----------------------------------------------------------------------- 1932 @Test(groups={"tck"}) 1933 public void test_toEpochDay() { 1934 long date_0000_01_01 = -678941 - 40587; 1935 1936 LocalDate test = LocalDate.of(0, 1, 1); 1937 for (long i = date_0000_01_01; i < 700000; i++) { 1938 assertEquals(test.toEpochDay(), i); 1939 test = next(test); 1940 } 1941 test = LocalDate.of(0, 1, 1); 1942 for (long i = date_0000_01_01; i > -2000000; i--) { 1943 assertEquals(test.toEpochDay(), i); 1944 test = previous(test); 1945 } 1946 1947 assertEquals(LocalDate.of(1858, 11, 17).toEpochDay(), -40587); 1948 assertEquals(LocalDate.of(1, 1, 1).toEpochDay(), -678575 - 40587); 1949 assertEquals(LocalDate.of(1995, 9, 27).toEpochDay(), 49987 - 40587); 1950 assertEquals(LocalDate.of(1970, 1, 1).toEpochDay(), 0); 1951 assertEquals(LocalDate.of(-1, 12, 31).toEpochDay(), -678942 - 40587); 1952 } 1953 1954 //----------------------------------------------------------------------- 1955 // compareTo() 1956 //----------------------------------------------------------------------- 1957 @Test(groups={"tck"}) 1958 public void test_comparisons() { 1959 doTest_comparisons_LocalDate( 1960 LocalDate.of(Year.MIN_VALUE, 1, 1), 1961 LocalDate.of(Year.MIN_VALUE, 12, 31), 1962 LocalDate.of(-1, 1, 1), 1963 LocalDate.of(-1, 12, 31), 1964 LocalDate.of(0, 1, 1), 1965 LocalDate.of(0, 12, 31), 1966 LocalDate.of(1, 1, 1), 1967 LocalDate.of(1, 12, 31), 1968 LocalDate.of(2006, 1, 1), 1969 LocalDate.of(2006, 12, 31), 1970 LocalDate.of(2007, 1, 1), 1971 LocalDate.of(2007, 12, 31), 1972 LocalDate.of(2008, 1, 1), 1973 LocalDate.of(2008, 2, 29), 1974 LocalDate.of(2008, 12, 31), 1975 LocalDate.of(Year.MAX_VALUE, 1, 1), 1976 LocalDate.of(Year.MAX_VALUE, 12, 31) 1977 ); 1978 } 1979 1980 void doTest_comparisons_LocalDate(LocalDate... localDates) { 1981 for (int i = 0; i < localDates.length; i++) { 1982 LocalDate a = localDates[i]; 1983 for (int j = 0; j < localDates.length; j++) { 1984 LocalDate b = localDates[j]; 1985 if (i < j) { 1986 assertTrue(a.compareTo(b) < 0, a + " <=> " + b); 1987 assertEquals(a.isBefore(b), true, a + " <=> " + b); 1988 assertEquals(a.isAfter(b), false, a + " <=> " + b); 1989 assertEquals(a.equals(b), false, a + " <=> " + b); 1990 } else if (i > j) { 1991 assertTrue(a.compareTo(b) > 0, a + " <=> " + b); 1992 assertEquals(a.isBefore(b), false, a + " <=> " + b); 1993 assertEquals(a.isAfter(b), true, a + " <=> " + b); 1994 assertEquals(a.equals(b), false, a + " <=> " + b); 1995 } else { 1996 assertEquals(a.compareTo(b), 0, a + " <=> " + b); 1997 assertEquals(a.isBefore(b), false, a + " <=> " + b); 1998 assertEquals(a.isAfter(b), false, a + " <=> " + b); 1999 assertEquals(a.equals(b), true, a + " <=> " + b); 2000 } 2001 } 2002 } 2003 } 2004 2005 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 2006 public void test_compareTo_ObjectNull() { 2007 TEST_2007_07_15.compareTo(null); 2008 } 2009 2010 @Test(groups={"tck"}) 2011 public void test_isBefore() { 2012 assertTrue(TEST_2007_07_15.isBefore(LocalDate.of(2007, 07, 16))); 2013 assertFalse(TEST_2007_07_15.isBefore(LocalDate.of(2007, 07, 14))); 2014 assertFalse(TEST_2007_07_15.isBefore(TEST_2007_07_15)); 2015 } 2016 2017 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 2018 public void test_isBefore_ObjectNull() { 2019 TEST_2007_07_15.isBefore(null); 2020 } 2021 2022 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 2023 public void test_isAfter_ObjectNull() { 2024 TEST_2007_07_15.isAfter(null); 2025 } 2026 2027 @Test(groups={"tck"}) 2028 public void test_isAfter() { 2029 assertTrue(TEST_2007_07_15.isAfter(LocalDate.of(2007, 07, 14))); 2030 assertFalse(TEST_2007_07_15.isAfter(LocalDate.of(2007, 07, 16))); 2031 assertFalse(TEST_2007_07_15.isAfter(TEST_2007_07_15)); 2032 } 2033 2034 @Test(expectedExceptions=ClassCastException.class, groups={"tck"}) 2035 @SuppressWarnings({"unchecked", "rawtypes"}) 2036 public void compareToNonLocalDate() { 2037 Comparable c = TEST_2007_07_15; 2038 c.compareTo(new Object()); 2039 } 2040 2041 //----------------------------------------------------------------------- 2042 // equals() 2043 //----------------------------------------------------------------------- 2044 @Test(dataProvider="sampleDates" , groups={"tck"}) 2045 public void test_equals_true(int y, int m, int d) { 2046 LocalDate a = LocalDate.of(y, m, d); 2047 LocalDate b = LocalDate.of(y, m, d); 2048 assertEquals(a.equals(b), true); 2049 } 2050 @Test(dataProvider="sampleDates", groups={"tck"}) 2051 public void test_equals_false_year_differs(int y, int m, int d) { 2052 LocalDate a = LocalDate.of(y, m, d); 2053 LocalDate b = LocalDate.of(y + 1, m, d); 2054 assertEquals(a.equals(b), false); 2055 } 2056 @Test(dataProvider="sampleDates", groups={"tck"}) 2057 public void test_equals_false_month_differs(int y, int m, int d) { 2058 LocalDate a = LocalDate.of(y, m, d); 2059 LocalDate b = LocalDate.of(y, m + 1, d); 2060 assertEquals(a.equals(b), false); 2061 } 2062 @Test(dataProvider="sampleDates", groups={"tck"}) 2063 public void test_equals_false_day_differs(int y, int m, int d) { 2064 LocalDate a = LocalDate.of(y, m, d); 2065 LocalDate b = LocalDate.of(y, m, d + 1); 2066 assertEquals(a.equals(b), false); 2067 } 2068 2069 @Test(groups={"tck"}) 2070 public void test_equals_itself_true() { 2071 assertEquals(TEST_2007_07_15.equals(TEST_2007_07_15), true); 2072 } 2073 2074 @Test(groups={"tck"}) 2075 public void test_equals_string_false() { 2076 assertEquals(TEST_2007_07_15.equals("2007-07-15"), false); 2077 } 2078 2079 @Test(groups={"tck"}) 2080 public void test_equals_null_false() { 2081 assertEquals(TEST_2007_07_15.equals(null), false); 2082 } 2083 2084 //----------------------------------------------------------------------- 2085 // hashCode() 2086 //----------------------------------------------------------------------- 2087 @Test(dataProvider="sampleDates", groups={"tck"}) 2088 public void test_hashCode(int y, int m, int d) { 2089 LocalDate a = LocalDate.of(y, m, d); 2090 assertEquals(a.hashCode(), a.hashCode()); 2091 LocalDate b = LocalDate.of(y, m, d); 2092 assertEquals(a.hashCode(), b.hashCode()); 2093 } 2094 2095 //----------------------------------------------------------------------- 2096 // toString() 2097 //----------------------------------------------------------------------- 2098 @DataProvider(name="sampleToString") 2099 Object[][] provider_sampleToString() { 2100 return new Object[][] { 2101 {2008, 7, 5, "2008-07-05"}, 2102 {2007, 12, 31, "2007-12-31"}, 2103 {999, 12, 31, "0999-12-31"}, 2104 {-1, 1, 2, "-0001-01-02"}, 2105 {9999, 12, 31, "9999-12-31"}, 2106 {-9999, 12, 31, "-9999-12-31"}, 2107 {10000, 1, 1, "+10000-01-01"}, 2108 {-10000, 1, 1, "-10000-01-01"}, 2109 {12345678, 1, 1, "+12345678-01-01"}, 2110 {-12345678, 1, 1, "-12345678-01-01"}, 2111 }; 2112 } 2113 2114 @Test(dataProvider="sampleToString", groups={"tck"}) 2115 public void test_toString(int y, int m, int d, String expected) { 2116 LocalDate t = LocalDate.of(y, m, d); 2117 String str = t.toString(); 2118 assertEquals(str, expected); 2119 } 2120 2121 //----------------------------------------------------------------------- 2122 // toString(DateTimeFormatter) 2123 //----------------------------------------------------------------------- 2124 @Test(groups={"tck"}) 2125 public void test_toString_formatter() { 2126 DateTimeFormatter f = DateTimeFormatter.ofPattern("y M d"); 2127 String t = LocalDate.of(2010, 12, 3).toString(f); 2128 assertEquals(t, "2010 12 3"); 2129 } 2130 2131 @Test(expectedExceptions=NullPointerException.class, groups={"tck"}) 2132 public void test_toString_formatter_null() { 2133 LocalDate.of(2010, 12, 3).toString(null); 2134 } 2135 2136 }