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.io.IOException;
84 import java.util.ArrayList;
85 import java.util.Arrays;
86 import java.util.List;
87
88 import java.time.Clock;
89 import java.time.DateTimeException;
90 import java.time.DayOfWeek;
91 import java.time.Instant;
92 import java.time.LocalDate;
93 import java.time.LocalDateTime;
94 import java.time.LocalTime;
95 import java.time.Month;
96 import java.time.ZoneId;
97 import java.time.ZoneOffset;
98 import java.time.ZonedDateTime;
99 import java.time.format.DateTimeFormatter;
100 import java.time.format.DateTimeFormatters;
101 import java.time.format.DateTimeParseException;
102 import java.time.temporal.ChronoField;
103 import java.time.temporal.ChronoUnit;
104 import java.time.temporal.ISOChrono;
105 import java.time.temporal.JulianFields;
106 import java.time.temporal.OffsetDate;
107 import java.time.temporal.Queries;
108 import java.time.temporal.Temporal;
109 import java.time.temporal.TemporalAccessor;
110 import java.time.temporal.TemporalAdjuster;
111 import java.time.temporal.TemporalField;
112 import java.time.temporal.TemporalUnit;
113 import java.time.temporal.Year;
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 = DateTimeFormatters.pattern("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 = DateTimeFormatters.pattern("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 @Test
641 public void test_query_chrono() {
642 assertEquals(TEST_2007_07_15.query(Queries.chrono()), ISOChrono.INSTANCE);
643 assertEquals(Queries.chrono().queryFrom(TEST_2007_07_15), ISOChrono.INSTANCE);
644 }
645
646 @Test
647 public void test_query_zoneId() {
648 assertEquals(TEST_2007_07_15.query(Queries.zoneId()), null);
649 assertEquals(Queries.zoneId().queryFrom(TEST_2007_07_15), null);
650 }
651
652 @Test
653 public void test_query_precision() {
654 assertEquals(TEST_2007_07_15.query(Queries.precision()), ChronoUnit.DAYS);
655 assertEquals(Queries.precision().queryFrom(TEST_2007_07_15), ChronoUnit.DAYS);
656 }
657
658 @Test
659 public void test_query_offset() {
660 assertEquals(TEST_2007_07_15.query(Queries.offset()), null);
661 assertEquals(Queries.offset().queryFrom(TEST_2007_07_15), null);
662 }
663
664 @Test
665 public void test_query_zone() {
666 assertEquals(TEST_2007_07_15.query(Queries.zone()), null);
667 assertEquals(Queries.zone().queryFrom(TEST_2007_07_15), null);
668 }
669
670 @Test(expectedExceptions=NullPointerException.class)
671 public void test_query_null() {
672 TEST_2007_07_15.query(null);
673 }
674
675 //-----------------------------------------------------------------------
676 // get*()
677 //-----------------------------------------------------------------------
678 @DataProvider(name="sampleDates")
679 Object[][] provider_sampleDates() {
680 return new Object[][] {
681 {2008, 7, 5},
682 {2007, 7, 5},
683 {2006, 7, 5},
684 {2005, 7, 5},
685 {2004, 1, 1},
686 {-1, 1, 2},
687 };
688 }
689
690 //-----------------------------------------------------------------------
691 @Test(dataProvider="sampleDates", groups={"tck"})
692 public void test_get(int y, int m, int d) {
693 LocalDate a = LocalDate.of(y, m, d);
694 assertEquals(a.getYear(), y);
695 assertEquals(a.getMonth(), Month.of(m));
696 assertEquals(a.getDayOfMonth(), d);
697 }
698
699 @Test(dataProvider="sampleDates", groups={"tck"})
700 public void test_getDOY(int y, int m, int d) {
701 LocalDate a = LocalDate.of(y, m, d);
702 int total = 0;
703 for (int i = 1; i < m; i++) {
704 total += Month.of(i).length(isIsoLeap(y));
705 }
706 int doy = total + d;
707 assertEquals(a.getDayOfYear(), doy);
708 }
709
710 @Test(groups={"tck"})
711 public void test_getDayOfWeek() {
712 DayOfWeek dow = DayOfWeek.MONDAY;
713 for (Month month : Month.values()) {
714 int length = month.length(false);
715 for (int i = 1; i <= length; i++) {
716 LocalDate d = LocalDate.of(2007, month, i);
717 assertSame(d.getDayOfWeek(), dow);
718 dow = dow.plus(1);
719 }
720 }
721 }
722
723 //-----------------------------------------------------------------------
724 // isLeapYear()
725 //-----------------------------------------------------------------------
726 @Test(groups={"tck"})
727 public void test_isLeapYear() {
728 assertEquals(LocalDate.of(1999, 1, 1).isLeapYear(), false);
729 assertEquals(LocalDate.of(2000, 1, 1).isLeapYear(), true);
730 assertEquals(LocalDate.of(2001, 1, 1).isLeapYear(), false);
731 assertEquals(LocalDate.of(2002, 1, 1).isLeapYear(), false);
732 assertEquals(LocalDate.of(2003, 1, 1).isLeapYear(), false);
733 assertEquals(LocalDate.of(2004, 1, 1).isLeapYear(), true);
734 assertEquals(LocalDate.of(2005, 1, 1).isLeapYear(), false);
735
736 assertEquals(LocalDate.of(1500, 1, 1).isLeapYear(), false);
737 assertEquals(LocalDate.of(1600, 1, 1).isLeapYear(), true);
738 assertEquals(LocalDate.of(1700, 1, 1).isLeapYear(), false);
739 assertEquals(LocalDate.of(1800, 1, 1).isLeapYear(), false);
740 assertEquals(LocalDate.of(1900, 1, 1).isLeapYear(), false);
741 }
742
743 //-----------------------------------------------------------------------
744 // lengthOfMonth()
745 //-----------------------------------------------------------------------
746 @Test(groups={"tck"})
747 public void test_lengthOfMonth_notLeapYear() {
748 assertEquals(LocalDate.of(2007, 1, 1).lengthOfMonth(), 31);
749 assertEquals(LocalDate.of(2007, 2, 1).lengthOfMonth(), 28);
750 assertEquals(LocalDate.of(2007, 3, 1).lengthOfMonth(), 31);
751 assertEquals(LocalDate.of(2007, 4, 1).lengthOfMonth(), 30);
752 assertEquals(LocalDate.of(2007, 5, 1).lengthOfMonth(), 31);
753 assertEquals(LocalDate.of(2007, 6, 1).lengthOfMonth(), 30);
754 assertEquals(LocalDate.of(2007, 7, 1).lengthOfMonth(), 31);
755 assertEquals(LocalDate.of(2007, 8, 1).lengthOfMonth(), 31);
756 assertEquals(LocalDate.of(2007, 9, 1).lengthOfMonth(), 30);
757 assertEquals(LocalDate.of(2007, 10, 1).lengthOfMonth(), 31);
758 assertEquals(LocalDate.of(2007, 11, 1).lengthOfMonth(), 30);
759 assertEquals(LocalDate.of(2007, 12, 1).lengthOfMonth(), 31);
760 }
761
762 @Test(groups={"tck"})
763 public void test_lengthOfMonth_leapYear() {
764 assertEquals(LocalDate.of(2008, 1, 1).lengthOfMonth(), 31);
765 assertEquals(LocalDate.of(2008, 2, 1).lengthOfMonth(), 29);
766 assertEquals(LocalDate.of(2008, 3, 1).lengthOfMonth(), 31);
767 assertEquals(LocalDate.of(2008, 4, 1).lengthOfMonth(), 30);
768 assertEquals(LocalDate.of(2008, 5, 1).lengthOfMonth(), 31);
769 assertEquals(LocalDate.of(2008, 6, 1).lengthOfMonth(), 30);
770 assertEquals(LocalDate.of(2008, 7, 1).lengthOfMonth(), 31);
771 assertEquals(LocalDate.of(2008, 8, 1).lengthOfMonth(), 31);
772 assertEquals(LocalDate.of(2008, 9, 1).lengthOfMonth(), 30);
773 assertEquals(LocalDate.of(2008, 10, 1).lengthOfMonth(), 31);
774 assertEquals(LocalDate.of(2008, 11, 1).lengthOfMonth(), 30);
775 assertEquals(LocalDate.of(2008, 12, 1).lengthOfMonth(), 31);
776 }
777
778 //-----------------------------------------------------------------------
779 // lengthOfYear()
780 //-----------------------------------------------------------------------
781 @Test(groups={"tck"})
782 public void test_lengthOfYear() {
783 assertEquals(LocalDate.of(2007, 1, 1).lengthOfYear(), 365);
784 assertEquals(LocalDate.of(2008, 1, 1).lengthOfYear(), 366);
785 }
786
787 //-----------------------------------------------------------------------
788 // with()
789 //-----------------------------------------------------------------------
790 @Test(groups={"tck"})
791 public void test_with_adjustment() {
792 final LocalDate sample = LocalDate.of(2012, 3, 4);
793 TemporalAdjuster adjuster = new TemporalAdjuster() {
794 @Override
795 public Temporal adjustInto(Temporal dateTime) {
796 return sample;
797 }
798 };
799 assertEquals(TEST_2007_07_15.with(adjuster), sample);
800 }
801
802 @Test(expectedExceptions=NullPointerException.class, groups={"tck"})
803 public void test_with_adjustment_null() {
804 TEST_2007_07_15.with((TemporalAdjuster) null);
805 }
806
807 //-----------------------------------------------------------------------
808 // with(TemporalField,long)
809 //-----------------------------------------------------------------------
810 @Test(groups={"tck"})
811 public void test_with_TemporalField_long_normal() {
812 LocalDate t = TEST_2007_07_15.with(YEAR, 2008);
813 assertEquals(t, LocalDate.of(2008, 7, 15));
814 }
815
816 @Test(expectedExceptions=NullPointerException.class, groups={"tck"} )
817 public void test_with_TemporalField_long_null() {
818 TEST_2007_07_15.with((TemporalField) null, 1);
819 }
820
821 @Test(expectedExceptions=DateTimeException.class, groups={"tck"} )
822 public void test_with_TemporalField_long_invalidField() {
823 TEST_2007_07_15.with(MockFieldNoValue.INSTANCE, 1);
824 }
825
826 @Test(expectedExceptions=DateTimeException.class, groups={"tck"} )
827 public void test_with_TemporalField_long_timeField() {
828 TEST_2007_07_15.with(ChronoField.AMPM_OF_DAY, 1);
829 }
830
831 @Test(expectedExceptions=DateTimeException.class, groups={"tck"} )
832 public void test_with_TemporalField_long_invalidValue() {
833 TEST_2007_07_15.with(ChronoField.DAY_OF_WEEK, -1);
834 }
835
836 //-----------------------------------------------------------------------
837 // withYear()
838 //-----------------------------------------------------------------------
839 @Test(groups={"tck"})
840 public void test_withYear_int_normal() {
841 LocalDate t = TEST_2007_07_15.withYear(2008);
842 assertEquals(t, LocalDate.of(2008, 7, 15));
843 }
844
845 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
846 public void test_withYear_int_invalid() {
847 TEST_2007_07_15.withYear(Year.MIN_VALUE - 1);
848 }
849
850 @Test(groups={"tck"})
851 public void test_withYear_int_adjustDay() {
852 LocalDate t = LocalDate.of(2008, 2, 29).withYear(2007);
853 LocalDate expected = LocalDate.of(2007, 2, 28);
854 assertEquals(t, expected);
855 }
856
857 //-----------------------------------------------------------------------
858 // withMonth()
859 //-----------------------------------------------------------------------
860 @Test(groups={"tck"})
861 public void test_withMonth_int_normal() {
862 LocalDate t = TEST_2007_07_15.withMonth(1);
863 assertEquals(t, LocalDate.of(2007, 1, 15));
864 }
865
866 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
867 public void test_withMonth_int_invalid() {
868 TEST_2007_07_15.withMonth(13);
869 }
870
871 @Test(groups={"tck"})
872 public void test_withMonth_int_adjustDay() {
873 LocalDate t = LocalDate.of(2007, 12, 31).withMonth(11);
874 LocalDate expected = LocalDate.of(2007, 11, 30);
875 assertEquals(t, expected);
876 }
877
878 //-----------------------------------------------------------------------
879 // withDayOfMonth()
880 //-----------------------------------------------------------------------
881 @Test(groups={"tck"})
882 public void test_withDayOfMonth_normal() {
883 LocalDate t = TEST_2007_07_15.withDayOfMonth(1);
884 assertEquals(t, LocalDate.of(2007, 7, 1));
885 }
886
887 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
888 public void test_withDayOfMonth_illegal() {
889 TEST_2007_07_15.withDayOfMonth(32);
890 }
891
892 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
893 public void test_withDayOfMonth_invalid() {
894 LocalDate.of(2007, 11, 30).withDayOfMonth(31);
895 }
896
897 //-----------------------------------------------------------------------
898 // withDayOfYear(int)
899 //-----------------------------------------------------------------------
900 @Test(groups={"tck"})
901 public void test_withDayOfYear_normal() {
902 LocalDate t = TEST_2007_07_15.withDayOfYear(33);
903 assertEquals(t, LocalDate.of(2007, 2, 2));
904 }
905
906 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
907 public void test_withDayOfYear_illegal() {
908 TEST_2007_07_15.withDayOfYear(367);
909 }
910
911 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
912 public void test_withDayOfYear_invalid() {
913 TEST_2007_07_15.withDayOfYear(366);
914 }
915
916 //-----------------------------------------------------------------------
917 // plus(Period)
918 //-----------------------------------------------------------------------
919 @Test(groups={"tck"})
920 public void test_plus_Period_positiveMonths() {
921 MockSimplePeriod period = MockSimplePeriod.of(7, ChronoUnit.MONTHS);
922 LocalDate t = TEST_2007_07_15.plus(period);
923 assertEquals(t, LocalDate.of(2008, 2, 15));
924 }
925
926 @Test(groups={"tck"})
927 public void test_plus_Period_negativeDays() {
928 MockSimplePeriod period = MockSimplePeriod.of(-25, ChronoUnit.DAYS);
929 LocalDate t = TEST_2007_07_15.plus(period);
930 assertEquals(t, LocalDate.of(2007, 6, 20));
931 }
932
933 @Test(groups={"tck"}, expectedExceptions=DateTimeException.class)
934 public void test_plus_Period_timeNotAllowed() {
935 MockSimplePeriod period = MockSimplePeriod.of(7, ChronoUnit.HOURS);
936 TEST_2007_07_15.plus(period);
937 }
938
939 @Test(expectedExceptions=NullPointerException.class, groups={"tck"})
940 public void test_plus_Period_null() {
941 TEST_2007_07_15.plus((MockSimplePeriod) null);
942 }
943
944 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
945 public void test_plus_Period_invalidTooLarge() {
946 MockSimplePeriod period = MockSimplePeriod.of(1, ChronoUnit.YEARS);
947 LocalDate.of(Year.MAX_VALUE, 1, 1).plus(period);
948 }
949
950 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
951 public void test_plus_Period_invalidTooSmall() {
952 MockSimplePeriod period = MockSimplePeriod.of(-1, ChronoUnit.YEARS);
953 LocalDate.of(Year.MIN_VALUE, 1, 1).plus(period);
954 }
955
956 //-----------------------------------------------------------------------
957 // plus(long,TemporalUnit)
958 //-----------------------------------------------------------------------
959 @Test(groups={"tck"})
960 public void test_plus_longTemporalUnit_positiveMonths() {
961 LocalDate t = TEST_2007_07_15.plus(7, ChronoUnit.MONTHS);
962 assertEquals(t, LocalDate.of(2008, 2, 15));
963 }
964
965 @Test(groups={"tck"})
966 public void test_plus_longTemporalUnit_negativeDays() {
967 LocalDate t = TEST_2007_07_15.plus(-25, ChronoUnit.DAYS);
968 assertEquals(t, LocalDate.of(2007, 6, 20));
969 }
970
971 @Test(groups={"tck"}, expectedExceptions=DateTimeException.class)
972 public void test_plus_longTemporalUnit_timeNotAllowed() {
973 TEST_2007_07_15.plus(7, ChronoUnit.HOURS);
974 }
975
976 @Test(expectedExceptions=NullPointerException.class, groups={"tck"})
977 public void test_plus_longTemporalUnit_null() {
978 TEST_2007_07_15.plus(1, (TemporalUnit) null);
979 }
980
981 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
982 public void test_plus_longTemporalUnit_invalidTooLarge() {
983 LocalDate.of(Year.MAX_VALUE, 1, 1).plus(1, ChronoUnit.YEARS);
984 }
985
986 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
987 public void test_plus_longTemporalUnit_invalidTooSmall() {
988 LocalDate.of(Year.MIN_VALUE, 1, 1).plus(-1, ChronoUnit.YEARS);
989 }
990
991 //-----------------------------------------------------------------------
992 // plusYears()
993 //-----------------------------------------------------------------------
994 @Test(groups={"tck"})
995 public void test_plusYears_long_normal() {
996 LocalDate t = TEST_2007_07_15.plusYears(1);
997 assertEquals(t, LocalDate.of(2008, 7, 15));
998 }
999
1000 @Test(groups={"tck"})
1001 public void test_plusYears_long_negative() {
1002 LocalDate t = TEST_2007_07_15.plusYears(-1);
1003 assertEquals(t, LocalDate.of(2006, 7, 15));
1004 }
1005
1006 @Test(groups={"tck"})
1007 public void test_plusYears_long_adjustDay() {
1008 LocalDate t = LocalDate.of(2008, 2, 29).plusYears(1);
1009 LocalDate expected = LocalDate.of(2009, 2, 28);
1010 assertEquals(t, expected);
1011 }
1012
1013 @Test(groups={"tck"})
1014 public void test_plusYears_long_big() {
1015 long years = 20L + Year.MAX_VALUE;
1016 LocalDate test = LocalDate.of(-40, 6, 1).plusYears(years);
1017 assertEquals(test, LocalDate.of((int) (-40L + years), 6, 1));
1018 }
1019
1020 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1021 public void test_plusYears_long_invalidTooLarge() {
1022 LocalDate test = LocalDate.of(Year.MAX_VALUE, 6, 1);
1023 test.plusYears(1);
1024 }
1025
1026 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1027 public void test_plusYears_long_invalidTooLargeMaxAddMax() {
1028 LocalDate test = LocalDate.of(Year.MAX_VALUE, 12, 1);
1029 test.plusYears(Long.MAX_VALUE);
1030 }
1031
1032 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1033 public void test_plusYears_long_invalidTooLargeMaxAddMin() {
1034 LocalDate test = LocalDate.of(Year.MAX_VALUE, 12, 1);
1035 test.plusYears(Long.MIN_VALUE);
1036 }
1037
1038 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1039 public void test_plusYears_long_invalidTooSmall_validInt() {
1040 LocalDate.of(Year.MIN_VALUE, 1, 1).plusYears(-1);
1041 }
1042
1043 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1044 public void test_plusYears_long_invalidTooSmall_invalidInt() {
1045 LocalDate.of(Year.MIN_VALUE, 1, 1).plusYears(-10);
1046 }
1047
1048 //-----------------------------------------------------------------------
1049 // plusMonths()
1050 //-----------------------------------------------------------------------
1051 @Test(groups={"tck"})
1052 public void test_plusMonths_long_normal() {
1053 LocalDate t = TEST_2007_07_15.plusMonths(1);
1054 assertEquals(t, LocalDate.of(2007, 8, 15));
1055 }
1056
1057 @Test(groups={"tck"})
1058 public void test_plusMonths_long_overYears() {
1059 LocalDate t = TEST_2007_07_15.plusMonths(25);
1060 assertEquals(t, LocalDate.of(2009, 8, 15));
1061 }
1062
1063 @Test(groups={"tck"})
1064 public void test_plusMonths_long_negative() {
1065 LocalDate t = TEST_2007_07_15.plusMonths(-1);
1066 assertEquals(t, LocalDate.of(2007, 6, 15));
1067 }
1068
1069 @Test(groups={"tck"})
1070 public void test_plusMonths_long_negativeAcrossYear() {
1071 LocalDate t = TEST_2007_07_15.plusMonths(-7);
1072 assertEquals(t, LocalDate.of(2006, 12, 15));
1073 }
1074
1075 @Test(groups={"tck"})
1076 public void test_plusMonths_long_negativeOverYears() {
1077 LocalDate t = TEST_2007_07_15.plusMonths(-31);
1078 assertEquals(t, LocalDate.of(2004, 12, 15));
1079 }
1080
1081 @Test(groups={"tck"})
1082 public void test_plusMonths_long_adjustDayFromLeapYear() {
1083 LocalDate t = LocalDate.of(2008, 2, 29).plusMonths(12);
1084 LocalDate expected = LocalDate.of(2009, 2, 28);
1085 assertEquals(t, expected);
1086 }
1087
1088 @Test(groups={"tck"})
1089 public void test_plusMonths_long_adjustDayFromMonthLength() {
1090 LocalDate t = LocalDate.of(2007, 3, 31).plusMonths(1);
1091 LocalDate expected = LocalDate.of(2007, 4, 30);
1092 assertEquals(t, expected);
1093 }
1094
1095 @Test(groups={"tck"})
1096 public void test_plusMonths_long_big() {
1097 long months = 20L + Integer.MAX_VALUE;
1098 LocalDate test = LocalDate.of(-40, 6, 1).plusMonths(months);
1099 assertEquals(test, LocalDate.of((int) (-40L + months / 12), 6 + (int) (months % 12), 1));
1100 }
1101
1102 @Test(expectedExceptions={DateTimeException.class}, groups={"tck"})
1103 public void test_plusMonths_long_invalidTooLarge() {
1104 LocalDate.of(Year.MAX_VALUE, 12, 1).plusMonths(1);
1105 }
1106
1107 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1108 public void test_plusMonths_long_invalidTooLargeMaxAddMax() {
1109 LocalDate test = LocalDate.of(Year.MAX_VALUE, 12, 1);
1110 test.plusMonths(Long.MAX_VALUE);
1111 }
1112
1113 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1114 public void test_plusMonths_long_invalidTooLargeMaxAddMin() {
1115 LocalDate test = LocalDate.of(Year.MAX_VALUE, 12, 1);
1116 test.plusMonths(Long.MIN_VALUE);
1117 }
1118
1119 @Test(expectedExceptions={DateTimeException.class}, groups={"tck"})
1120 public void test_plusMonths_long_invalidTooSmall() {
1121 LocalDate.of(Year.MIN_VALUE, 1, 1).plusMonths(-1);
1122 }
1123
1124 @Test(groups={"tck"})
1125 public void test_plusWeeks_normal() {
1126 LocalDate t = TEST_2007_07_15.plusWeeks(1);
1127 assertEquals(t, LocalDate.of(2007, 7, 22));
1128 }
1129
1130 @Test(groups={"tck"})
1131 public void test_plusWeeks_overMonths() {
1132 LocalDate t = TEST_2007_07_15.plusWeeks(9);
1133 assertEquals(t, LocalDate.of(2007, 9, 16));
1134 }
1135
1136 @Test(groups={"tck"})
1137 public void test_plusWeeks_overYears() {
1138 LocalDate t = LocalDate.of(2006, 7, 16).plusWeeks(52);
1139 assertEquals(t, TEST_2007_07_15);
1140 }
1141
1142 @Test(groups={"tck"})
1143 public void test_plusWeeks_overLeapYears() {
1144 LocalDate t = TEST_2007_07_15.plusYears(-1).plusWeeks(104);
1145 assertEquals(t, LocalDate.of(2008, 7, 12));
1146 }
1147
1148 @Test(groups={"tck"})
1149 public void test_plusWeeks_negative() {
1150 LocalDate t = TEST_2007_07_15.plusWeeks(-1);
1151 assertEquals(t, LocalDate.of(2007, 7, 8));
1152 }
1153
1154 @Test(groups={"tck"})
1155 public void test_plusWeeks_negativeAcrossYear() {
1156 LocalDate t = TEST_2007_07_15.plusWeeks(-28);
1157 assertEquals(t, LocalDate.of(2006, 12, 31));
1158 }
1159
1160 @Test(groups={"tck"})
1161 public void test_plusWeeks_negativeOverYears() {
1162 LocalDate t = TEST_2007_07_15.plusWeeks(-104);
1163 assertEquals(t, LocalDate.of(2005, 7, 17));
1164 }
1165
1166 @Test(groups={"tck"})
1167 public void test_plusWeeks_maximum() {
1168 LocalDate t = LocalDate.of(Year.MAX_VALUE, 12, 24).plusWeeks(1);
1169 LocalDate expected = LocalDate.of(Year.MAX_VALUE, 12, 31);
1170 assertEquals(t, expected);
1171 }
1172
1173 @Test(groups={"tck"})
1174 public void test_plusWeeks_minimum() {
1175 LocalDate t = LocalDate.of(Year.MIN_VALUE, 1, 8).plusWeeks(-1);
1176 LocalDate expected = LocalDate.of(Year.MIN_VALUE, 1, 1);
1177 assertEquals(t, expected);
1178 }
1179
1180 @Test(expectedExceptions={DateTimeException.class}, groups={"tck"})
1181 public void test_plusWeeks_invalidTooLarge() {
1182 LocalDate.of(Year.MAX_VALUE, 12, 25).plusWeeks(1);
1183 }
1184
1185 @Test(expectedExceptions={DateTimeException.class}, groups={"tck"})
1186 public void test_plusWeeks_invalidTooSmall() {
1187 LocalDate.of(Year.MIN_VALUE, 1, 7).plusWeeks(-1);
1188 }
1189
1190 @Test(expectedExceptions={ArithmeticException.class}, groups={"tck"})
1191 public void test_plusWeeks_invalidMaxMinusMax() {
1192 LocalDate.of(Year.MAX_VALUE, 12, 25).plusWeeks(Long.MAX_VALUE);
1193 }
1194
1195 @Test(expectedExceptions={ArithmeticException.class}, groups={"tck"})
1196 public void test_plusWeeks_invalidMaxMinusMin() {
1197 LocalDate.of(Year.MAX_VALUE, 12, 25).plusWeeks(Long.MIN_VALUE);
1198 }
1199
1200 @Test(groups={"tck"})
1201 public void test_plusDays_normal() {
1202 LocalDate t = TEST_2007_07_15.plusDays(1);
1203 assertEquals(t, LocalDate.of(2007, 7, 16));
1204 }
1205
1206 @Test(groups={"tck"})
1207 public void test_plusDays_overMonths() {
1208 LocalDate t = TEST_2007_07_15.plusDays(62);
1209 assertEquals(t, LocalDate.of(2007, 9, 15));
1210 }
1211
1212 @Test(groups={"tck"})
1213 public void test_plusDays_overYears() {
1214 LocalDate t = LocalDate.of(2006, 7, 14).plusDays(366);
1215 assertEquals(t, TEST_2007_07_15);
1216 }
1217
1218 @Test(groups={"tck"})
1219 public void test_plusDays_overLeapYears() {
1220 LocalDate t = TEST_2007_07_15.plusYears(-1).plusDays(365 + 366);
1221 assertEquals(t, LocalDate.of(2008, 7, 15));
1222 }
1223
1224 @Test(groups={"tck"})
1225 public void test_plusDays_negative() {
1226 LocalDate t = TEST_2007_07_15.plusDays(-1);
1227 assertEquals(t, LocalDate.of(2007, 7, 14));
1228 }
1229
1230 @Test(groups={"tck"})
1231 public void test_plusDays_negativeAcrossYear() {
1232 LocalDate t = TEST_2007_07_15.plusDays(-196);
1233 assertEquals(t, LocalDate.of(2006, 12, 31));
1234 }
1235
1236 @Test(groups={"tck"})
1237 public void test_plusDays_negativeOverYears() {
1238 LocalDate t = TEST_2007_07_15.plusDays(-730);
1239 assertEquals(t, LocalDate.of(2005, 7, 15));
1240 }
1241
1242 @Test(groups={"tck"})
1243 public void test_plusDays_maximum() {
1244 LocalDate t = LocalDate.of(Year.MAX_VALUE, 12, 30).plusDays(1);
1245 LocalDate expected = LocalDate.of(Year.MAX_VALUE, 12, 31);
1246 assertEquals(t, expected);
1247 }
1248
1249 @Test(groups={"tck"})
1250 public void test_plusDays_minimum() {
1251 LocalDate t = LocalDate.of(Year.MIN_VALUE, 1, 2).plusDays(-1);
1252 LocalDate expected = LocalDate.of(Year.MIN_VALUE, 1, 1);
1253 assertEquals(t, expected);
1254 }
1255
1256 @Test(expectedExceptions={DateTimeException.class}, groups={"tck"})
1257 public void test_plusDays_invalidTooLarge() {
1258 LocalDate.of(Year.MAX_VALUE, 12, 31).plusDays(1);
1259 }
1260
1261 @Test(expectedExceptions={DateTimeException.class}, groups={"tck"})
1262 public void test_plusDays_invalidTooSmall() {
1263 LocalDate.of(Year.MIN_VALUE, 1, 1).plusDays(-1);
1264 }
1265
1266 @Test(expectedExceptions=ArithmeticException.class, groups={"tck"})
1267 public void test_plusDays_overflowTooLarge() {
1268 LocalDate.of(Year.MAX_VALUE, 12, 31).plusDays(Long.MAX_VALUE);
1269 }
1270
1271 @Test(expectedExceptions=ArithmeticException.class, groups={"tck"})
1272 public void test_plusDays_overflowTooSmall() {
1273 LocalDate.of(Year.MIN_VALUE, 1, 1).plusDays(Long.MIN_VALUE);
1274 }
1275
1276 //-----------------------------------------------------------------------
1277 // minus(Period)
1278 //-----------------------------------------------------------------------
1279 @Test(groups={"tck"})
1280 public void test_minus_Period_positiveMonths() {
1281 MockSimplePeriod period = MockSimplePeriod.of(7, ChronoUnit.MONTHS);
1282 LocalDate t = TEST_2007_07_15.minus(period);
1283 assertEquals(t, LocalDate.of(2006, 12, 15));
1284 }
1285
1286 @Test(groups={"tck"})
1287 public void test_minus_Period_negativeDays() {
1288 MockSimplePeriod period = MockSimplePeriod.of(-25, ChronoUnit.DAYS);
1289 LocalDate t = TEST_2007_07_15.minus(period);
1290 assertEquals(t, LocalDate.of(2007, 8, 9));
1291 }
1292
1293 @Test(groups={"tck"}, expectedExceptions=DateTimeException.class)
1294 public void test_minus_Period_timeNotAllowed() {
1295 MockSimplePeriod period = MockSimplePeriod.of(7, ChronoUnit.HOURS);
1296 TEST_2007_07_15.minus(period);
1297 }
1298
1299 @Test(expectedExceptions=NullPointerException.class, groups={"tck"})
1300 public void test_minus_Period_null() {
1301 TEST_2007_07_15.minus((MockSimplePeriod) null);
1302 }
1303
1304 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1305 public void test_minus_Period_invalidTooLarge() {
1306 MockSimplePeriod period = MockSimplePeriod.of(-1, ChronoUnit.YEARS);
1307 LocalDate.of(Year.MAX_VALUE, 1, 1).minus(period);
1308 }
1309
1310 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1311 public void test_minus_Period_invalidTooSmall() {
1312 MockSimplePeriod period = MockSimplePeriod.of(1, ChronoUnit.YEARS);
1313 LocalDate.of(Year.MIN_VALUE, 1, 1).minus(period);
1314 }
1315
1316 //-----------------------------------------------------------------------
1317 // minus(long,TemporalUnit)
1318 //-----------------------------------------------------------------------
1319 @Test(groups={"tck"})
1320 public void test_minus_longTemporalUnit_positiveMonths() {
1321 LocalDate t = TEST_2007_07_15.minus(7, ChronoUnit.MONTHS);
1322 assertEquals(t, LocalDate.of(2006, 12, 15));
1323 }
1324
1325 @Test(groups={"tck"})
1326 public void test_minus_longTemporalUnit_negativeDays() {
1327 LocalDate t = TEST_2007_07_15.minus(-25, ChronoUnit.DAYS);
1328 assertEquals(t, LocalDate.of(2007, 8, 9));
1329 }
1330
1331 @Test(groups={"tck"}, expectedExceptions=DateTimeException.class)
1332 public void test_minus_longTemporalUnit_timeNotAllowed() {
1333 TEST_2007_07_15.minus(7, ChronoUnit.HOURS);
1334 }
1335
1336 @Test(expectedExceptions=NullPointerException.class, groups={"tck"})
1337 public void test_minus_longTemporalUnit_null() {
1338 TEST_2007_07_15.minus(1, (TemporalUnit) null);
1339 }
1340
1341 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1342 public void test_minus_longTemporalUnit_invalidTooLarge() {
1343 LocalDate.of(Year.MAX_VALUE, 1, 1).minus(-1, ChronoUnit.YEARS);
1344 }
1345
1346 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1347 public void test_minus_longTemporalUnit_invalidTooSmall() {
1348 LocalDate.of(Year.MIN_VALUE, 1, 1).minus(1, ChronoUnit.YEARS);
1349 }
1350
1351 //-----------------------------------------------------------------------
1352 // minusYears()
1353 //-----------------------------------------------------------------------
1354 @Test(groups={"tck"})
1355 public void test_minusYears_long_normal() {
1356 LocalDate t = TEST_2007_07_15.minusYears(1);
1357 assertEquals(t, LocalDate.of(2006, 7, 15));
1358 }
1359
1360 @Test(groups={"tck"})
1361 public void test_minusYears_long_negative() {
1362 LocalDate t = TEST_2007_07_15.minusYears(-1);
1363 assertEquals(t, LocalDate.of(2008, 7, 15));
1364 }
1365
1366 @Test(groups={"tck"})
1367 public void test_minusYears_long_adjustDay() {
1368 LocalDate t = LocalDate.of(2008, 2, 29).minusYears(1);
1369 LocalDate expected = LocalDate.of(2007, 2, 28);
1370 assertEquals(t, expected);
1371 }
1372
1373 @Test(groups={"tck"})
1374 public void test_minusYears_long_big() {
1375 long years = 20L + Year.MAX_VALUE;
1376 LocalDate test = LocalDate.of(40, 6, 1).minusYears(years);
1377 assertEquals(test, LocalDate.of((int) (40L - years), 6, 1));
1378 }
1379
1380 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1381 public void test_minusYears_long_invalidTooLarge() {
1382 LocalDate test = LocalDate.of(Year.MAX_VALUE, 6, 1);
1383 test.minusYears(-1);
1384 }
1385
1386 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1387 public void test_minusYears_long_invalidTooLargeMaxAddMax() {
1388 LocalDate test = LocalDate.of(Year.MAX_VALUE, 12, 1);
1389 test.minusYears(Long.MAX_VALUE);
1390 }
1391
1392 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1393 public void test_minusYears_long_invalidTooLargeMaxAddMin() {
1394 LocalDate test = LocalDate.of(Year.MAX_VALUE, 12, 1);
1395 test.minusYears(Long.MIN_VALUE);
1396 }
1397
1398 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1399 public void test_minusYears_long_invalidTooSmall() {
1400 LocalDate.of(Year.MIN_VALUE, 1, 1).minusYears(1);
1401 }
1402
1403 //-----------------------------------------------------------------------
1404 // minusMonths()
1405 //-----------------------------------------------------------------------
1406 @Test(groups={"tck"})
1407 public void test_minusMonths_long_normal() {
1408 LocalDate t = TEST_2007_07_15.minusMonths(1);
1409 assertEquals(t, LocalDate.of(2007, 6, 15));
1410 }
1411
1412 @Test(groups={"tck"})
1413 public void test_minusMonths_long_overYears() {
1414 LocalDate t = TEST_2007_07_15.minusMonths(25);
1415 assertEquals(t, LocalDate.of(2005, 6, 15));
1416 }
1417
1418 @Test(groups={"tck"})
1419 public void test_minusMonths_long_negative() {
1420 LocalDate t = TEST_2007_07_15.minusMonths(-1);
1421 assertEquals(t, LocalDate.of(2007, 8, 15));
1422 }
1423
1424 @Test(groups={"tck"})
1425 public void test_minusMonths_long_negativeAcrossYear() {
1426 LocalDate t = TEST_2007_07_15.minusMonths(-7);
1427 assertEquals(t, LocalDate.of(2008, 2, 15));
1428 }
1429
1430 @Test(groups={"tck"})
1431 public void test_minusMonths_long_negativeOverYears() {
1432 LocalDate t = TEST_2007_07_15.minusMonths(-31);
1433 assertEquals(t, LocalDate.of(2010, 2, 15));
1434 }
1435
1436 @Test(groups={"tck"})
1437 public void test_minusMonths_long_adjustDayFromLeapYear() {
1438 LocalDate t = LocalDate.of(2008, 2, 29).minusMonths(12);
1439 LocalDate expected = LocalDate.of(2007, 2, 28);
1440 assertEquals(t, expected);
1441 }
1442
1443 @Test(groups={"tck"})
1444 public void test_minusMonths_long_adjustDayFromMonthLength() {
1445 LocalDate t = LocalDate.of(2007, 3, 31).minusMonths(1);
1446 LocalDate expected = LocalDate.of(2007, 2, 28);
1447 assertEquals(t, expected);
1448 }
1449
1450 @Test(groups={"tck"})
1451 public void test_minusMonths_long_big() {
1452 long months = 20L + Integer.MAX_VALUE;
1453 LocalDate test = LocalDate.of(40, 6, 1).minusMonths(months);
1454 assertEquals(test, LocalDate.of((int) (40L - months / 12), 6 - (int) (months % 12), 1));
1455 }
1456
1457 @Test(expectedExceptions={DateTimeException.class}, groups={"tck"})
1458 public void test_minusMonths_long_invalidTooLarge() {
1459 LocalDate.of(Year.MAX_VALUE, 12, 1).minusMonths(-1);
1460 }
1461
1462 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1463 public void test_minusMonths_long_invalidTooLargeMaxAddMax() {
1464 LocalDate test = LocalDate.of(Year.MAX_VALUE, 12, 1);
1465 test.minusMonths(Long.MAX_VALUE);
1466 }
1467
1468 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1469 public void test_minusMonths_long_invalidTooLargeMaxAddMin() {
1470 LocalDate test = LocalDate.of(Year.MAX_VALUE, 12, 1);
1471 test.minusMonths(Long.MIN_VALUE);
1472 }
1473
1474 @Test(expectedExceptions={DateTimeException.class}, groups={"tck"})
1475 public void test_minusMonths_long_invalidTooSmall() {
1476 LocalDate.of(Year.MIN_VALUE, 1, 1).minusMonths(1);
1477 }
1478
1479 @Test(groups={"tck"})
1480 public void test_minusWeeks_normal() {
1481 LocalDate t = TEST_2007_07_15.minusWeeks(1);
1482 assertEquals(t, LocalDate.of(2007, 7, 8));
1483 }
1484
1485 @Test(groups={"tck"})
1486 public void test_minusWeeks_overMonths() {
1487 LocalDate t = TEST_2007_07_15.minusWeeks(9);
1488 assertEquals(t, LocalDate.of(2007, 5, 13));
1489 }
1490
1491 @Test(groups={"tck"})
1492 public void test_minusWeeks_overYears() {
1493 LocalDate t = LocalDate.of(2008, 7, 13).minusWeeks(52);
1494 assertEquals(t, TEST_2007_07_15);
1495 }
1496
1497 @Test(groups={"tck"})
1498 public void test_minusWeeks_overLeapYears() {
1499 LocalDate t = TEST_2007_07_15.minusYears(-1).minusWeeks(104);
1500 assertEquals(t, LocalDate.of(2006, 7, 18));
1501 }
1502
1503 @Test(groups={"tck"})
1504 public void test_minusWeeks_negative() {
1505 LocalDate t = TEST_2007_07_15.minusWeeks(-1);
1506 assertEquals(t, LocalDate.of(2007, 7, 22));
1507 }
1508
1509 @Test(groups={"tck"})
1510 public void test_minusWeeks_negativeAcrossYear() {
1511 LocalDate t = TEST_2007_07_15.minusWeeks(-28);
1512 assertEquals(t, LocalDate.of(2008, 1, 27));
1513 }
1514
1515 @Test(groups={"tck"})
1516 public void test_minusWeeks_negativeOverYears() {
1517 LocalDate t = TEST_2007_07_15.minusWeeks(-104);
1518 assertEquals(t, LocalDate.of(2009, 7, 12));
1519 }
1520
1521 @Test(groups={"tck"})
1522 public void test_minusWeeks_maximum() {
1523 LocalDate t = LocalDate.of(Year.MAX_VALUE, 12, 24).minusWeeks(-1);
1524 LocalDate expected = LocalDate.of(Year.MAX_VALUE, 12, 31);
1525 assertEquals(t, expected);
1526 }
1527
1528 @Test(groups={"tck"})
1529 public void test_minusWeeks_minimum() {
1530 LocalDate t = LocalDate.of(Year.MIN_VALUE, 1, 8).minusWeeks(1);
1531 LocalDate expected = LocalDate.of(Year.MIN_VALUE, 1, 1);
1532 assertEquals(t, expected);
1533 }
1534
1535 @Test(expectedExceptions={DateTimeException.class}, groups={"tck"})
1536 public void test_minusWeeks_invalidTooLarge() {
1537 LocalDate.of(Year.MAX_VALUE, 12, 25).minusWeeks(-1);
1538 }
1539
1540 @Test(expectedExceptions={DateTimeException.class}, groups={"tck"})
1541 public void test_minusWeeks_invalidTooSmall() {
1542 LocalDate.of(Year.MIN_VALUE, 1, 7).minusWeeks(1);
1543 }
1544
1545 @Test(expectedExceptions={ArithmeticException.class}, groups={"tck"})
1546 public void test_minusWeeks_invalidMaxMinusMax() {
1547 LocalDate.of(Year.MAX_VALUE, 12, 25).minusWeeks(Long.MAX_VALUE);
1548 }
1549
1550 @Test(expectedExceptions={ArithmeticException.class}, groups={"tck"})
1551 public void test_minusWeeks_invalidMaxMinusMin() {
1552 LocalDate.of(Year.MAX_VALUE, 12, 25).minusWeeks(Long.MIN_VALUE);
1553 }
1554
1555 @Test(groups={"tck"})
1556 public void test_minusDays_normal() {
1557 LocalDate t = TEST_2007_07_15.minusDays(1);
1558 assertEquals(t, LocalDate.of(2007, 7, 14));
1559 }
1560
1561 @Test(groups={"tck"})
1562 public void test_minusDays_overMonths() {
1563 LocalDate t = TEST_2007_07_15.minusDays(62);
1564 assertEquals(t, LocalDate.of(2007, 5, 14));
1565 }
1566
1567 @Test(groups={"tck"})
1568 public void test_minusDays_overYears() {
1569 LocalDate t = LocalDate.of(2008, 7, 16).minusDays(367);
1570 assertEquals(t, TEST_2007_07_15);
1571 }
1572
1573 @Test(groups={"tck"})
1574 public void test_minusDays_overLeapYears() {
1575 LocalDate t = TEST_2007_07_15.plusYears(2).minusDays(365 + 366);
1576 assertEquals(t, TEST_2007_07_15);
1577 }
1578
1579 @Test(groups={"tck"})
1580 public void test_minusDays_negative() {
1581 LocalDate t = TEST_2007_07_15.minusDays(-1);
1582 assertEquals(t, LocalDate.of(2007, 7, 16));
1583 }
1584
1585 @Test(groups={"tck"})
1586 public void test_minusDays_negativeAcrossYear() {
1587 LocalDate t = TEST_2007_07_15.minusDays(-169);
1588 assertEquals(t, LocalDate.of(2007, 12, 31));
1589 }
1590
1591 @Test(groups={"tck"})
1592 public void test_minusDays_negativeOverYears() {
1593 LocalDate t = TEST_2007_07_15.minusDays(-731);
1594 assertEquals(t, LocalDate.of(2009, 7, 15));
1595 }
1596
1597 @Test(groups={"tck"})
1598 public void test_minusDays_maximum() {
1599 LocalDate t = LocalDate.of(Year.MAX_VALUE, 12, 30).minusDays(-1);
1600 LocalDate expected = LocalDate.of(Year.MAX_VALUE, 12, 31);
1601 assertEquals(t, expected);
1602 }
1603
1604 @Test(groups={"tck"})
1605 public void test_minusDays_minimum() {
1606 LocalDate t = LocalDate.of(Year.MIN_VALUE, 1, 2).minusDays(1);
1607 LocalDate expected = LocalDate.of(Year.MIN_VALUE, 1, 1);
1608 assertEquals(t, expected);
1609 }
1610
1611 @Test(expectedExceptions={DateTimeException.class}, groups={"tck"})
1612 public void test_minusDays_invalidTooLarge() {
1613 LocalDate.of(Year.MAX_VALUE, 12, 31).minusDays(-1);
1614 }
1615
1616 @Test(expectedExceptions={DateTimeException.class}, groups={"tck"})
1617 public void test_minusDays_invalidTooSmall() {
1618 LocalDate.of(Year.MIN_VALUE, 1, 1).minusDays(1);
1619 }
1620
1621 @Test(expectedExceptions=ArithmeticException.class, groups={"tck"})
1622 public void test_minusDays_overflowTooLarge() {
1623 LocalDate.of(Year.MAX_VALUE, 12, 31).minusDays(Long.MIN_VALUE);
1624 }
1625
1626 @Test(expectedExceptions=ArithmeticException.class, groups={"tck"})
1627 public void test_minusDays_overflowTooSmall() {
1628 LocalDate.of(Year.MIN_VALUE, 1, 1).minusDays(Long.MAX_VALUE);
1629 }
1630
1631 //-----------------------------------------------------------------------
1632 // atTime()
1633 //-----------------------------------------------------------------------
1634 @Test(groups={"tck"})
1635 public void test_atTime_LocalTime() {
1636 LocalDate t = LocalDate.of(2008, 6, 30);
1637 assertEquals(t.atTime(LocalTime.of(11, 30)), LocalDateTime.of(2008, 6, 30, 11, 30));
1638 }
1639
1640 @Test(expectedExceptions=NullPointerException.class, groups={"tck"})
1641 public void test_atTime_LocalTime_null() {
1642 LocalDate t = LocalDate.of(2008, 6, 30);
1643 t.atTime((LocalTime) null);
1644 }
1645
1646 //-------------------------------------------------------------------------
1647 @Test(groups={"tck"})
1648 public void test_atTime_int_int() {
1649 LocalDate t = LocalDate.of(2008, 6, 30);
1650 assertEquals(t.atTime(11, 30), LocalDateTime.of(2008, 6, 30, 11, 30));
1651 }
1652
1653 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1654 public void test_atTime_int_int_hourTooSmall() {
1655 LocalDate t = LocalDate.of(2008, 6, 30);
1656 t.atTime(-1, 30);
1657 }
1658
1659 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1660 public void test_atTime_int_int_hourTooBig() {
1661 LocalDate t = LocalDate.of(2008, 6, 30);
1662 t.atTime(24, 30);
1663 }
1664
1665 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1666 public void test_atTime_int_int_minuteTooSmall() {
1667 LocalDate t = LocalDate.of(2008, 6, 30);
1668 t.atTime(11, -1);
1669 }
1670
1671 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1672 public void test_atTime_int_int_minuteTooBig() {
1673 LocalDate t = LocalDate.of(2008, 6, 30);
1674 t.atTime(11, 60);
1675 }
1676
1677 @Test(groups={"tck"})
1678 public void test_atTime_int_int_int() {
1679 LocalDate t = LocalDate.of(2008, 6, 30);
1680 assertEquals(t.atTime(11, 30, 40), LocalDateTime.of(2008, 6, 30, 11, 30, 40));
1681 }
1682
1683 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1684 public void test_atTime_int_int_int_hourTooSmall() {
1685 LocalDate t = LocalDate.of(2008, 6, 30);
1686 t.atTime(-1, 30, 40);
1687 }
1688
1689 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1690 public void test_atTime_int_int_int_hourTooBig() {
1691 LocalDate t = LocalDate.of(2008, 6, 30);
1692 t.atTime(24, 30, 40);
1693 }
1694
1695 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1696 public void test_atTime_int_int_int_minuteTooSmall() {
1697 LocalDate t = LocalDate.of(2008, 6, 30);
1698 t.atTime(11, -1, 40);
1699 }
1700
1701 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1702 public void test_atTime_int_int_int_minuteTooBig() {
1703 LocalDate t = LocalDate.of(2008, 6, 30);
1704 t.atTime(11, 60, 40);
1705 }
1706
1707 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1708 public void test_atTime_int_int_int_secondTooSmall() {
1709 LocalDate t = LocalDate.of(2008, 6, 30);
1710 t.atTime(11, 30, -1);
1711 }
1712
1713 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1714 public void test_atTime_int_int_int_secondTooBig() {
1715 LocalDate t = LocalDate.of(2008, 6, 30);
1716 t.atTime(11, 30, 60);
1717 }
1718
1719 @Test(groups={"tck"})
1720 public void test_atTime_int_int_int_int() {
1721 LocalDate t = LocalDate.of(2008, 6, 30);
1722 assertEquals(t.atTime(11, 30, 40, 50), LocalDateTime.of(2008, 6, 30, 11, 30, 40, 50));
1723 }
1724
1725 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1726 public void test_atTime_int_int_int_int_hourTooSmall() {
1727 LocalDate t = LocalDate.of(2008, 6, 30);
1728 t.atTime(-1, 30, 40, 50);
1729 }
1730
1731 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1732 public void test_atTime_int_int_int_int_hourTooBig() {
1733 LocalDate t = LocalDate.of(2008, 6, 30);
1734 t.atTime(24, 30, 40, 50);
1735 }
1736
1737 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1738 public void test_atTime_int_int_int_int_minuteTooSmall() {
1739 LocalDate t = LocalDate.of(2008, 6, 30);
1740 t.atTime(11, -1, 40, 50);
1741 }
1742
1743 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1744 public void test_atTime_int_int_int_int_minuteTooBig() {
1745 LocalDate t = LocalDate.of(2008, 6, 30);
1746 t.atTime(11, 60, 40, 50);
1747 }
1748
1749 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1750 public void test_atTime_int_int_int_int_secondTooSmall() {
1751 LocalDate t = LocalDate.of(2008, 6, 30);
1752 t.atTime(11, 30, -1, 50);
1753 }
1754
1755 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1756 public void test_atTime_int_int_int_int_secondTooBig() {
1757 LocalDate t = LocalDate.of(2008, 6, 30);
1758 t.atTime(11, 30, 60, 50);
1759 }
1760
1761 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1762 public void test_atTime_int_int_int_int_nanoTooSmall() {
1763 LocalDate t = LocalDate.of(2008, 6, 30);
1764 t.atTime(11, 30, 40, -1);
1765 }
1766
1767 @Test(expectedExceptions=DateTimeException.class, groups={"tck"})
1768 public void test_atTime_int_int_int_int_nanoTooBig() {
1769 LocalDate t = LocalDate.of(2008, 6, 30);
1770 t.atTime(11, 30, 40, 1000000000);
1771 }
1772
1773 //-----------------------------------------------------------------------
1774 // atOffset()
1775 //-----------------------------------------------------------------------
1776 @Test(groups={"tck"})
1777 public void test_atOffset() {
1778 LocalDate t = LocalDate.of(2008, 6, 30);
1779 assertEquals(t.atOffset(OFFSET_PTWO), OffsetDate.of(LocalDate.of(2008, 6, 30), OFFSET_PTWO));
1780 }
1781
1782 @Test(expectedExceptions=NullPointerException.class, groups={"tck"})
1783 public void test_atOffset_nullZoneOffset() {
1784 LocalDate t = LocalDate.of(2008, 6, 30);
1785 t.atOffset((ZoneOffset) null);
1786 }
1787
1788 //-----------------------------------------------------------------------
1789 // atStartOfDay()
1790 //-----------------------------------------------------------------------
1791 @Test(groups={"tck"})
1792 public void test_atStartOfDay() {
1793 LocalDate t = LocalDate.of(2008, 6, 30);
1794 assertEquals(t.atStartOfDay(ZONE_PARIS),
1795 ZonedDateTime.of(LocalDateTime.of(2008, 6, 30, 0, 0), ZONE_PARIS));
1796 }
1797
1798 @Test(groups={"tck"})
1799 public void test_atStartOfDay_dstGap() {
1800 LocalDate t = LocalDate.of(2007, 4, 1);
1801 assertEquals(t.atStartOfDay(ZONE_GAZA),
1802 ZonedDateTime.of(LocalDateTime.of(2007, 4, 1, 1, 0), ZONE_GAZA));
1803 }
1804
1805 @Test(expectedExceptions=NullPointerException.class, groups={"tck"})
1806 public void test_atStartOfDay_nullTimeZone() {
1807 LocalDate t = LocalDate.of(2008, 6, 30);
1808 t.atStartOfDay((ZoneId) null);
1809 }
1810
1811 //-----------------------------------------------------------------------
1812 // toEpochDay()
1813 //-----------------------------------------------------------------------
1814 @Test(groups={"tck"})
1815 public void test_toEpochDay() {
1816 long date_0000_01_01 = -678941 - 40587;
1817
1818 LocalDate test = LocalDate.of(0, 1, 1);
1819 for (long i = date_0000_01_01; i < 700000; i++) {
1820 assertEquals(test.toEpochDay(), i);
1821 test = next(test);
1822 }
1823 test = LocalDate.of(0, 1, 1);
1824 for (long i = date_0000_01_01; i > -2000000; i--) {
1825 assertEquals(test.toEpochDay(), i);
1826 test = previous(test);
1827 }
1828
1829 assertEquals(LocalDate.of(1858, 11, 17).toEpochDay(), -40587);
1830 assertEquals(LocalDate.of(1, 1, 1).toEpochDay(), -678575 - 40587);
1831 assertEquals(LocalDate.of(1995, 9, 27).toEpochDay(), 49987 - 40587);
1832 assertEquals(LocalDate.of(1970, 1, 1).toEpochDay(), 0);
1833 assertEquals(LocalDate.of(-1, 12, 31).toEpochDay(), -678942 - 40587);
1834 }
1835
1836 //-----------------------------------------------------------------------
1837 // compareTo()
1838 //-----------------------------------------------------------------------
1839 @Test(groups={"tck"})
1840 public void test_comparisons() {
1841 doTest_comparisons_LocalDate(
1842 LocalDate.of(Year.MIN_VALUE, 1, 1),
1843 LocalDate.of(Year.MIN_VALUE, 12, 31),
1844 LocalDate.of(-1, 1, 1),
1845 LocalDate.of(-1, 12, 31),
1846 LocalDate.of(0, 1, 1),
1847 LocalDate.of(0, 12, 31),
1848 LocalDate.of(1, 1, 1),
1849 LocalDate.of(1, 12, 31),
1850 LocalDate.of(2006, 1, 1),
1851 LocalDate.of(2006, 12, 31),
1852 LocalDate.of(2007, 1, 1),
1853 LocalDate.of(2007, 12, 31),
1854 LocalDate.of(2008, 1, 1),
1855 LocalDate.of(2008, 2, 29),
1856 LocalDate.of(2008, 12, 31),
1857 LocalDate.of(Year.MAX_VALUE, 1, 1),
1858 LocalDate.of(Year.MAX_VALUE, 12, 31)
1859 );
1860 }
1861
1862 void doTest_comparisons_LocalDate(LocalDate... localDates) {
1863 for (int i = 0; i < localDates.length; i++) {
1864 LocalDate a = localDates[i];
1865 for (int j = 0; j < localDates.length; j++) {
1866 LocalDate b = localDates[j];
1867 if (i < j) {
1868 assertTrue(a.compareTo(b) < 0, a + " <=> " + b);
1869 assertEquals(a.isBefore(b), true, a + " <=> " + b);
1870 assertEquals(a.isAfter(b), false, a + " <=> " + b);
1871 assertEquals(a.equals(b), false, a + " <=> " + b);
1872 } else if (i > j) {
1873 assertTrue(a.compareTo(b) > 0, a + " <=> " + b);
1874 assertEquals(a.isBefore(b), false, a + " <=> " + b);
1875 assertEquals(a.isAfter(b), true, a + " <=> " + b);
1876 assertEquals(a.equals(b), false, a + " <=> " + b);
1877 } else {
1878 assertEquals(a.compareTo(b), 0, a + " <=> " + b);
1879 assertEquals(a.isBefore(b), false, a + " <=> " + b);
1880 assertEquals(a.isAfter(b), false, a + " <=> " + b);
1881 assertEquals(a.equals(b), true, a + " <=> " + b);
1882 }
1883 }
1884 }
1885 }
1886
1887 @Test(expectedExceptions=NullPointerException.class, groups={"tck"})
1888 public void test_compareTo_ObjectNull() {
1889 TEST_2007_07_15.compareTo(null);
1890 }
1891
1892 @Test(groups={"tck"})
1893 public void test_isBefore() {
1894 assertTrue(TEST_2007_07_15.isBefore(LocalDate.of(2007, 07, 16)));
1895 assertFalse(TEST_2007_07_15.isBefore(LocalDate.of(2007, 07, 14)));
1896 assertFalse(TEST_2007_07_15.isBefore(TEST_2007_07_15));
1897 }
1898
1899 @Test(expectedExceptions=NullPointerException.class, groups={"tck"})
1900 public void test_isBefore_ObjectNull() {
1901 TEST_2007_07_15.isBefore(null);
1902 }
1903
1904 @Test(expectedExceptions=NullPointerException.class, groups={"tck"})
1905 public void test_isAfter_ObjectNull() {
1906 TEST_2007_07_15.isAfter(null);
1907 }
1908
1909 @Test(groups={"tck"})
1910 public void test_isAfter() {
1911 assertTrue(TEST_2007_07_15.isAfter(LocalDate.of(2007, 07, 14)));
1912 assertFalse(TEST_2007_07_15.isAfter(LocalDate.of(2007, 07, 16)));
1913 assertFalse(TEST_2007_07_15.isAfter(TEST_2007_07_15));
1914 }
1915
1916 @Test(expectedExceptions=ClassCastException.class, groups={"tck"})
1917 @SuppressWarnings({"unchecked", "rawtypes"})
1918 public void compareToNonLocalDate() {
1919 Comparable c = TEST_2007_07_15;
1920 c.compareTo(new Object());
1921 }
1922
1923 //-----------------------------------------------------------------------
1924 // equals()
1925 //-----------------------------------------------------------------------
1926 @Test(dataProvider="sampleDates" , groups={"tck"})
1927 public void test_equals_true(int y, int m, int d) {
1928 LocalDate a = LocalDate.of(y, m, d);
1929 LocalDate b = LocalDate.of(y, m, d);
1930 assertEquals(a.equals(b), true);
1931 }
1932 @Test(dataProvider="sampleDates", groups={"tck"})
1933 public void test_equals_false_year_differs(int y, int m, int d) {
1934 LocalDate a = LocalDate.of(y, m, d);
1935 LocalDate b = LocalDate.of(y + 1, m, d);
1936 assertEquals(a.equals(b), false);
1937 }
1938 @Test(dataProvider="sampleDates", groups={"tck"})
1939 public void test_equals_false_month_differs(int y, int m, int d) {
1940 LocalDate a = LocalDate.of(y, m, d);
1941 LocalDate b = LocalDate.of(y, m + 1, d);
1942 assertEquals(a.equals(b), false);
1943 }
1944 @Test(dataProvider="sampleDates", groups={"tck"})
1945 public void test_equals_false_day_differs(int y, int m, int d) {
1946 LocalDate a = LocalDate.of(y, m, d);
1947 LocalDate b = LocalDate.of(y, m, d + 1);
1948 assertEquals(a.equals(b), false);
1949 }
1950
1951 @Test(groups={"tck"})
1952 public void test_equals_itself_true() {
1953 assertEquals(TEST_2007_07_15.equals(TEST_2007_07_15), true);
1954 }
1955
1956 @Test(groups={"tck"})
1957 public void test_equals_string_false() {
1958 assertEquals(TEST_2007_07_15.equals("2007-07-15"), false);
1959 }
1960
1961 @Test(groups={"tck"})
1962 public void test_equals_null_false() {
1963 assertEquals(TEST_2007_07_15.equals(null), false);
1964 }
1965
1966 //-----------------------------------------------------------------------
1967 // hashCode()
1968 //-----------------------------------------------------------------------
1969 @Test(dataProvider="sampleDates", groups={"tck"})
1970 public void test_hashCode(int y, int m, int d) {
1971 LocalDate a = LocalDate.of(y, m, d);
1972 assertEquals(a.hashCode(), a.hashCode());
1973 LocalDate b = LocalDate.of(y, m, d);
1974 assertEquals(a.hashCode(), b.hashCode());
1975 }
1976
1977 //-----------------------------------------------------------------------
1978 // toString()
1979 //-----------------------------------------------------------------------
1980 @DataProvider(name="sampleToString")
1981 Object[][] provider_sampleToString() {
1982 return new Object[][] {
1983 {2008, 7, 5, "2008-07-05"},
1984 {2007, 12, 31, "2007-12-31"},
1985 {999, 12, 31, "0999-12-31"},
1986 {-1, 1, 2, "-0001-01-02"},
1987 {9999, 12, 31, "9999-12-31"},
1988 {-9999, 12, 31, "-9999-12-31"},
1989 {10000, 1, 1, "+10000-01-01"},
1990 {-10000, 1, 1, "-10000-01-01"},
1991 {12345678, 1, 1, "+12345678-01-01"},
1992 {-12345678, 1, 1, "-12345678-01-01"},
1993 };
1994 }
1995
1996 @Test(dataProvider="sampleToString", groups={"tck"})
1997 public void test_toString(int y, int m, int d, String expected) {
1998 LocalDate t = LocalDate.of(y, m, d);
1999 String str = t.toString();
2000 assertEquals(str, expected);
2001 }
2002
2003 //-----------------------------------------------------------------------
2004 // toString(DateTimeFormatter)
2005 //-----------------------------------------------------------------------
2006 @Test(groups={"tck"})
2007 public void test_toString_formatter() {
2008 DateTimeFormatter f = DateTimeFormatters.pattern("y M d");
2009 String t = LocalDate.of(2010, 12, 3).toString(f);
2010 assertEquals(t, "2010 12 3");
2011 }
2012
2013 @Test(expectedExceptions=NullPointerException.class, groups={"tck"})
2014 public void test_toString_formatter_null() {
2015 LocalDate.of(2010, 12, 3).toString(null);
2016 }
2017
2018 }