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 }