102 import java.time.ZoneOffset;
103 import java.time.ZonedDateTime;
104 import java.time.chrono.IsoChronology;
105 import java.time.chrono.IsoEra;
106 import java.time.format.DateTimeFormatter;
107 import java.time.format.DateTimeParseException;
108 import java.time.temporal.ChronoField;
109 import java.time.temporal.ChronoUnit;
110 import java.time.temporal.JulianFields;
111 import java.time.temporal.Temporal;
112 import java.time.temporal.TemporalAccessor;
113 import java.time.temporal.TemporalAdjuster;
114 import java.time.temporal.TemporalField;
115 import java.time.temporal.TemporalQueries;
116 import java.time.temporal.TemporalQuery;
117 import java.time.temporal.TemporalUnit;
118 import java.time.temporal.UnsupportedTemporalTypeException;
119 import java.util.ArrayList;
120 import java.util.Arrays;
121 import java.util.List;
122
123 import org.testng.annotations.BeforeMethod;
124 import org.testng.annotations.DataProvider;
125 import org.testng.annotations.Test;
126 import test.java.time.MockSimplePeriod;
127 import test.java.time.temporal.MockFieldNoValue;
128
129 /**
130 * Test LocalDate.
131 */
132 @Test
133 public class TCKLocalDate extends AbstractDateTimeTest {
134
135 private static final ZoneOffset OFFSET_PONE = ZoneOffset.ofHours(1);
136 private static final ZoneOffset OFFSET_PTWO = ZoneOffset.ofHours(2);
137 private static final ZoneOffset OFFSET_MTWO = ZoneOffset.ofHours(-2);
138 private static final ZoneId ZONE_PARIS = ZoneId.of("Europe/Paris");
139 private static final ZoneId ZONE_GAZA = ZoneId.of("Asia/Gaza");
140
141 private LocalDate TEST_2007_07_15;
2343
2344 @Test(dataProvider="sampleToString")
2345 public void test_toString(int y, int m, int d, String expected) {
2346 LocalDate t = LocalDate.of(y, m, d);
2347 String str = t.toString();
2348 assertEquals(str, expected);
2349 }
2350
2351 private LocalDate date(int year, int month, int day) {
2352 return LocalDate.of(year, month, day);
2353 }
2354
2355 //-----------------------------------------------------------------
2356 // getEra()
2357 // ----------------------------------------------------------------
2358 @Test
2359 public void test_getEra() {
2360 IsoEra isoEra = LocalDate.MAX.getEra();
2361 assertSame(isoEra,IsoEra.CE);
2362 assertSame(LocalDate.MIN.getEra(),IsoEra.BCE);
2363 }
2364 }
|
102 import java.time.ZoneOffset;
103 import java.time.ZonedDateTime;
104 import java.time.chrono.IsoChronology;
105 import java.time.chrono.IsoEra;
106 import java.time.format.DateTimeFormatter;
107 import java.time.format.DateTimeParseException;
108 import java.time.temporal.ChronoField;
109 import java.time.temporal.ChronoUnit;
110 import java.time.temporal.JulianFields;
111 import java.time.temporal.Temporal;
112 import java.time.temporal.TemporalAccessor;
113 import java.time.temporal.TemporalAdjuster;
114 import java.time.temporal.TemporalField;
115 import java.time.temporal.TemporalQueries;
116 import java.time.temporal.TemporalQuery;
117 import java.time.temporal.TemporalUnit;
118 import java.time.temporal.UnsupportedTemporalTypeException;
119 import java.util.ArrayList;
120 import java.util.Arrays;
121 import java.util.List;
122 import java.util.stream.Collectors;
123
124 import org.testng.annotations.BeforeMethod;
125 import org.testng.annotations.DataProvider;
126 import org.testng.annotations.Test;
127 import test.java.time.MockSimplePeriod;
128 import test.java.time.temporal.MockFieldNoValue;
129
130 /**
131 * Test LocalDate.
132 */
133 @Test
134 public class TCKLocalDate extends AbstractDateTimeTest {
135
136 private static final ZoneOffset OFFSET_PONE = ZoneOffset.ofHours(1);
137 private static final ZoneOffset OFFSET_PTWO = ZoneOffset.ofHours(2);
138 private static final ZoneOffset OFFSET_MTWO = ZoneOffset.ofHours(-2);
139 private static final ZoneId ZONE_PARIS = ZoneId.of("Europe/Paris");
140 private static final ZoneId ZONE_GAZA = ZoneId.of("Asia/Gaza");
141
142 private LocalDate TEST_2007_07_15;
2344
2345 @Test(dataProvider="sampleToString")
2346 public void test_toString(int y, int m, int d, String expected) {
2347 LocalDate t = LocalDate.of(y, m, d);
2348 String str = t.toString();
2349 assertEquals(str, expected);
2350 }
2351
2352 private LocalDate date(int year, int month, int day) {
2353 return LocalDate.of(year, month, day);
2354 }
2355
2356 //-----------------------------------------------------------------
2357 // getEra()
2358 // ----------------------------------------------------------------
2359 @Test
2360 public void test_getEra() {
2361 IsoEra isoEra = LocalDate.MAX.getEra();
2362 assertSame(isoEra,IsoEra.CE);
2363 assertSame(LocalDate.MIN.getEra(),IsoEra.BCE);
2364 }
2365
2366 //-----------------------------------------------------------------
2367 // datesUntil()
2368 // ----------------------------------------------------------------
2369 @Test
2370 public void test_datesUntil() {
2371 assertEquals(
2372 date(2015, 9, 29).datesUntil(date(2015, 10, 3)).collect(
2373 Collectors.toList()), Arrays.asList(date(2015, 9, 29),
2374 date(2015, 9, 30), date(2015, 10, 1), date(2015, 10, 2)));
2375 assertEquals(date(2015, 9, 29).datesUntil(date(2015, 10, 3), Period.ofDays(2))
2376 .collect(Collectors.toList()), Arrays.asList(date(2015, 9, 29),
2377 date(2015, 10, 1)));
2378 assertEquals(date(2015, 1, 31).datesUntil(date(2015, 6, 1), Period.ofMonths(1))
2379 .collect(Collectors.toList()), Arrays.asList(date(2015, 1, 31),
2380 date(2015, 2, 28), date(2015, 3, 31), date(2015, 4, 30),
2381 date(2015, 5, 31)));
2382 }
2383
2384 @Test(expectedExceptions=NullPointerException.class)
2385 public void test_datesUntil_nullEnd() {
2386 LocalDate date = date(2015, 1, 31);
2387 date.datesUntil(null);
2388 }
2389
2390 @Test(expectedExceptions=NullPointerException.class)
2391 public void test_datesUntil_nullEndStep() {
2392 LocalDate date = date(2015, 1, 31);
2393 date.datesUntil(null, Period.ofDays(1));
2394 }
2395
2396 @Test(expectedExceptions=NullPointerException.class)
2397 public void test_datesUntil_nullStep() {
2398 LocalDate date = date(2015, 1, 31);
2399 date.datesUntil(date, null);
2400 }
2401
2402 @Test(expectedExceptions=IllegalArgumentException.class)
2403 public void test_datesUntil_zeroStep() {
2404 LocalDate date = date(2015, 1, 31);
2405 date.datesUntil(date, Period.ZERO);
2406 }
2407
2408 @Test(expectedExceptions=IllegalArgumentException.class)
2409 public void test_datesUntil_negativeStep() {
2410 LocalDate date = date(2015, 1, 31);
2411 date.datesUntil(date, Period.of(1, 0, -1));
2412 }
2413
2414 @DataProvider(name="datesUntil")
2415 public Object[][] provider_datesUntil() {
2416 return new Object[][] {
2417 {MIN_DATE, MIN_DATE},
2418 {MIN_DATE, MAX_DATE},
2419 {MAX_DATE, MAX_DATE},
2420 {date(2015,10,1), date(2015,10,2)},
2421 {date(2015,10,1), date(2015,11,1)},
2422 {date(2015,10,31), date(2015,11,1)},
2423 {date(2015,10,1), MAX_DATE},
2424 {MIN_DATE, date(2015,10,1)}
2425 };
2426 }
2427
2428 @Test(dataProvider = "datesUntil")
2429 public void test_datesUntil_count(LocalDate start, LocalDate end) {
2430 assertEquals(end.datesUntil(start).count(), 0L);
2431 assertEquals(end.datesUntil(start, Period.ofYears(1)).count(), 0L);
2432 assertEquals(end.datesUntil(start, Period.ofMonths(1)).count(), 0L);
2433 assertEquals(end.datesUntil(start, Period.ofDays(1)).count(), 0L);
2434 assertEquals(start.datesUntil(end).count(), start.until(end, ChronoUnit.DAYS));
2435 assertEquals(start.datesUntil(end, Period.ofDays(1)).count(),
2436 start.until(end, ChronoUnit.DAYS));
2437 }
2438
2439 @DataProvider(name="datesUntilSteps")
2440 public Object[][] provider_datesUntil_steps() {
2441 List<Object[]> data = new ArrayList<>(Arrays.asList(new Object[][] {
2442 {MIN_DATE, MAX_DATE, Period.ofYears(Year.MAX_VALUE)},
2443 {MIN_DATE, MAX_DATE, Period.ofDays(2)},
2444 {MIN_DATE, MAX_DATE, Period.of(1,2,3)},
2445 {MIN_DATE, MAX_DATE, Period.of(1,2,1000000)},
2446 {MIN_DATE, MAX_DATE, Period.of(1,1000000,3)},
2447 {MIN_DATE, MAX_DATE, Period.of(1000000,2,3)},
2448 {MIN_DATE, MAX_DATE.minusYears(1), Period.ofYears(Year.MAX_VALUE)},
2449 {MAX_DATE.minusMonths(1), MAX_DATE, Period.ofMonths(1)},
2450 {date(Year.MAX_VALUE, 2, 20), MAX_DATE, Period.of(0, 1, 1)},
2451 {date(2015,1,1), date(2016,1,1), Period.ofYears(1)},
2452 {date(2015,1,1), date(2016,1,1), Period.ofDays(365)},
2453 {date(2015,1,1), date(2016,1,1), Period.ofDays(366)},
2454 {date(2015,1,1), date(2016,1,1), Period.ofDays(4)},
2455 {date(2015,1,1), date(2016,1,1), Period.of(0,1,2)},
2456 {date(2015,1,1), date(2016,1,1), Period.ofMonths(1)},
2457 {date(2015,1,1), date(2016,1,1), Period.ofMonths(12)},
2458 {date(2015,1,1), date(2016,1,2), Period.ofMonths(12)},
2459 {date(2015,1,1), date(2016,1,1), Period.of(0, 11, 30)},
2460 {date(2015,1,1), date(2015,12,31), Period.of(0, 11, 30)},
2461 {date(2015,1,31), date(2015,12,31), Period.ofMonths(2)},
2462 {date(2015,1,31), date(2015,12,1), Period.ofMonths(2)},
2463 {date(2015,1,31), date(2015,11,30), Period.ofMonths(2)},
2464 {date(2015,1,31), date(2030,11,30), Period.of(1,30,365)},
2465 {date(2015,1,31), date(2043,1,31), Period.of(4,0,0)},
2466 {date(2015,1,31), date(2043,2,1), Period.of(4,0,0)},
2467 {date(2015,1,31), date(2043,1,31), Period.of(3,11,30)},
2468 {date(2015,1,31), date(2043,2,1), Period.of(3,11,30)},
2469 {date(2015,1,31), date(2043,1,31), Period.of(0,0,1460)},
2470 {date(2015,1,31), date(2043,1,31), Period.of(0,0,1461)},
2471 {date(2015,1,31), date(2043,2,1), Period.of(0,0,1461)},
2472 {date(2015,1,31), MAX_DATE, Period.of(10,100,1000)},
2473 {date(2015,1,31), MAX_DATE, Period.of(1000000,10000,100000)},
2474 {date(2015,1,31), MAX_DATE, Period.ofDays(10000000)},
2475 {date(2015,1,31), MAX_DATE, Period.ofDays(Integer.MAX_VALUE)},
2476 {date(2015,1,31), MAX_DATE, Period.ofMonths(Integer.MAX_VALUE)},
2477 {date(2015,1,31), MAX_DATE, Period.ofYears(Integer.MAX_VALUE)}
2478 }));
2479 LocalDate start = date(2014, 1, 15);
2480 LocalDate end = date(2015, 3, 4);
2481 for (int months : new int[] { 0, 1, 2, 6, 12, 13 }) {
2482 for (int days = 0; days < 80; days++) {
2483 if (months > 0 || days > 0)
2484 data.add(new Object[] { start, end, Period.of(0, months, days) });
2485 }
2486 }
2487 for (int days = 27; days < 100; days++) {
2488 data.add(new Object[] { start, start.plusDays(days), Period.ofMonths(1) });
2489 }
2490 return data.toArray(new Object[data.size()][]);
2491 }
2492
2493 @Test(dataProvider="datesUntilSteps")
2494 public void test_datesUntil_step(LocalDate start, LocalDate end, Period step) {
2495 // Reverse range: must produce empty stream
2496 assertEquals(end.datesUntil(start, step).count(), 0);
2497 long count = start.datesUntil(end, step).count();
2498 if(start.equals(end)) {
2499 assertTrue(count == 0);
2500 } else {
2501 assertTrue(count > 0);
2502 // the last value must be before the end date
2503 assertTrue(start.plusMonths(step.toTotalMonths()*(count-1))
2504 .plusDays(step.getDays()*(count-1)).isBefore(end));
2505 try {
2506 // the next after the last value must be either invalid
2507 // or not before the end date
2508 assertFalse(start.plusMonths(step.toTotalMonths()*count)
2509 .plusDays(step.getDays()*count).isBefore(end));
2510 } catch (ArithmeticException | DateTimeException e) {
2511 // ignore: possible overflow for the next value is ok
2512 }
2513 if(count < 1000) {
2514 assertTrue(start.datesUntil(end, step)
2515 .allMatch(date -> !date.isBefore(start) && date.isBefore(end)));
2516 List<LocalDate> list = new ArrayList<>();
2517 for(long i=0; i<count; i++) {
2518 list.add(start.plusMonths(step.toTotalMonths()*i)
2519 .plusDays(step.getDays()*i));
2520 }
2521 assertEquals(start.datesUntil(end, step)
2522 .collect(Collectors.toList()), list);
2523 }
2524 }
2525 }
2526 }
|