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.INSTANT_SECONDS;
63 import static java.time.temporal.ChronoField.MICRO_OF_SECOND;
64 import static java.time.temporal.ChronoField.MILLI_OF_SECOND;
65 import static java.time.temporal.ChronoField.NANO_OF_SECOND;
66 import static java.time.temporal.ChronoUnit.DAYS;
67 import static java.time.temporal.ChronoUnit.HOURS;
68 import static java.time.temporal.ChronoUnit.MICROS;
69 import static java.time.temporal.ChronoUnit.MILLIS;
70 import static java.time.temporal.ChronoUnit.MINUTES;
71 import static java.time.temporal.ChronoUnit.MONTHS;
72 import static java.time.temporal.ChronoUnit.NANOS;
73 import static java.time.temporal.ChronoUnit.SECONDS;
74 import static java.time.temporal.ChronoUnit.WEEKS;
75 import static java.time.temporal.ChronoUnit.YEARS;
76 import static org.testng.Assert.assertEquals;
77 import static org.testng.Assert.assertTrue;
78 import static org.testng.Assert.fail;
79
80 import java.io.ByteArrayOutputStream;
81 import java.io.DataOutputStream;
82 import java.time.Clock;
83 import java.time.DateTimeException;
84 import java.time.Duration;
85 import java.time.Instant;
86 import java.time.LocalDateTime;
87 import java.time.LocalTime;
88 import java.time.OffsetDateTime;
89 import java.time.ZoneId;
90 import java.time.ZoneOffset;
91 import java.time.ZonedDateTime;
92 import java.time.format.DateTimeParseException;
93 import java.time.temporal.ChronoField;
94 import java.time.temporal.JulianFields;
95 import java.time.temporal.Temporal;
96 import java.time.temporal.TemporalAccessor;
97 import java.time.temporal.TemporalAdjuster;
98 import java.time.temporal.TemporalAmount;
99 import java.time.temporal.TemporalField;
100 import java.time.temporal.TemporalQueries;
101 import java.time.temporal.TemporalQuery;
102 import java.time.temporal.TemporalUnit;
103 import java.time.temporal.UnsupportedTemporalTypeException;
104 import java.util.ArrayList;
105 import java.util.Arrays;
106 import java.util.List;
107 import java.util.Locale;
108
109 import org.testng.annotations.BeforeMethod;
110 import org.testng.annotations.DataProvider;
111 import org.testng.annotations.Test;
112
113 /**
114 * Test Instant.
115 *
116 * @bug 8133022
117 */
118 @Test
119 public class TCKInstant extends AbstractDateTimeTest {
120
121 private static final long MIN_SECOND = Instant.MIN.getEpochSecond();
122 private static final long MAX_SECOND = Instant.MAX.getEpochSecond();
123 private static final ZoneId ZONE_PARIS = ZoneId.of("Europe/Paris");
124 private static final ZoneOffset OFFSET_PTWO = ZoneOffset.ofHours(2);
125
126 private Instant TEST_12345_123456789;
127
128 @BeforeMethod
129 public void setUp() {
130 TEST_12345_123456789 = Instant.ofEpochSecond(12345, 123456789);
131 }
132
133 //-----------------------------------------------------------------------
134 @Override
135 protected List<TemporalAccessor> samples() {
136 TemporalAccessor[] array = {TEST_12345_123456789, Instant.MIN, Instant.MAX, Instant.EPOCH};
137 return Arrays.asList(array);
138 }
139
140 @Override
141 protected List<TemporalField> validFields() {
142 TemporalField[] array = {
143 NANO_OF_SECOND,
144 MICRO_OF_SECOND,
145 MILLI_OF_SECOND,
146 INSTANT_SECONDS,
147 };
148 return Arrays.asList(array);
149 }
150
151 @Override
152 protected List<TemporalField> invalidFields() {
153 List<TemporalField> list = new ArrayList<>(Arrays.<TemporalField>asList(ChronoField.values()));
154 list.removeAll(validFields());
155 list.add(JulianFields.JULIAN_DAY);
156 list.add(JulianFields.MODIFIED_JULIAN_DAY);
157 list.add(JulianFields.RATA_DIE);
158 return list;
159 }
160
161 //-----------------------------------------------------------------------
162 private void check(Instant instant, long epochSecs, int nos) {
163 assertEquals(instant.getEpochSecond(), epochSecs);
164 assertEquals(instant.getNano(), nos);
165 assertEquals(instant, instant);
166 assertEquals(instant.hashCode(), instant.hashCode());
167 }
168
169 //-----------------------------------------------------------------------
170 @Test
171 public void constant_EPOCH() {
172 check(Instant.EPOCH, 0, 0);
173 }
174
175 @Test
176 public void constant_MIN() {
177 check(Instant.MIN, -31557014167219200L, 0);
178 }
179
180 @Test
181 public void constant_MAX() {
182 check(Instant.MAX, 31556889864403199L, 999_999_999);
183 }
184
185 //-----------------------------------------------------------------------
186 // now()
187 //-----------------------------------------------------------------------
188 @Test
189 public void now() {
190 Instant expected = Instant.now(Clock.systemUTC());
191 Instant test = Instant.now();
192 long diff = Math.abs(test.toEpochMilli() - expected.toEpochMilli());
193 assertTrue(diff < 100); // less than 0.1 secs
194 }
195
196 //-----------------------------------------------------------------------
197 // now(Clock)
198 //-----------------------------------------------------------------------
199 @Test(expectedExceptions=NullPointerException.class)
200 public void now_Clock_nullClock() {
201 Instant.now(null);
202 }
203
204 @Test
205 public void now_Clock_allSecsInDay_utc() {
206 for (int i = 0; i < (2 * 24 * 60 * 60); i++) {
207 Instant expected = Instant.ofEpochSecond(i).plusNanos(123456789L);
208 Clock clock = Clock.fixed(expected, ZoneOffset.UTC);
209 Instant test = Instant.now(clock);
210 assertEquals(test, expected);
211 }
212 }
213
214 @Test
215 public void now_Clock_allSecsInDay_beforeEpoch() {
216 for (int i =-1; i >= -(24 * 60 * 60); i--) {
217 Instant expected = Instant.ofEpochSecond(i).plusNanos(123456789L);
218 Clock clock = Clock.fixed(expected, ZoneOffset.UTC);
219 Instant test = Instant.now(clock);
220 assertEquals(test, expected);
221 }
222 }
223
224 //-----------------------------------------------------------------------
225 // ofEpochSecond(long)
226 //-----------------------------------------------------------------------
227 @Test
228 public void factory_seconds_long() {
229 for (long i = -2; i <= 2; i++) {
230 Instant t = Instant.ofEpochSecond(i);
231 assertEquals(t.getEpochSecond(), i);
232 assertEquals(t.getNano(), 0);
233 }
234 }
235
236 //-----------------------------------------------------------------------
237 // ofEpochSecond(long,long)
238 //-----------------------------------------------------------------------
239 @Test
240 public void factory_seconds_long_long() {
241 for (long i = -2; i <= 2; i++) {
242 for (int j = 0; j < 10; j++) {
243 Instant t = Instant.ofEpochSecond(i, j);
244 assertEquals(t.getEpochSecond(), i);
245 assertEquals(t.getNano(), j);
246 }
247 for (int j = -10; j < 0; j++) {
248 Instant t = Instant.ofEpochSecond(i, j);
249 assertEquals(t.getEpochSecond(), i - 1);
250 assertEquals(t.getNano(), j + 1000000000);
251 }
252 for (int j = 999999990; j < 1000000000; j++) {
253 Instant t = Instant.ofEpochSecond(i, j);
254 assertEquals(t.getEpochSecond(), i);
255 assertEquals(t.getNano(), j);
256 }
257 }
258 }
259
260 @Test
261 public void factory_seconds_long_long_nanosNegativeAdjusted() {
262 Instant test = Instant.ofEpochSecond(2L, -1);
263 assertEquals(test.getEpochSecond(), 1);
264 assertEquals(test.getNano(), 999999999);
265 }
266
267 @Test(expectedExceptions=DateTimeException.class)
268 public void factory_seconds_long_long_tooBig() {
269 Instant.ofEpochSecond(MAX_SECOND, 1000000000);
270 }
271
272 @Test(expectedExceptions=ArithmeticException.class)
273 public void factory_seconds_long_long_tooBigBig() {
274 Instant.ofEpochSecond(Long.MAX_VALUE, Long.MAX_VALUE);
275 }
276
277 //-----------------------------------------------------------------------
278 // ofEpochMilli(long)
279 //-----------------------------------------------------------------------
280 @DataProvider(name="MillisInstantNoNanos")
281 Object[][] provider_factory_millis_long() {
282 return new Object[][] {
283 {0, 0, 0},
284 {1, 0, 1000000},
285 {2, 0, 2000000},
286 {999, 0, 999000000},
287 {1000, 1, 0},
288 {1001, 1, 1000000},
289 {-1, -1, 999000000},
290 {-2, -1, 998000000},
291 {-999, -1, 1000000},
292 {-1000, -1, 0},
293 {-1001, -2, 999000000},
294 };
295 }
296
297 @Test(dataProvider="MillisInstantNoNanos")
298 public void factory_millis_long(long millis, long expectedSeconds, int expectedNanoOfSecond) {
299 Instant t = Instant.ofEpochMilli(millis);
300 assertEquals(t.getEpochSecond(), expectedSeconds);
301 assertEquals(t.getNano(), expectedNanoOfSecond);
302 }
303
304 //-----------------------------------------------------------------------
305 // parse(String)
306 //-----------------------------------------------------------------------
307 // see also parse tests under toString()
308 @DataProvider(name="Parse")
309 Object[][] provider_factory_parse() {
310 return new Object[][] {
311 {"1970-01-01T00:00:00Z", 0, 0},
312 {"1970-01-01t00:00:00Z", 0, 0},
313 {"1970-01-01T00:00:00z", 0, 0},
314 {"1970-01-01T00:00:00.0Z", 0, 0},
315 {"1970-01-01T00:00:00.000000000Z", 0, 0},
316
317 {"1970-01-01T00:00:00.000000001Z", 0, 1},
318 {"1970-01-01T00:00:00.100000000Z", 0, 100000000},
319 {"1970-01-01T00:00:01Z", 1, 0},
320 {"1970-01-01T00:01:00Z", 60, 0},
321 {"1970-01-01T00:01:01Z", 61, 0},
322 {"1970-01-01T00:01:01.000000001Z", 61, 1},
323 {"1970-01-01T01:00:00.000000000Z", 3600, 0},
324 {"1970-01-01T01:01:01.000000001Z", 3661, 1},
325 {"1970-01-02T01:01:01.100000000Z", 90061, 100000000},
326 };
327 }
328
329 @Test(dataProvider="Parse")
330 public void factory_parse(String text, long expectedEpochSeconds, int expectedNanoOfSecond) {
331 Instant t = Instant.parse(text);
332 assertEquals(t.getEpochSecond(), expectedEpochSeconds);
333 assertEquals(t.getNano(), expectedNanoOfSecond);
334 }
335
336 @Test(dataProvider="Parse")
337 public void factory_parseLowercase(String text, long expectedEpochSeconds, int expectedNanoOfSecond) {
338 Instant t = Instant.parse(text.toLowerCase(Locale.ENGLISH));
339 assertEquals(t.getEpochSecond(), expectedEpochSeconds);
340 assertEquals(t.getNano(), expectedNanoOfSecond);
341 }
342
343 // TODO: should comma be accepted?
344 // @Test(dataProvider="Parse")
345 // public void factory_parse_comma(String text, long expectedEpochSeconds, int expectedNanoOfSecond) {
346 // text = text.replace('.', ',');
347 // Instant t = Instant.parse(text);
348 // assertEquals(t.getEpochSecond(), expectedEpochSeconds);
349 // assertEquals(t.getNano(), expectedNanoOfSecond);
350 // }
351
352 @DataProvider(name="ParseFailures")
353 Object[][] provider_factory_parseFailures() {
354 return new Object[][] {
355 {""},
356 {"Z"},
357 {"1970-01-01T00:00:00"},
358 {"1970-01-01T00:00:0Z"},
359 {"1970-01-01T00:0:00Z"},
360 {"1970-01-01T0:00:00Z"},
361 {"1970-01-01T00:00:00.0000000000Z"},
362 };
363 }
364
365 @Test(dataProvider="ParseFailures", expectedExceptions=DateTimeParseException.class)
366 public void factory_parseFailures(String text) {
367 Instant.parse(text);
368 }
369
370 @Test(dataProvider="ParseFailures", expectedExceptions=DateTimeParseException.class)
371 public void factory_parseFailures_comma(String text) {
372 text = text.replace('.', ',');
373 Instant.parse(text);
374 }
375
376 @Test(expectedExceptions=NullPointerException.class)
377 public void factory_parse_nullText() {
378 Instant.parse(null);
379 }
380
381 //-----------------------------------------------------------------------
382 // get(TemporalField)
383 //-----------------------------------------------------------------------
384 @Test
385 public void test_get_TemporalField() {
386 Instant test = TEST_12345_123456789;
387 assertEquals(test.get(ChronoField.NANO_OF_SECOND), 123456789);
388 assertEquals(test.get(ChronoField.MICRO_OF_SECOND), 123456);
389 assertEquals(test.get(ChronoField.MILLI_OF_SECOND), 123);
390 }
391
392 @Test
393 public void test_getLong_TemporalField() {
394 Instant test = TEST_12345_123456789;
395 assertEquals(test.getLong(ChronoField.NANO_OF_SECOND), 123456789);
396 assertEquals(test.getLong(ChronoField.MICRO_OF_SECOND), 123456);
397 assertEquals(test.getLong(ChronoField.MILLI_OF_SECOND), 123);
398 assertEquals(test.getLong(ChronoField.INSTANT_SECONDS), 12345);
399 }
400
401 //-----------------------------------------------------------------------
402 // query(TemporalQuery)
403 //-----------------------------------------------------------------------
404 @DataProvider(name="query")
405 Object[][] data_query() {
406 return new Object[][] {
407 {TEST_12345_123456789, TemporalQueries.chronology(), null},
408 {TEST_12345_123456789, TemporalQueries.zoneId(), null},
409 {TEST_12345_123456789, TemporalQueries.precision(), NANOS},
410 {TEST_12345_123456789, TemporalQueries.zone(), null},
411 {TEST_12345_123456789, TemporalQueries.offset(), null},
412 {TEST_12345_123456789, TemporalQueries.localDate(), null},
413 {TEST_12345_123456789, TemporalQueries.localTime(), null},
414 };
415 }
416
417 @Test(dataProvider="query")
418 public <T> void test_query(TemporalAccessor temporal, TemporalQuery<T> query, T expected) {
419 assertEquals(temporal.query(query), expected);
420 }
421
422 @Test(dataProvider="query")
423 public <T> void test_queryFrom(TemporalAccessor temporal, TemporalQuery<T> query, T expected) {
424 assertEquals(query.queryFrom(temporal), expected);
425 }
426
427 @Test(expectedExceptions=NullPointerException.class)
428 public void test_query_null() {
429 TEST_12345_123456789.query(null);
430 }
431
432 //-----------------------------------------------------------------------
433 // adjustInto(Temporal)
434 //-----------------------------------------------------------------------
435 @DataProvider(name="adjustInto")
436 Object[][] data_adjustInto() {
437 return new Object[][]{
438 {Instant.ofEpochSecond(10, 200), Instant.ofEpochSecond(20), Instant.ofEpochSecond(10, 200), null},
439 {Instant.ofEpochSecond(10, -200), Instant.now(), Instant.ofEpochSecond(10, -200), null},
440 {Instant.ofEpochSecond(-10), Instant.EPOCH, Instant.ofEpochSecond(-10), null},
441 {Instant.ofEpochSecond(10), Instant.MIN, Instant.ofEpochSecond(10), null},
442 {Instant.ofEpochSecond(10), Instant.MAX, Instant.ofEpochSecond(10), null},
443
444 {Instant.ofEpochSecond(10, 200), LocalDateTime.of(1970, 1, 1, 0, 0, 20).toInstant(ZoneOffset.UTC), Instant.ofEpochSecond(10, 200), null},
445 {Instant.ofEpochSecond(10, 200), OffsetDateTime.of(1970, 1, 1, 0, 0, 20, 10, ZoneOffset.UTC), OffsetDateTime.of(1970, 1, 1, 0, 0, 10, 200, ZoneOffset.UTC), null},
446 {Instant.ofEpochSecond(10, 200), OffsetDateTime.of(1970, 1, 1, 0, 0, 20, 10, OFFSET_PTWO), OffsetDateTime.of(1970, 1, 1, 2, 0, 10, 200, OFFSET_PTWO), null},
447 {Instant.ofEpochSecond(10, 200), ZonedDateTime.of(1970, 1, 1, 0, 0, 20, 10, ZONE_PARIS), ZonedDateTime.of(1970, 1, 1, 1, 0, 10, 200, ZONE_PARIS), null},
448
449 {Instant.ofEpochSecond(10, 200), LocalDateTime.of(1970, 1, 1, 0, 0, 20), null, DateTimeException.class},
450 {Instant.ofEpochSecond(10, 200), null, null, NullPointerException.class},
451
452 };
453 }
454
455 @Test(dataProvider="adjustInto")
456 public void test_adjustInto(Instant test, Temporal temporal, Temporal expected, Class<?> expectedEx) {
457 if (expectedEx == null) {
458 Temporal result = test.adjustInto(temporal);
459 assertEquals(result, expected);
460 } else {
461 try {
462 Temporal result = test.adjustInto(temporal);
463 fail();
464 } catch (Exception ex) {
465 assertTrue(expectedEx.isInstance(ex));
466 }
467 }
468 }
469
470 //-----------------------------------------------------------------------
471 // with(TemporalAdjuster)
472 //-----------------------------------------------------------------------
473 @DataProvider(name="with")
474 Object[][] data_with() {
475 return new Object[][]{
476 {Instant.ofEpochSecond(10, 200), Instant.ofEpochSecond(20), Instant.ofEpochSecond(20), null},
477 {Instant.ofEpochSecond(10), Instant.ofEpochSecond(20, -100), Instant.ofEpochSecond(20, -100), null},
478 {Instant.ofEpochSecond(-10), Instant.EPOCH, Instant.ofEpochSecond(0), null},
479 {Instant.ofEpochSecond(10), Instant.MIN, Instant.MIN, null},
480 {Instant.ofEpochSecond(10), Instant.MAX, Instant.MAX, null},
481
482 {Instant.ofEpochSecond(10, 200), LocalDateTime.of(1970, 1, 1, 0, 0, 20).toInstant(ZoneOffset.UTC), Instant.ofEpochSecond(20), null},
483
484 {Instant.ofEpochSecond(10, 200), LocalDateTime.of(1970, 1, 1, 0, 0, 20), null, DateTimeException.class},
485 {Instant.ofEpochSecond(10, 200), null, null, NullPointerException.class},
486
487 };
488 }
489
490
491 @Test(dataProvider="with")
492 public void test_with_temporalAdjuster(Instant test, TemporalAdjuster adjuster, Instant expected, Class<?> expectedEx) {
493 if (expectedEx == null) {
494 Instant result = test.with(adjuster);
495 assertEquals(result, expected);
496 } else {
497 try {
498 Instant result = test.with(adjuster);
499 fail();
500 } catch (Exception ex) {
501 assertTrue(expectedEx.isInstance(ex));
502 }
503 }
504 }
505
506 //-----------------------------------------------------------------------
507 // with(TemporalField, long)
508 //-----------------------------------------------------------------------
509 @DataProvider(name="with_longTemporalField")
510 Object[][] data_with_longTemporalField() {
511 return new Object[][]{
512 {Instant.ofEpochSecond(10, 200), ChronoField.INSTANT_SECONDS, 100, Instant.ofEpochSecond(100, 200), null},
513 {Instant.ofEpochSecond(10, 200), ChronoField.INSTANT_SECONDS, 0, Instant.ofEpochSecond(0, 200), null},
514 {Instant.ofEpochSecond(10, 200), ChronoField.INSTANT_SECONDS, -100, Instant.ofEpochSecond(-100, 200), null},
515 {Instant.ofEpochSecond(10, 200), ChronoField.NANO_OF_SECOND, 100, Instant.ofEpochSecond(10, 100), null},
516 {Instant.ofEpochSecond(10, 200), ChronoField.NANO_OF_SECOND, 0, Instant.ofEpochSecond(10), null},
517 {Instant.ofEpochSecond(10, 200), ChronoField.MICRO_OF_SECOND, 100, Instant.ofEpochSecond(10, 100*1000), null},
518 {Instant.ofEpochSecond(10, 200), ChronoField.MICRO_OF_SECOND, 0, Instant.ofEpochSecond(10), null},
519 {Instant.ofEpochSecond(10, 200), ChronoField.MILLI_OF_SECOND, 100, Instant.ofEpochSecond(10, 100*1000*1000), null},
520 {Instant.ofEpochSecond(10, 200), ChronoField.MILLI_OF_SECOND, 0, Instant.ofEpochSecond(10), null},
521
522 {Instant.ofEpochSecond(10, 200), ChronoField.NANO_OF_SECOND, 1000000000L, null, DateTimeException.class},
523 {Instant.ofEpochSecond(10, 200), ChronoField.MICRO_OF_SECOND, 1000000, null, DateTimeException.class},
524 {Instant.ofEpochSecond(10, 200), ChronoField.MILLI_OF_SECOND, 1000, null, DateTimeException.class},
525
526 {Instant.ofEpochSecond(10, 200), ChronoField.SECOND_OF_MINUTE, 1, null, DateTimeException.class},
527 {Instant.ofEpochSecond(10, 200), ChronoField.SECOND_OF_DAY, 1, null, DateTimeException.class},
528 {Instant.ofEpochSecond(10, 200), ChronoField.OFFSET_SECONDS, 1, null, DateTimeException.class},
529 {Instant.ofEpochSecond(10, 200), ChronoField.NANO_OF_DAY, 1, null, DateTimeException.class},
530 {Instant.ofEpochSecond(10, 200), ChronoField.MINUTE_OF_HOUR, 1, null, DateTimeException.class},
531 {Instant.ofEpochSecond(10, 200), ChronoField.MINUTE_OF_DAY, 1, null, DateTimeException.class},
532 {Instant.ofEpochSecond(10, 200), ChronoField.MILLI_OF_DAY, 1, null, DateTimeException.class},
533 {Instant.ofEpochSecond(10, 200), ChronoField.MICRO_OF_DAY, 1, null, DateTimeException.class},
534
535
536 };
537 }
538
539 @Test(dataProvider="with_longTemporalField")
540 public void test_with_longTemporalField(Instant test, TemporalField field, long value, Instant expected, Class<?> expectedEx) {
541 if (expectedEx == null) {
542 Instant result = test.with(field, value);
543 assertEquals(result, expected);
544 } else {
545 try {
546 Instant result = test.with(field, value);
547 fail();
548 } catch (Exception ex) {
549 assertTrue(expectedEx.isInstance(ex));
550 }
551 }
552 }
553
554 //-----------------------------------------------------------------------
555 // truncated(TemporalUnit)
556 //-----------------------------------------------------------------------
557 TemporalUnit NINETY_MINS = new TemporalUnit() {
558 @Override
559 public Duration getDuration() {
560 return Duration.ofMinutes(90);
561 }
562 @Override
563 public boolean isDurationEstimated() {
564 return false;
565 }
566 @Override
567 public boolean isDateBased() {
568 return false;
569 }
570 @Override
571 public boolean isTimeBased() {
572 return true;
573 }
574 @Override
575 public boolean isSupportedBy(Temporal temporal) {
576 return false;
577 }
578 @Override
579 public <R extends Temporal> R addTo(R temporal, long amount) {
580 throw new UnsupportedOperationException();
581 }
582 @Override
583 public long between(Temporal temporal1, Temporal temporal2) {
584 throw new UnsupportedOperationException();
585 }
586 @Override
587 public String toString() {
588 return "NinetyMins";
589 }
590 };
591
592 TemporalUnit NINETY_FIVE_MINS = new TemporalUnit() {
593 @Override
594 public Duration getDuration() {
595 return Duration.ofMinutes(95);
596 }
597 @Override
598 public boolean isDurationEstimated() {
599 return false;
600 }
601 @Override
602 public boolean isDateBased() {
603 return false;
604 }
605 @Override
606 public boolean isTimeBased() {
607 return false;
608 }
609 @Override
610 public boolean isSupportedBy(Temporal temporal) {
611 return false;
612 }
613 @Override
614 public <R extends Temporal> R addTo(R temporal, long amount) {
615 throw new UnsupportedOperationException();
616 }
617 @Override
618 public long between(Temporal temporal1, Temporal temporal2) {
619 throw new UnsupportedOperationException();
620 }
621 @Override
622 public String toString() {
623 return "NinetyFiveMins";
624 }
625 };
626
627 @DataProvider(name="truncatedToValid")
628 Object[][] data_truncatedToValid() {
629 return new Object[][] {
630 {Instant.ofEpochSecond(86400 + 3600 + 60 + 1, 123_456_789), NANOS, Instant.ofEpochSecond(86400 + 3600 + 60 + 1, 123_456_789)},
631 {Instant.ofEpochSecond(86400 + 3600 + 60 + 1, 123_456_789), MICROS, Instant.ofEpochSecond(86400 + 3600 + 60 + 1, 123_456_000)},
632 {Instant.ofEpochSecond(86400 + 3600 + 60 + 1, 123_456_789), MILLIS, Instant.ofEpochSecond(86400 + 3600 + 60 + 1, 1230_00_000)},
633 {Instant.ofEpochSecond(86400 + 3600 + 60 + 1, 123_456_789), SECONDS, Instant.ofEpochSecond(86400 + 3600 + 60 + 1, 0)},
634 {Instant.ofEpochSecond(86400 + 3600 + 60 + 1, 123_456_789), MINUTES, Instant.ofEpochSecond(86400 + 3600 + 60, 0)},
635 {Instant.ofEpochSecond(86400 + 3600 + 60 + 1, 123_456_789), HOURS, Instant.ofEpochSecond(86400 + 3600, 0)},
636 {Instant.ofEpochSecond(86400 + 3600 + 60 + 1, 123_456_789), DAYS, Instant.ofEpochSecond(86400, 0)},
637
638 {Instant.ofEpochSecond(86400 + 3600 + 60 + 1, 123_456_789), NINETY_MINS, Instant.ofEpochSecond(86400 + 0, 0)},
639 {Instant.ofEpochSecond(86400 + 7200 + 60 + 1, 123_456_789), NINETY_MINS, Instant.ofEpochSecond(86400 + 5400, 0)},
640 {Instant.ofEpochSecond(86400 + 10800 + 60 + 1, 123_456_789), NINETY_MINS, Instant.ofEpochSecond(86400 + 10800, 0)},
641 };
642 }
643 @Test(dataProvider="truncatedToValid")
644 public void test_truncatedTo_valid(Instant input, TemporalUnit unit, Instant expected) {
645 assertEquals(input.truncatedTo(unit), expected);
646 }
647
648 @DataProvider(name="truncatedToInvalid")
649 Object[][] data_truncatedToInvalid() {
650 return new Object[][] {
651 {Instant.ofEpochSecond(1, 123_456_789), NINETY_FIVE_MINS},
652 {Instant.ofEpochSecond(1, 123_456_789), WEEKS},
653 {Instant.ofEpochSecond(1, 123_456_789), MONTHS},
654 {Instant.ofEpochSecond(1, 123_456_789), YEARS},
655 };
656 }
657
658 @Test(dataProvider="truncatedToInvalid", expectedExceptions=DateTimeException.class)
659 public void test_truncatedTo_invalid(Instant input, TemporalUnit unit) {
660 input.truncatedTo(unit);
661 }
662
663 @Test(expectedExceptions=NullPointerException.class)
664 public void test_truncatedTo_null() {
665 TEST_12345_123456789.truncatedTo(null);
666 }
667
668 //-----------------------------------------------------------------------
669 // plus(TemporalAmount)
670 //-----------------------------------------------------------------------
671 @DataProvider(name="plusTemporalAmount")
672 Object[][] data_plusTemporalAmount() {
673 return new Object[][] {
674 {DAYS, MockSimplePeriod.of(1, DAYS), 86401, 0},
675 {HOURS, MockSimplePeriod.of(2, HOURS), 7201, 0},
676 {MINUTES, MockSimplePeriod.of(4, MINUTES), 241, 0},
677 {SECONDS, MockSimplePeriod.of(5, SECONDS), 6, 0},
678 {NANOS, MockSimplePeriod.of(6, NANOS), 1, 6},
679 {DAYS, MockSimplePeriod.of(10, DAYS), 864001, 0},
680 {HOURS, MockSimplePeriod.of(11, HOURS), 39601, 0},
681 {MINUTES, MockSimplePeriod.of(12, MINUTES), 721, 0},
682 {SECONDS, MockSimplePeriod.of(13, SECONDS), 14, 0},
683 {NANOS, MockSimplePeriod.of(14, NANOS), 1, 14},
684 {SECONDS, Duration.ofSeconds(20, 40), 21, 40},
685 {NANOS, Duration.ofSeconds(30, 300), 31, 300},
686 };
687 }
688
689 @Test(dataProvider="plusTemporalAmount")
690 public void test_plusTemporalAmount(TemporalUnit unit, TemporalAmount amount, int seconds, int nanos) {
691 Instant inst = Instant.ofEpochMilli(1000);
692 Instant actual = inst.plus(amount);
693 Instant expected = Instant.ofEpochSecond(seconds, nanos);
694 assertEquals(actual, expected, "plus(TemporalAmount) failed");
695 }
696
697 @DataProvider(name="badTemporalAmount")
698 Object[][] data_badPlusTemporalAmount() {
699 return new Object[][] {
700 {MockSimplePeriod.of(2, YEARS)},
701 {MockSimplePeriod.of(2, MONTHS)},
702 };
703 }
704
705 @Test(dataProvider="badTemporalAmount",expectedExceptions=DateTimeException.class)
706 public void test_badPlusTemporalAmount(TemporalAmount amount) {
707 Instant inst = Instant.ofEpochMilli(1000);
708 inst.plus(amount);
709 }
710
711 //-----------------------------------------------------------------------
712 @DataProvider(name="Plus")
713 Object[][] provider_plus() {
714 return new Object[][] {
715 {MIN_SECOND, 0, -MIN_SECOND, 0, 0, 0},
716
717 {MIN_SECOND, 0, 1, 0, MIN_SECOND + 1, 0},
718 {MIN_SECOND, 0, 0, 500, MIN_SECOND, 500},
719 {MIN_SECOND, 0, 0, 1000000000, MIN_SECOND + 1, 0},
720
721 {MIN_SECOND + 1, 0, -1, 0, MIN_SECOND, 0},
722 {MIN_SECOND + 1, 0, 0, -500, MIN_SECOND, 999999500},
723 {MIN_SECOND + 1, 0, 0, -1000000000, MIN_SECOND, 0},
724
725 {-4, 666666667, -4, 666666667, -7, 333333334},
726 {-4, 666666667, -3, 0, -7, 666666667},
727 {-4, 666666667, -2, 0, -6, 666666667},
728 {-4, 666666667, -1, 0, -5, 666666667},
729 {-4, 666666667, -1, 333333334, -4, 1},
730 {-4, 666666667, -1, 666666667, -4, 333333334},
731 {-4, 666666667, -1, 999999999, -4, 666666666},
732 {-4, 666666667, 0, 0, -4, 666666667},
733 {-4, 666666667, 0, 1, -4, 666666668},
734 {-4, 666666667, 0, 333333333, -3, 0},
735 {-4, 666666667, 0, 666666666, -3, 333333333},
736 {-4, 666666667, 1, 0, -3, 666666667},
737 {-4, 666666667, 2, 0, -2, 666666667},
738 {-4, 666666667, 3, 0, -1, 666666667},
739 {-4, 666666667, 3, 333333333, 0, 0},
740
741 {-3, 0, -4, 666666667, -7, 666666667},
742 {-3, 0, -3, 0, -6, 0},
743 {-3, 0, -2, 0, -5, 0},
744 {-3, 0, -1, 0, -4, 0},
745 {-3, 0, -1, 333333334, -4, 333333334},
746 {-3, 0, -1, 666666667, -4, 666666667},
747 {-3, 0, -1, 999999999, -4, 999999999},
748 {-3, 0, 0, 0, -3, 0},
749 {-3, 0, 0, 1, -3, 1},
750 {-3, 0, 0, 333333333, -3, 333333333},
751 {-3, 0, 0, 666666666, -3, 666666666},
752 {-3, 0, 1, 0, -2, 0},
753 {-3, 0, 2, 0, -1, 0},
754 {-3, 0, 3, 0, 0, 0},
755 {-3, 0, 3, 333333333, 0, 333333333},
756
757 {-2, 0, -4, 666666667, -6, 666666667},
758 {-2, 0, -3, 0, -5, 0},
759 {-2, 0, -2, 0, -4, 0},
760 {-2, 0, -1, 0, -3, 0},
761 {-2, 0, -1, 333333334, -3, 333333334},
762 {-2, 0, -1, 666666667, -3, 666666667},
763 {-2, 0, -1, 999999999, -3, 999999999},
764 {-2, 0, 0, 0, -2, 0},
765 {-2, 0, 0, 1, -2, 1},
766 {-2, 0, 0, 333333333, -2, 333333333},
767 {-2, 0, 0, 666666666, -2, 666666666},
768 {-2, 0, 1, 0, -1, 0},
769 {-2, 0, 2, 0, 0, 0},
770 {-2, 0, 3, 0, 1, 0},
771 {-2, 0, 3, 333333333, 1, 333333333},
772
773 {-1, 0, -4, 666666667, -5, 666666667},
774 {-1, 0, -3, 0, -4, 0},
775 {-1, 0, -2, 0, -3, 0},
776 {-1, 0, -1, 0, -2, 0},
777 {-1, 0, -1, 333333334, -2, 333333334},
778 {-1, 0, -1, 666666667, -2, 666666667},
779 {-1, 0, -1, 999999999, -2, 999999999},
780 {-1, 0, 0, 0, -1, 0},
781 {-1, 0, 0, 1, -1, 1},
782 {-1, 0, 0, 333333333, -1, 333333333},
783 {-1, 0, 0, 666666666, -1, 666666666},
784 {-1, 0, 1, 0, 0, 0},
785 {-1, 0, 2, 0, 1, 0},
786 {-1, 0, 3, 0, 2, 0},
787 {-1, 0, 3, 333333333, 2, 333333333},
788
789 {-1, 666666667, -4, 666666667, -4, 333333334},
790 {-1, 666666667, -3, 0, -4, 666666667},
791 {-1, 666666667, -2, 0, -3, 666666667},
792 {-1, 666666667, -1, 0, -2, 666666667},
793 {-1, 666666667, -1, 333333334, -1, 1},
794 {-1, 666666667, -1, 666666667, -1, 333333334},
795 {-1, 666666667, -1, 999999999, -1, 666666666},
796 {-1, 666666667, 0, 0, -1, 666666667},
797 {-1, 666666667, 0, 1, -1, 666666668},
798 {-1, 666666667, 0, 333333333, 0, 0},
799 {-1, 666666667, 0, 666666666, 0, 333333333},
800 {-1, 666666667, 1, 0, 0, 666666667},
801 {-1, 666666667, 2, 0, 1, 666666667},
802 {-1, 666666667, 3, 0, 2, 666666667},
803 {-1, 666666667, 3, 333333333, 3, 0},
804
805 {0, 0, -4, 666666667, -4, 666666667},
806 {0, 0, -3, 0, -3, 0},
807 {0, 0, -2, 0, -2, 0},
808 {0, 0, -1, 0, -1, 0},
809 {0, 0, -1, 333333334, -1, 333333334},
810 {0, 0, -1, 666666667, -1, 666666667},
811 {0, 0, -1, 999999999, -1, 999999999},
812 {0, 0, 0, 0, 0, 0},
813 {0, 0, 0, 1, 0, 1},
814 {0, 0, 0, 333333333, 0, 333333333},
815 {0, 0, 0, 666666666, 0, 666666666},
816 {0, 0, 1, 0, 1, 0},
817 {0, 0, 2, 0, 2, 0},
818 {0, 0, 3, 0, 3, 0},
819 {0, 0, 3, 333333333, 3, 333333333},
820
821 {0, 333333333, -4, 666666667, -3, 0},
822 {0, 333333333, -3, 0, -3, 333333333},
823 {0, 333333333, -2, 0, -2, 333333333},
824 {0, 333333333, -1, 0, -1, 333333333},
825 {0, 333333333, -1, 333333334, -1, 666666667},
826 {0, 333333333, -1, 666666667, 0, 0},
827 {0, 333333333, -1, 999999999, 0, 333333332},
828 {0, 333333333, 0, 0, 0, 333333333},
829 {0, 333333333, 0, 1, 0, 333333334},
830 {0, 333333333, 0, 333333333, 0, 666666666},
831 {0, 333333333, 0, 666666666, 0, 999999999},
832 {0, 333333333, 1, 0, 1, 333333333},
833 {0, 333333333, 2, 0, 2, 333333333},
834 {0, 333333333, 3, 0, 3, 333333333},
835 {0, 333333333, 3, 333333333, 3, 666666666},
836
837 {1, 0, -4, 666666667, -3, 666666667},
838 {1, 0, -3, 0, -2, 0},
839 {1, 0, -2, 0, -1, 0},
840 {1, 0, -1, 0, 0, 0},
841 {1, 0, -1, 333333334, 0, 333333334},
842 {1, 0, -1, 666666667, 0, 666666667},
843 {1, 0, -1, 999999999, 0, 999999999},
844 {1, 0, 0, 0, 1, 0},
845 {1, 0, 0, 1, 1, 1},
846 {1, 0, 0, 333333333, 1, 333333333},
847 {1, 0, 0, 666666666, 1, 666666666},
848 {1, 0, 1, 0, 2, 0},
849 {1, 0, 2, 0, 3, 0},
850 {1, 0, 3, 0, 4, 0},
851 {1, 0, 3, 333333333, 4, 333333333},
852
853 {2, 0, -4, 666666667, -2, 666666667},
854 {2, 0, -3, 0, -1, 0},
855 {2, 0, -2, 0, 0, 0},
856 {2, 0, -1, 0, 1, 0},
857 {2, 0, -1, 333333334, 1, 333333334},
858 {2, 0, -1, 666666667, 1, 666666667},
859 {2, 0, -1, 999999999, 1, 999999999},
860 {2, 0, 0, 0, 2, 0},
861 {2, 0, 0, 1, 2, 1},
862 {2, 0, 0, 333333333, 2, 333333333},
863 {2, 0, 0, 666666666, 2, 666666666},
864 {2, 0, 1, 0, 3, 0},
865 {2, 0, 2, 0, 4, 0},
866 {2, 0, 3, 0, 5, 0},
867 {2, 0, 3, 333333333, 5, 333333333},
868
869 {3, 0, -4, 666666667, -1, 666666667},
870 {3, 0, -3, 0, 0, 0},
871 {3, 0, -2, 0, 1, 0},
872 {3, 0, -1, 0, 2, 0},
873 {3, 0, -1, 333333334, 2, 333333334},
874 {3, 0, -1, 666666667, 2, 666666667},
875 {3, 0, -1, 999999999, 2, 999999999},
876 {3, 0, 0, 0, 3, 0},
877 {3, 0, 0, 1, 3, 1},
878 {3, 0, 0, 333333333, 3, 333333333},
879 {3, 0, 0, 666666666, 3, 666666666},
880 {3, 0, 1, 0, 4, 0},
881 {3, 0, 2, 0, 5, 0},
882 {3, 0, 3, 0, 6, 0},
883 {3, 0, 3, 333333333, 6, 333333333},
884
885 {3, 333333333, -4, 666666667, 0, 0},
886 {3, 333333333, -3, 0, 0, 333333333},
887 {3, 333333333, -2, 0, 1, 333333333},
888 {3, 333333333, -1, 0, 2, 333333333},
889 {3, 333333333, -1, 333333334, 2, 666666667},
890 {3, 333333333, -1, 666666667, 3, 0},
891 {3, 333333333, -1, 999999999, 3, 333333332},
892 {3, 333333333, 0, 0, 3, 333333333},
893 {3, 333333333, 0, 1, 3, 333333334},
894 {3, 333333333, 0, 333333333, 3, 666666666},
895 {3, 333333333, 0, 666666666, 3, 999999999},
896 {3, 333333333, 1, 0, 4, 333333333},
897 {3, 333333333, 2, 0, 5, 333333333},
898 {3, 333333333, 3, 0, 6, 333333333},
899 {3, 333333333, 3, 333333333, 6, 666666666},
900
901 {MAX_SECOND - 1, 0, 1, 0, MAX_SECOND, 0},
902 {MAX_SECOND - 1, 0, 0, 500, MAX_SECOND - 1, 500},
903 {MAX_SECOND - 1, 0, 0, 1000000000, MAX_SECOND, 0},
904
905 {MAX_SECOND, 0, -1, 0, MAX_SECOND - 1, 0},
906 {MAX_SECOND, 0, 0, -500, MAX_SECOND - 1, 999999500},
907 {MAX_SECOND, 0, 0, -1000000000, MAX_SECOND - 1, 0},
908
909 {MAX_SECOND, 0, -MAX_SECOND, 0, 0, 0},
910 };
911 }
912
913 @Test(dataProvider="Plus")
914 public void plus_Duration(long seconds, int nanos, long otherSeconds, int otherNanos, long expectedSeconds, int expectedNanoOfSecond) {
915 Instant i = Instant.ofEpochSecond(seconds, nanos).plus(Duration.ofSeconds(otherSeconds, otherNanos));
916 assertEquals(i.getEpochSecond(), expectedSeconds);
917 assertEquals(i.getNano(), expectedNanoOfSecond);
918 }
919
920 @Test(expectedExceptions=DateTimeException.class)
921 public void plus_Duration_overflowTooBig() {
922 Instant i = Instant.ofEpochSecond(MAX_SECOND, 999999999);
923 i.plus(Duration.ofSeconds(0, 1));
924 }
925
926 @Test(expectedExceptions=DateTimeException.class)
927 public void plus_Duration_overflowTooSmall() {
928 Instant i = Instant.ofEpochSecond(MIN_SECOND);
929 i.plus(Duration.ofSeconds(-1, 999999999));
930 }
931
932 //-----------------------------------------------------------------------a
933 @Test(dataProvider="Plus")
934 public void plus_longTemporalUnit(long seconds, int nanos, long otherSeconds, int otherNanos, long expectedSeconds, int expectedNanoOfSecond) {
935 Instant i = Instant.ofEpochSecond(seconds, nanos).plus(otherSeconds, SECONDS).plus(otherNanos, NANOS);
936 assertEquals(i.getEpochSecond(), expectedSeconds);
937 assertEquals(i.getNano(), expectedNanoOfSecond);
938 }
939
940 @Test(expectedExceptions=DateTimeException.class)
941 public void plus_longTemporalUnit_overflowTooBig() {
942 Instant i = Instant.ofEpochSecond(MAX_SECOND, 999999999);
943 i.plus(1, NANOS);
944 }
945
946 @Test(expectedExceptions=DateTimeException.class)
947 public void plus_longTemporalUnit_overflowTooSmall() {
948 Instant i = Instant.ofEpochSecond(MIN_SECOND);
949 i.plus(999999999, NANOS);
950 i.plus(-1, SECONDS);
951 }
952
953 //-----------------------------------------------------------------------
954 @DataProvider(name="PlusSeconds")
955 Object[][] provider_plusSeconds_long() {
956 return new Object[][] {
957 {0, 0, 0, 0, 0},
958 {0, 0, 1, 1, 0},
959 {0, 0, -1, -1, 0},
960 {0, 0, MAX_SECOND, MAX_SECOND, 0},
961 {0, 0, MIN_SECOND, MIN_SECOND, 0},
962 {1, 0, 0, 1, 0},
963 {1, 0, 1, 2, 0},
964 {1, 0, -1, 0, 0},
965 {1, 0, MAX_SECOND - 1, MAX_SECOND, 0},
966 {1, 0, MIN_SECOND, MIN_SECOND + 1, 0},
967 {1, 1, 0, 1, 1},
968 {1, 1, 1, 2, 1},
969 {1, 1, -1, 0, 1},
970 {1, 1, MAX_SECOND - 1, MAX_SECOND, 1},
971 {1, 1, MIN_SECOND, MIN_SECOND + 1, 1},
972 {-1, 1, 0, -1, 1},
973 {-1, 1, 1, 0, 1},
974 {-1, 1, -1, -2, 1},
975 {-1, 1, MAX_SECOND, MAX_SECOND - 1, 1},
976 {-1, 1, MIN_SECOND + 1, MIN_SECOND, 1},
977
978 {MAX_SECOND, 2, -MAX_SECOND, 0, 2},
979 {MIN_SECOND, 2, -MIN_SECOND, 0, 2},
980 };
981 }
982
983 @Test(dataProvider="PlusSeconds")
984 public void plusSeconds_long(long seconds, int nanos, long amount, long expectedSeconds, int expectedNanoOfSecond) {
985 Instant t = Instant.ofEpochSecond(seconds, nanos);
986 t = t.plusSeconds(amount);
987 assertEquals(t.getEpochSecond(), expectedSeconds);
988 assertEquals(t.getNano(), expectedNanoOfSecond);
989 }
990
991 @Test(expectedExceptions=ArithmeticException.class)
992 public void plusSeconds_long_overflowTooBig() {
993 Instant t = Instant.ofEpochSecond(1, 0);
994 t.plusSeconds(Long.MAX_VALUE);
995 }
996
997 @Test(expectedExceptions=ArithmeticException.class)
998 public void plusSeconds_long_overflowTooSmall() {
999 Instant t = Instant.ofEpochSecond(-1, 0);
1000 t.plusSeconds(Long.MIN_VALUE);
1001 }
1002
1003 //-----------------------------------------------------------------------
1004 @DataProvider(name="PlusMillis")
1005 Object[][] provider_plusMillis_long() {
1006 return new Object[][] {
1007 {0, 0, 0, 0, 0},
1008 {0, 0, 1, 0, 1000000},
1009 {0, 0, 999, 0, 999000000},
1010 {0, 0, 1000, 1, 0},
1011 {0, 0, 1001, 1, 1000000},
1012 {0, 0, 1999, 1, 999000000},
1013 {0, 0, 2000, 2, 0},
1014 {0, 0, -1, -1, 999000000},
1015 {0, 0, -999, -1, 1000000},
1016 {0, 0, -1000, -1, 0},
1017 {0, 0, -1001, -2, 999000000},
1018 {0, 0, -1999, -2, 1000000},
1019
1020 {0, 1, 0, 0, 1},
1021 {0, 1, 1, 0, 1000001},
1022 {0, 1, 998, 0, 998000001},
1023 {0, 1, 999, 0, 999000001},
1024 {0, 1, 1000, 1, 1},
1025 {0, 1, 1998, 1, 998000001},
1026 {0, 1, 1999, 1, 999000001},
1027 {0, 1, 2000, 2, 1},
1028 {0, 1, -1, -1, 999000001},
1029 {0, 1, -2, -1, 998000001},
1030 {0, 1, -1000, -1, 1},
1031 {0, 1, -1001, -2, 999000001},
1032
1033 {0, 1000000, 0, 0, 1000000},
1034 {0, 1000000, 1, 0, 2000000},
1035 {0, 1000000, 998, 0, 999000000},
1036 {0, 1000000, 999, 1, 0},
1037 {0, 1000000, 1000, 1, 1000000},
1038 {0, 1000000, 1998, 1, 999000000},
1039 {0, 1000000, 1999, 2, 0},
1040 {0, 1000000, 2000, 2, 1000000},
1041 {0, 1000000, -1, 0, 0},
1042 {0, 1000000, -2, -1, 999000000},
1043 {0, 1000000, -999, -1, 2000000},
1044 {0, 1000000, -1000, -1, 1000000},
1045 {0, 1000000, -1001, -1, 0},
1046 {0, 1000000, -1002, -2, 999000000},
1047
1048 {0, 999999999, 0, 0, 999999999},
1049 {0, 999999999, 1, 1, 999999},
1050 {0, 999999999, 999, 1, 998999999},
1051 {0, 999999999, 1000, 1, 999999999},
1052 {0, 999999999, 1001, 2, 999999},
1053 {0, 999999999, -1, 0, 998999999},
1054 {0, 999999999, -1000, -1, 999999999},
1055 {0, 999999999, -1001, -1, 998999999},
1056
1057 {0, 0, Long.MAX_VALUE, Long.MAX_VALUE / 1000, (int) (Long.MAX_VALUE % 1000) * 1000000},
1058 {0, 0, Long.MIN_VALUE, Long.MIN_VALUE / 1000 - 1, (int) (Long.MIN_VALUE % 1000) * 1000000 + 1000000000},
1059 };
1060 }
1061
1062 @Test(dataProvider="PlusMillis")
1063 public void plusMillis_long(long seconds, int nanos, long amount, long expectedSeconds, int expectedNanoOfSecond) {
1064 Instant t = Instant.ofEpochSecond(seconds, nanos);
1065 t = t.plusMillis(amount);
1066 assertEquals(t.getEpochSecond(), expectedSeconds);
1067 assertEquals(t.getNano(), expectedNanoOfSecond);
1068 }
1069 @Test(dataProvider="PlusMillis")
1070 public void plusMillis_long_oneMore(long seconds, int nanos, long amount, long expectedSeconds, int expectedNanoOfSecond) {
1071 Instant t = Instant.ofEpochSecond(seconds + 1, nanos);
1072 t = t.plusMillis(amount);
1073 assertEquals(t.getEpochSecond(), expectedSeconds + 1);
1074 assertEquals(t.getNano(), expectedNanoOfSecond);
1075 }
1076 @Test(dataProvider="PlusMillis")
1077 public void plusMillis_long_minusOneLess(long seconds, int nanos, long amount, long expectedSeconds, int expectedNanoOfSecond) {
1078 Instant t = Instant.ofEpochSecond(seconds - 1, nanos);
1079 t = t.plusMillis(amount);
1080 assertEquals(t.getEpochSecond(), expectedSeconds - 1);
1081 assertEquals(t.getNano(), expectedNanoOfSecond);
1082 }
1083
1084 @Test
1085 public void plusMillis_long_max() {
1086 Instant t = Instant.ofEpochSecond(MAX_SECOND, 998999999);
1087 t = t.plusMillis(1);
1088 assertEquals(t.getEpochSecond(), MAX_SECOND);
1089 assertEquals(t.getNano(), 999999999);
1090 }
1091
1092 @Test(expectedExceptions=DateTimeException.class)
1093 public void plusMillis_long_overflowTooBig() {
1094 Instant t = Instant.ofEpochSecond(MAX_SECOND, 999000000);
1095 t.plusMillis(1);
1096 }
1097
1098 @Test
1099 public void plusMillis_long_min() {
1100 Instant t = Instant.ofEpochSecond(MIN_SECOND, 1000000);
1101 t = t.plusMillis(-1);
1102 assertEquals(t.getEpochSecond(), MIN_SECOND);
1103 assertEquals(t.getNano(), 0);
1104 }
1105
1106 @Test(expectedExceptions=DateTimeException.class)
1107 public void plusMillis_long_overflowTooSmall() {
1108 Instant t = Instant.ofEpochSecond(MIN_SECOND, 0);
1109 t.plusMillis(-1);
1110 }
1111
1112 //-----------------------------------------------------------------------
1113 @DataProvider(name="PlusNanos")
1114 Object[][] provider_plusNanos_long() {
1115 return new Object[][] {
1116 {0, 0, 0, 0, 0},
1117 {0, 0, 1, 0, 1},
1118 {0, 0, 999999999, 0, 999999999},
1119 {0, 0, 1000000000, 1, 0},
1120 {0, 0, 1000000001, 1, 1},
1121 {0, 0, 1999999999, 1, 999999999},
1122 {0, 0, 2000000000, 2, 0},
1123 {0, 0, -1, -1, 999999999},
1124 {0, 0, -999999999, -1, 1},
1125 {0, 0, -1000000000, -1, 0},
1126 {0, 0, -1000000001, -2, 999999999},
1127 {0, 0, -1999999999, -2, 1},
1128
1129 {1, 0, 0, 1, 0},
1130 {1, 0, 1, 1, 1},
1131 {1, 0, 999999999, 1, 999999999},
1132 {1, 0, 1000000000, 2, 0},
1133 {1, 0, 1000000001, 2, 1},
1134 {1, 0, 1999999999, 2, 999999999},
1135 {1, 0, 2000000000, 3, 0},
1136 {1, 0, -1, 0, 999999999},
1137 {1, 0, -999999999, 0, 1},
1138 {1, 0, -1000000000, 0, 0},
1139 {1, 0, -1000000001, -1, 999999999},
1140 {1, 0, -1999999999, -1, 1},
1141
1142 {-1, 0, 0, -1, 0},
1143 {-1, 0, 1, -1, 1},
1144 {-1, 0, 999999999, -1, 999999999},
1145 {-1, 0, 1000000000, 0, 0},
1146 {-1, 0, 1000000001, 0, 1},
1147 {-1, 0, 1999999999, 0, 999999999},
1148 {-1, 0, 2000000000, 1, 0},
1149 {-1, 0, -1, -2, 999999999},
1150 {-1, 0, -999999999, -2, 1},
1151 {-1, 0, -1000000000, -2, 0},
1152 {-1, 0, -1000000001, -3, 999999999},
1153 {-1, 0, -1999999999, -3, 1},
1154
1155 {1, 1, 0, 1, 1},
1156 {1, 1, 1, 1, 2},
1157 {1, 1, 999999998, 1, 999999999},
1158 {1, 1, 999999999, 2, 0},
1159 {1, 1, 1000000000, 2, 1},
1160 {1, 1, 1999999998, 2, 999999999},
1161 {1, 1, 1999999999, 3, 0},
1162 {1, 1, 2000000000, 3, 1},
1163 {1, 1, -1, 1, 0},
1164 {1, 1, -2, 0, 999999999},
1165 {1, 1, -1000000000, 0, 1},
1166 {1, 1, -1000000001, 0, 0},
1167 {1, 1, -1000000002, -1, 999999999},
1168 {1, 1, -2000000000, -1, 1},
1169
1170 {1, 999999999, 0, 1, 999999999},
1171 {1, 999999999, 1, 2, 0},
1172 {1, 999999999, 999999999, 2, 999999998},
1173 {1, 999999999, 1000000000, 2, 999999999},
1174 {1, 999999999, 1000000001, 3, 0},
1175 {1, 999999999, -1, 1, 999999998},
1176 {1, 999999999, -1000000000, 0, 999999999},
1177 {1, 999999999, -1000000001, 0, 999999998},
1178 {1, 999999999, -1999999999, 0, 0},
1179 {1, 999999999, -2000000000, -1, 999999999},
1180
1181 {MAX_SECOND, 0, 999999999, MAX_SECOND, 999999999},
1182 {MAX_SECOND - 1, 0, 1999999999, MAX_SECOND, 999999999},
1183 {MIN_SECOND, 1, -1, MIN_SECOND, 0},
1184 {MIN_SECOND + 1, 1, -1000000001, MIN_SECOND, 0},
1185
1186 {0, 0, MAX_SECOND, MAX_SECOND / 1000000000, (int) (MAX_SECOND % 1000000000)},
1187 {0, 0, MIN_SECOND, MIN_SECOND / 1000000000 - 1, (int) (MIN_SECOND % 1000000000) + 1000000000},
1188 };
1189 }
1190
1191 @Test(dataProvider="PlusNanos")
1192 public void plusNanos_long(long seconds, int nanos, long amount, long expectedSeconds, int expectedNanoOfSecond) {
1193 Instant t = Instant.ofEpochSecond(seconds, nanos);
1194 t = t.plusNanos(amount);
1195 assertEquals(t.getEpochSecond(), expectedSeconds);
1196 assertEquals(t.getNano(), expectedNanoOfSecond);
1197 }
1198
1199 @Test(expectedExceptions=DateTimeException.class)
1200 public void plusNanos_long_overflowTooBig() {
1201 Instant t = Instant.ofEpochSecond(MAX_SECOND, 999999999);
1202 t.plusNanos(1);
1203 }
1204
1205 @Test(expectedExceptions=DateTimeException.class)
1206 public void plusNanos_long_overflowTooSmall() {
1207 Instant t = Instant.ofEpochSecond(MIN_SECOND, 0);
1208 t.plusNanos(-1);
1209 }
1210
1211 //-----------------------------------------------------------------------
1212 @DataProvider(name="Minus")
1213 Object[][] provider_minus() {
1214 return new Object[][] {
1215 {MIN_SECOND, 0, MIN_SECOND, 0, 0, 0},
1216
1217 {MIN_SECOND, 0, -1, 0, MIN_SECOND + 1, 0},
1218 {MIN_SECOND, 0, 0, -500, MIN_SECOND, 500},
1219 {MIN_SECOND, 0, 0, -1000000000, MIN_SECOND + 1, 0},
1220
1221 {MIN_SECOND + 1, 0, 1, 0, MIN_SECOND, 0},
1222 {MIN_SECOND + 1, 0, 0, 500, MIN_SECOND, 999999500},
1223 {MIN_SECOND + 1, 0, 0, 1000000000, MIN_SECOND, 0},
1224
1225 {-4, 666666667, -4, 666666667, 0, 0},
1226 {-4, 666666667, -3, 0, -1, 666666667},
1227 {-4, 666666667, -2, 0, -2, 666666667},
1228 {-4, 666666667, -1, 0, -3, 666666667},
1229 {-4, 666666667, -1, 333333334, -3, 333333333},
1230 {-4, 666666667, -1, 666666667, -3, 0},
1231 {-4, 666666667, -1, 999999999, -4, 666666668},
1232 {-4, 666666667, 0, 0, -4, 666666667},
1233 {-4, 666666667, 0, 1, -4, 666666666},
1234 {-4, 666666667, 0, 333333333, -4, 333333334},
1235 {-4, 666666667, 0, 666666666, -4, 1},
1236 {-4, 666666667, 1, 0, -5, 666666667},
1237 {-4, 666666667, 2, 0, -6, 666666667},
1238 {-4, 666666667, 3, 0, -7, 666666667},
1239 {-4, 666666667, 3, 333333333, -7, 333333334},
1240
1241 {-3, 0, -4, 666666667, 0, 333333333},
1242 {-3, 0, -3, 0, 0, 0},
1243 {-3, 0, -2, 0, -1, 0},
1244 {-3, 0, -1, 0, -2, 0},
1245 {-3, 0, -1, 333333334, -3, 666666666},
1246 {-3, 0, -1, 666666667, -3, 333333333},
1247 {-3, 0, -1, 999999999, -3, 1},
1248 {-3, 0, 0, 0, -3, 0},
1249 {-3, 0, 0, 1, -4, 999999999},
1250 {-3, 0, 0, 333333333, -4, 666666667},
1251 {-3, 0, 0, 666666666, -4, 333333334},
1252 {-3, 0, 1, 0, -4, 0},
1253 {-3, 0, 2, 0, -5, 0},
1254 {-3, 0, 3, 0, -6, 0},
1255 {-3, 0, 3, 333333333, -7, 666666667},
1256
1257 {-2, 0, -4, 666666667, 1, 333333333},
1258 {-2, 0, -3, 0, 1, 0},
1259 {-2, 0, -2, 0, 0, 0},
1260 {-2, 0, -1, 0, -1, 0},
1261 {-2, 0, -1, 333333334, -2, 666666666},
1262 {-2, 0, -1, 666666667, -2, 333333333},
1263 {-2, 0, -1, 999999999, -2, 1},
1264 {-2, 0, 0, 0, -2, 0},
1265 {-2, 0, 0, 1, -3, 999999999},
1266 {-2, 0, 0, 333333333, -3, 666666667},
1267 {-2, 0, 0, 666666666, -3, 333333334},
1268 {-2, 0, 1, 0, -3, 0},
1269 {-2, 0, 2, 0, -4, 0},
1270 {-2, 0, 3, 0, -5, 0},
1271 {-2, 0, 3, 333333333, -6, 666666667},
1272
1273 {-1, 0, -4, 666666667, 2, 333333333},
1274 {-1, 0, -3, 0, 2, 0},
1275 {-1, 0, -2, 0, 1, 0},
1276 {-1, 0, -1, 0, 0, 0},
1277 {-1, 0, -1, 333333334, -1, 666666666},
1278 {-1, 0, -1, 666666667, -1, 333333333},
1279 {-1, 0, -1, 999999999, -1, 1},
1280 {-1, 0, 0, 0, -1, 0},
1281 {-1, 0, 0, 1, -2, 999999999},
1282 {-1, 0, 0, 333333333, -2, 666666667},
1283 {-1, 0, 0, 666666666, -2, 333333334},
1284 {-1, 0, 1, 0, -2, 0},
1285 {-1, 0, 2, 0, -3, 0},
1286 {-1, 0, 3, 0, -4, 0},
1287 {-1, 0, 3, 333333333, -5, 666666667},
1288
1289 {-1, 666666667, -4, 666666667, 3, 0},
1290 {-1, 666666667, -3, 0, 2, 666666667},
1291 {-1, 666666667, -2, 0, 1, 666666667},
1292 {-1, 666666667, -1, 0, 0, 666666667},
1293 {-1, 666666667, -1, 333333334, 0, 333333333},
1294 {-1, 666666667, -1, 666666667, 0, 0},
1295 {-1, 666666667, -1, 999999999, -1, 666666668},
1296 {-1, 666666667, 0, 0, -1, 666666667},
1297 {-1, 666666667, 0, 1, -1, 666666666},
1298 {-1, 666666667, 0, 333333333, -1, 333333334},
1299 {-1, 666666667, 0, 666666666, -1, 1},
1300 {-1, 666666667, 1, 0, -2, 666666667},
1301 {-1, 666666667, 2, 0, -3, 666666667},
1302 {-1, 666666667, 3, 0, -4, 666666667},
1303 {-1, 666666667, 3, 333333333, -4, 333333334},
1304
1305 {0, 0, -4, 666666667, 3, 333333333},
1306 {0, 0, -3, 0, 3, 0},
1307 {0, 0, -2, 0, 2, 0},
1308 {0, 0, -1, 0, 1, 0},
1309 {0, 0, -1, 333333334, 0, 666666666},
1310 {0, 0, -1, 666666667, 0, 333333333},
1311 {0, 0, -1, 999999999, 0, 1},
1312 {0, 0, 0, 0, 0, 0},
1313 {0, 0, 0, 1, -1, 999999999},
1314 {0, 0, 0, 333333333, -1, 666666667},
1315 {0, 0, 0, 666666666, -1, 333333334},
1316 {0, 0, 1, 0, -1, 0},
1317 {0, 0, 2, 0, -2, 0},
1318 {0, 0, 3, 0, -3, 0},
1319 {0, 0, 3, 333333333, -4, 666666667},
1320
1321 {0, 333333333, -4, 666666667, 3, 666666666},
1322 {0, 333333333, -3, 0, 3, 333333333},
1323 {0, 333333333, -2, 0, 2, 333333333},
1324 {0, 333333333, -1, 0, 1, 333333333},
1325 {0, 333333333, -1, 333333334, 0, 999999999},
1326 {0, 333333333, -1, 666666667, 0, 666666666},
1327 {0, 333333333, -1, 999999999, 0, 333333334},
1328 {0, 333333333, 0, 0, 0, 333333333},
1329 {0, 333333333, 0, 1, 0, 333333332},
1330 {0, 333333333, 0, 333333333, 0, 0},
1331 {0, 333333333, 0, 666666666, -1, 666666667},
1332 {0, 333333333, 1, 0, -1, 333333333},
1333 {0, 333333333, 2, 0, -2, 333333333},
1334 {0, 333333333, 3, 0, -3, 333333333},
1335 {0, 333333333, 3, 333333333, -3, 0},
1336
1337 {1, 0, -4, 666666667, 4, 333333333},
1338 {1, 0, -3, 0, 4, 0},
1339 {1, 0, -2, 0, 3, 0},
1340 {1, 0, -1, 0, 2, 0},
1341 {1, 0, -1, 333333334, 1, 666666666},
1342 {1, 0, -1, 666666667, 1, 333333333},
1343 {1, 0, -1, 999999999, 1, 1},
1344 {1, 0, 0, 0, 1, 0},
1345 {1, 0, 0, 1, 0, 999999999},
1346 {1, 0, 0, 333333333, 0, 666666667},
1347 {1, 0, 0, 666666666, 0, 333333334},
1348 {1, 0, 1, 0, 0, 0},
1349 {1, 0, 2, 0, -1, 0},
1350 {1, 0, 3, 0, -2, 0},
1351 {1, 0, 3, 333333333, -3, 666666667},
1352
1353 {2, 0, -4, 666666667, 5, 333333333},
1354 {2, 0, -3, 0, 5, 0},
1355 {2, 0, -2, 0, 4, 0},
1356 {2, 0, -1, 0, 3, 0},
1357 {2, 0, -1, 333333334, 2, 666666666},
1358 {2, 0, -1, 666666667, 2, 333333333},
1359 {2, 0, -1, 999999999, 2, 1},
1360 {2, 0, 0, 0, 2, 0},
1361 {2, 0, 0, 1, 1, 999999999},
1362 {2, 0, 0, 333333333, 1, 666666667},
1363 {2, 0, 0, 666666666, 1, 333333334},
1364 {2, 0, 1, 0, 1, 0},
1365 {2, 0, 2, 0, 0, 0},
1366 {2, 0, 3, 0, -1, 0},
1367 {2, 0, 3, 333333333, -2, 666666667},
1368
1369 {3, 0, -4, 666666667, 6, 333333333},
1370 {3, 0, -3, 0, 6, 0},
1371 {3, 0, -2, 0, 5, 0},
1372 {3, 0, -1, 0, 4, 0},
1373 {3, 0, -1, 333333334, 3, 666666666},
1374 {3, 0, -1, 666666667, 3, 333333333},
1375 {3, 0, -1, 999999999, 3, 1},
1376 {3, 0, 0, 0, 3, 0},
1377 {3, 0, 0, 1, 2, 999999999},
1378 {3, 0, 0, 333333333, 2, 666666667},
1379 {3, 0, 0, 666666666, 2, 333333334},
1380 {3, 0, 1, 0, 2, 0},
1381 {3, 0, 2, 0, 1, 0},
1382 {3, 0, 3, 0, 0, 0},
1383 {3, 0, 3, 333333333, -1, 666666667},
1384
1385 {3, 333333333, -4, 666666667, 6, 666666666},
1386 {3, 333333333, -3, 0, 6, 333333333},
1387 {3, 333333333, -2, 0, 5, 333333333},
1388 {3, 333333333, -1, 0, 4, 333333333},
1389 {3, 333333333, -1, 333333334, 3, 999999999},
1390 {3, 333333333, -1, 666666667, 3, 666666666},
1391 {3, 333333333, -1, 999999999, 3, 333333334},
1392 {3, 333333333, 0, 0, 3, 333333333},
1393 {3, 333333333, 0, 1, 3, 333333332},
1394 {3, 333333333, 0, 333333333, 3, 0},
1395 {3, 333333333, 0, 666666666, 2, 666666667},
1396 {3, 333333333, 1, 0, 2, 333333333},
1397 {3, 333333333, 2, 0, 1, 333333333},
1398 {3, 333333333, 3, 0, 0, 333333333},
1399 {3, 333333333, 3, 333333333, 0, 0},
1400
1401 {MAX_SECOND - 1, 0, -1, 0, MAX_SECOND, 0},
1402 {MAX_SECOND - 1, 0, 0, -500, MAX_SECOND - 1, 500},
1403 {MAX_SECOND - 1, 0, 0, -1000000000, MAX_SECOND, 0},
1404
1405 {MAX_SECOND, 0, 1, 0, MAX_SECOND - 1, 0},
1406 {MAX_SECOND, 0, 0, 500, MAX_SECOND - 1, 999999500},
1407 {MAX_SECOND, 0, 0, 1000000000, MAX_SECOND - 1, 0},
1408
1409 {MAX_SECOND, 0, MAX_SECOND, 0, 0, 0},
1410 };
1411 }
1412
1413 @Test(dataProvider="Minus")
1414 public void minus_Duration(long seconds, int nanos, long otherSeconds, int otherNanos, long expectedSeconds, int expectedNanoOfSecond) {
1415 Instant i = Instant.ofEpochSecond(seconds, nanos).minus(Duration.ofSeconds(otherSeconds, otherNanos));
1416 assertEquals(i.getEpochSecond(), expectedSeconds);
1417 assertEquals(i.getNano(), expectedNanoOfSecond);
1418 }
1419
1420 @Test(expectedExceptions=DateTimeException.class)
1421 public void minus_Duration_overflowTooSmall() {
1422 Instant i = Instant.ofEpochSecond(MIN_SECOND);
1423 i.minus(Duration.ofSeconds(0, 1));
1424 }
1425
1426 @Test(expectedExceptions=DateTimeException.class)
1427 public void minus_Duration_overflowTooBig() {
1428 Instant i = Instant.ofEpochSecond(MAX_SECOND, 999999999);
1429 i.minus(Duration.ofSeconds(-1, 999999999));
1430 }
1431
1432 //-----------------------------------------------------------------------
1433 @Test(dataProvider="Minus")
1434 public void minus_longTemporalUnit(long seconds, int nanos, long otherSeconds, int otherNanos, long expectedSeconds, int expectedNanoOfSecond) {
1435 Instant i = Instant.ofEpochSecond(seconds, nanos).minus(otherSeconds, SECONDS).minus(otherNanos, NANOS);
1436 assertEquals(i.getEpochSecond(), expectedSeconds);
1437 assertEquals(i.getNano(), expectedNanoOfSecond);
1438 }
1439
1440 @Test(expectedExceptions=DateTimeException.class)
1441 public void minus_longTemporalUnit_overflowTooSmall() {
1442 Instant i = Instant.ofEpochSecond(MIN_SECOND);
1443 i.minus(1, NANOS);
1444 }
1445
1446 @Test(expectedExceptions=DateTimeException.class)
1447 public void minus_longTemporalUnit_overflowTooBig() {
1448 Instant i = Instant.ofEpochSecond(MAX_SECOND, 999999999);
1449 i.minus(999999999, NANOS);
1450 i.minus(-1, SECONDS);
1451 }
1452
1453 //-----------------------------------------------------------------------
1454 @DataProvider(name="MinusSeconds")
1455 Object[][] provider_minusSeconds_long() {
1456 return new Object[][] {
1457 {0, 0, 0, 0, 0},
1458 {0, 0, 1, -1, 0},
1459 {0, 0, -1, 1, 0},
1460 {0, 0, -MIN_SECOND, MIN_SECOND, 0},
1461 {1, 0, 0, 1, 0},
1462 {1, 0, 1, 0, 0},
1463 {1, 0, -1, 2, 0},
1464 {1, 0, -MIN_SECOND + 1, MIN_SECOND, 0},
1465 {1, 1, 0, 1, 1},
1466 {1, 1, 1, 0, 1},
1467 {1, 1, -1, 2, 1},
1468 {1, 1, -MIN_SECOND, MIN_SECOND + 1, 1},
1469 {1, 1, -MIN_SECOND + 1, MIN_SECOND, 1},
1470 {-1, 1, 0, -1, 1},
1471 {-1, 1, 1, -2, 1},
1472 {-1, 1, -1, 0, 1},
1473 {-1, 1, -MAX_SECOND, MAX_SECOND - 1, 1},
1474 {-1, 1, -(MAX_SECOND + 1), MAX_SECOND, 1},
1475
1476 {MIN_SECOND, 2, MIN_SECOND, 0, 2},
1477 {MIN_SECOND + 1, 2, MIN_SECOND, 1, 2},
1478 {MAX_SECOND - 1, 2, MAX_SECOND, -1, 2},
1479 {MAX_SECOND, 2, MAX_SECOND, 0, 2},
1480 };
1481 }
1482
1483 @Test(dataProvider="MinusSeconds")
1484 public void minusSeconds_long(long seconds, int nanos, long amount, long expectedSeconds, int expectedNanoOfSecond) {
1485 Instant i = Instant.ofEpochSecond(seconds, nanos);
1486 i = i.minusSeconds(amount);
1487 assertEquals(i.getEpochSecond(), expectedSeconds);
1488 assertEquals(i.getNano(), expectedNanoOfSecond);
1489 }
1490
1491 @Test(expectedExceptions = {ArithmeticException.class})
1492 public void minusSeconds_long_overflowTooBig() {
1493 Instant i = Instant.ofEpochSecond(1, 0);
1494 i.minusSeconds(Long.MIN_VALUE + 1);
1495 }
1496
1497 @Test(expectedExceptions = {ArithmeticException.class})
1498 public void minusSeconds_long_overflowTooSmall() {
1499 Instant i = Instant.ofEpochSecond(-2, 0);
1500 i.minusSeconds(Long.MAX_VALUE);
1501 }
1502
1503 //-----------------------------------------------------------------------
1504 @DataProvider(name="MinusMillis")
1505 Object[][] provider_minusMillis_long() {
1506 return new Object[][] {
1507 {0, 0, 0, 0, 0},
1508 {0, 0, 1, -1, 999000000},
1509 {0, 0, 999, -1, 1000000},
1510 {0, 0, 1000, -1, 0},
1511 {0, 0, 1001, -2, 999000000},
1512 {0, 0, 1999, -2, 1000000},
1513 {0, 0, 2000, -2, 0},
1514 {0, 0, -1, 0, 1000000},
1515 {0, 0, -999, 0, 999000000},
1516 {0, 0, -1000, 1, 0},
1517 {0, 0, -1001, 1, 1000000},
1518 {0, 0, -1999, 1, 999000000},
1519
1520 {0, 1, 0, 0, 1},
1521 {0, 1, 1, -1, 999000001},
1522 {0, 1, 998, -1, 2000001},
1523 {0, 1, 999, -1, 1000001},
1524 {0, 1, 1000, -1, 1},
1525 {0, 1, 1998, -2, 2000001},
1526 {0, 1, 1999, -2, 1000001},
1527 {0, 1, 2000, -2, 1},
1528 {0, 1, -1, 0, 1000001},
1529 {0, 1, -2, 0, 2000001},
1530 {0, 1, -1000, 1, 1},
1531 {0, 1, -1001, 1, 1000001},
1532
1533 {0, 1000000, 0, 0, 1000000},
1534 {0, 1000000, 1, 0, 0},
1535 {0, 1000000, 998, -1, 3000000},
1536 {0, 1000000, 999, -1, 2000000},
1537 {0, 1000000, 1000, -1, 1000000},
1538 {0, 1000000, 1998, -2, 3000000},
1539 {0, 1000000, 1999, -2, 2000000},
1540 {0, 1000000, 2000, -2, 1000000},
1541 {0, 1000000, -1, 0, 2000000},
1542 {0, 1000000, -2, 0, 3000000},
1543 {0, 1000000, -999, 1, 0},
1544 {0, 1000000, -1000, 1, 1000000},
1545 {0, 1000000, -1001, 1, 2000000},
1546 {0, 1000000, -1002, 1, 3000000},
1547
1548 {0, 999999999, 0, 0, 999999999},
1549 {0, 999999999, 1, 0, 998999999},
1550 {0, 999999999, 999, 0, 999999},
1551 {0, 999999999, 1000, -1, 999999999},
1552 {0, 999999999, 1001, -1, 998999999},
1553 {0, 999999999, -1, 1, 999999},
1554 {0, 999999999, -1000, 1, 999999999},
1555 {0, 999999999, -1001, 2, 999999},
1556
1557 {0, 0, Long.MAX_VALUE, -(Long.MAX_VALUE / 1000) - 1, (int) -(Long.MAX_VALUE % 1000) * 1000000 + 1000000000},
1558 {0, 0, Long.MIN_VALUE, -(Long.MIN_VALUE / 1000), (int) -(Long.MIN_VALUE % 1000) * 1000000},
1559 };
1560 }
1561
1562 @Test(dataProvider="MinusMillis")
1563 public void minusMillis_long(long seconds, int nanos, long amount, long expectedSeconds, int expectedNanoOfSecond) {
1564 Instant i = Instant.ofEpochSecond(seconds, nanos);
1565 i = i.minusMillis(amount);
1566 assertEquals(i.getEpochSecond(), expectedSeconds);
1567 assertEquals(i.getNano(), expectedNanoOfSecond);
1568 }
1569
1570 @Test(dataProvider="MinusMillis")
1571 public void minusMillis_long_oneMore(long seconds, int nanos, long amount, long expectedSeconds, int expectedNanoOfSecond) {
1572 Instant i = Instant.ofEpochSecond(seconds + 1, nanos);
1573 i = i.minusMillis(amount);
1574 assertEquals(i.getEpochSecond(), expectedSeconds + 1);
1575 assertEquals(i.getNano(), expectedNanoOfSecond);
1576 }
1577
1578 @Test(dataProvider="MinusMillis")
1579 public void minusMillis_long_minusOneLess(long seconds, int nanos, long amount, long expectedSeconds, int expectedNanoOfSecond) {
1580 Instant i = Instant.ofEpochSecond(seconds - 1, nanos);
1581 i = i.minusMillis(amount);
1582 assertEquals(i.getEpochSecond(), expectedSeconds - 1);
1583 assertEquals(i.getNano(), expectedNanoOfSecond);
1584 }
1585
1586 @Test
1587 public void minusMillis_long_max() {
1588 Instant i = Instant.ofEpochSecond(MAX_SECOND, 998999999);
1589 i = i.minusMillis(-1);
1590 assertEquals(i.getEpochSecond(), MAX_SECOND);
1591 assertEquals(i.getNano(), 999999999);
1592 }
1593
1594 @Test(expectedExceptions=DateTimeException.class)
1595 public void minusMillis_long_overflowTooBig() {
1596 Instant i = Instant.ofEpochSecond(MAX_SECOND, 999000000);
1597 i.minusMillis(-1);
1598 }
1599
1600 @Test
1601 public void minusMillis_long_min() {
1602 Instant i = Instant.ofEpochSecond(MIN_SECOND, 1000000);
1603 i = i.minusMillis(1);
1604 assertEquals(i.getEpochSecond(), MIN_SECOND);
1605 assertEquals(i.getNano(), 0);
1606 }
1607
1608 @Test(expectedExceptions=DateTimeException.class)
1609 public void minusMillis_long_overflowTooSmall() {
1610 Instant i = Instant.ofEpochSecond(MIN_SECOND, 0);
1611 i.minusMillis(1);
1612 }
1613
1614 //-----------------------------------------------------------------------
1615 @DataProvider(name="MinusNanos")
1616 Object[][] provider_minusNanos_long() {
1617 return new Object[][] {
1618 {0, 0, 0, 0, 0},
1619 {0, 0, 1, -1, 999999999},
1620 {0, 0, 999999999, -1, 1},
1621 {0, 0, 1000000000, -1, 0},
1622 {0, 0, 1000000001, -2, 999999999},
1623 {0, 0, 1999999999, -2, 1},
1624 {0, 0, 2000000000, -2, 0},
1625 {0, 0, -1, 0, 1},
1626 {0, 0, -999999999, 0, 999999999},
1627 {0, 0, -1000000000, 1, 0},
1628 {0, 0, -1000000001, 1, 1},
1629 {0, 0, -1999999999, 1, 999999999},
1630
1631 {1, 0, 0, 1, 0},
1632 {1, 0, 1, 0, 999999999},
1633 {1, 0, 999999999, 0, 1},
1634 {1, 0, 1000000000, 0, 0},
1635 {1, 0, 1000000001, -1, 999999999},
1636 {1, 0, 1999999999, -1, 1},
1637 {1, 0, 2000000000, -1, 0},
1638 {1, 0, -1, 1, 1},
1639 {1, 0, -999999999, 1, 999999999},
1640 {1, 0, -1000000000, 2, 0},
1641 {1, 0, -1000000001, 2, 1},
1642 {1, 0, -1999999999, 2, 999999999},
1643
1644 {-1, 0, 0, -1, 0},
1645 {-1, 0, 1, -2, 999999999},
1646 {-1, 0, 999999999, -2, 1},
1647 {-1, 0, 1000000000, -2, 0},
1648 {-1, 0, 1000000001, -3, 999999999},
1649 {-1, 0, 1999999999, -3, 1},
1650 {-1, 0, 2000000000, -3, 0},
1651 {-1, 0, -1, -1, 1},
1652 {-1, 0, -999999999, -1, 999999999},
1653 {-1, 0, -1000000000, 0, 0},
1654 {-1, 0, -1000000001, 0, 1},
1655 {-1, 0, -1999999999, 0, 999999999},
1656
1657 {1, 1, 0, 1, 1},
1658 {1, 1, 1, 1, 0},
1659 {1, 1, 999999998, 0, 3},
1660 {1, 1, 999999999, 0, 2},
1661 {1, 1, 1000000000, 0, 1},
1662 {1, 1, 1999999998, -1, 3},
1663 {1, 1, 1999999999, -1, 2},
1664 {1, 1, 2000000000, -1, 1},
1665 {1, 1, -1, 1, 2},
1666 {1, 1, -2, 1, 3},
1667 {1, 1, -1000000000, 2, 1},
1668 {1, 1, -1000000001, 2, 2},
1669 {1, 1, -1000000002, 2, 3},
1670 {1, 1, -2000000000, 3, 1},
1671
1672 {1, 999999999, 0, 1, 999999999},
1673 {1, 999999999, 1, 1, 999999998},
1674 {1, 999999999, 999999999, 1, 0},
1675 {1, 999999999, 1000000000, 0, 999999999},
1676 {1, 999999999, 1000000001, 0, 999999998},
1677 {1, 999999999, -1, 2, 0},
1678 {1, 999999999, -1000000000, 2, 999999999},
1679 {1, 999999999, -1000000001, 3, 0},
1680 {1, 999999999, -1999999999, 3, 999999998},
1681 {1, 999999999, -2000000000, 3, 999999999},
1682
1683 {MAX_SECOND, 0, -999999999, MAX_SECOND, 999999999},
1684 {MAX_SECOND - 1, 0, -1999999999, MAX_SECOND, 999999999},
1685 {MIN_SECOND, 1, 1, MIN_SECOND, 0},
1686 {MIN_SECOND + 1, 1, 1000000001, MIN_SECOND, 0},
1687
1688 {0, 0, Long.MAX_VALUE, -(Long.MAX_VALUE / 1000000000) - 1, (int) -(Long.MAX_VALUE % 1000000000) + 1000000000},
1689 {0, 0, Long.MIN_VALUE, -(Long.MIN_VALUE / 1000000000), (int) -(Long.MIN_VALUE % 1000000000)},
1690 };
1691 }
1692
1693 @Test(dataProvider="MinusNanos")
1694 public void minusNanos_long(long seconds, int nanos, long amount, long expectedSeconds, int expectedNanoOfSecond) {
1695 Instant i = Instant.ofEpochSecond(seconds, nanos);
1696 i = i.minusNanos(amount);
1697 assertEquals(i.getEpochSecond(), expectedSeconds);
1698 assertEquals(i.getNano(), expectedNanoOfSecond);
1699 }
1700
1701 @Test(expectedExceptions=DateTimeException.class)
1702 public void minusNanos_long_overflowTooBig() {
1703 Instant i = Instant.ofEpochSecond(MAX_SECOND, 999999999);
1704 i.minusNanos(-1);
1705 }
1706
1707 @Test(expectedExceptions=DateTimeException.class)
1708 public void minusNanos_long_overflowTooSmall() {
1709 Instant i = Instant.ofEpochSecond(MIN_SECOND, 0);
1710 i.minusNanos(1);
1711 }
1712
1713 //-----------------------------------------------------------------------
1714 // until(Temporal, TemporalUnit)
1715 //-----------------------------------------------------------------------
1716 @DataProvider(name="periodUntilUnit")
1717 Object[][] data_periodUntilUnit() {
1718 return new Object[][] {
1719 {5, 650, -1, 650, SECONDS, -6},
1720 {5, 650, 0, 650, SECONDS, -5},
1721 {5, 650, 3, 650, SECONDS, -2},
1722 {5, 650, 4, 650, SECONDS, -1},
1723 {5, 650, 5, 650, SECONDS, 0},
1724 {5, 650, 6, 650, SECONDS, 1},
1725 {5, 650, 7, 650, SECONDS, 2},
1726
1727 {5, 650, -1, 0, SECONDS, -6},
1728 {5, 650, 0, 0, SECONDS, -5},
1729 {5, 650, 3, 0, SECONDS, -2},
1730 {5, 650, 4, 0, SECONDS, -1},
1731 {5, 650, 5, 0, SECONDS, 0},
1732 {5, 650, 6, 0, SECONDS, 0},
1733 {5, 650, 7, 0, SECONDS, 1},
1734
1735 {5, 650, -1, 950, SECONDS, -5},
1736 {5, 650, 0, 950, SECONDS, -4},
1737 {5, 650, 3, 950, SECONDS, -1},
1738 {5, 650, 4, 950, SECONDS, 0},
1739 {5, 650, 5, 950, SECONDS, 0},
1740 {5, 650, 6, 950, SECONDS, 1},
1741 {5, 650, 7, 950, SECONDS, 2},
1742
1743 {5, 650, -1, 50, SECONDS, -6},
1744 {5, 650, 0, 50, SECONDS, -5},
1745 {5, 650, 4, 50, SECONDS, -1},
1746 {5, 650, 5, 50, SECONDS, 0},
1747 {5, 650, 6, 50, SECONDS, 0},
1748 {5, 650, 7, 50, SECONDS, 1},
1749 {5, 650, 8, 50, SECONDS, 2},
1750
1751 {5, 650_000_000, -1, 650_000_000, NANOS, -6_000_000_000L},
1752 {5, 650_000_000, 0, 650_000_000, NANOS, -5_000_000_000L},
1753 {5, 650_000_000, 3, 650_000_000, NANOS, -2_000_000_000L},
1754 {5, 650_000_000, 4, 650_000_000, NANOS, -1_000_000_000L},
1755 {5, 650_000_000, 5, 650_000_000, NANOS, 0},
1756 {5, 650_000_000, 6, 650_000_000, NANOS, 1_000_000_000L},
1757 {5, 650_000_000, 7, 650_000_000, NANOS, 2_000_000_000L},
1758
1759 {5, 650_000_000, -1, 0, NANOS, -6_650_000_000L},
1760 {5, 650_000_000, 0, 0, NANOS, -5_650_000_000L},
1761 {5, 650_000_000, 3, 0, NANOS, -2_650_000_000L},
1762 {5, 650_000_000, 4, 0, NANOS, -1_650_000_000L},
1763 {5, 650_000_000, 5, 0, NANOS, -650_000_000L},
1764 {5, 650_000_000, 6, 0, NANOS, 350_000_000L},
1765 {5, 650_000_000, 7, 0, NANOS, 1_350_000_000L},
1766
1767 {5, 650_000_000, -1, 950_000_000, NANOS, -5_700_000_000L},
1768 {5, 650_000_000, 0, 950_000_000, NANOS, -4_700_000_000L},
1769 {5, 650_000_000, 3, 950_000_000, NANOS, -1_700_000_000L},
1770 {5, 650_000_000, 4, 950_000_000, NANOS, -700_000_000L},
1771 {5, 650_000_000, 5, 950_000_000, NANOS, 300_000_000L},
1772 {5, 650_000_000, 6, 950_000_000, NANOS, 1_300_000_000L},
1773 {5, 650_000_000, 7, 950_000_000, NANOS, 2_300_000_000L},
1774
1775 {5, 650_000_000, -1, 50_000_000, NANOS, -6_600_000_000L},
1776 {5, 650_000_000, 0, 50_000_000, NANOS, -5_600_000_000L},
1777 {5, 650_000_000, 4, 50_000_000, NANOS, -1_600_000_000L},
1778 {5, 650_000_000, 5, 50_000_000, NANOS, -600_000_000L},
1779 {5, 650_000_000, 6, 50_000_000, NANOS, 400_000_000L},
1780 {5, 650_000_000, 7, 50_000_000, NANOS, 1_400_000_000L},
1781 {5, 650_000_000, 8, 50_000_000, NANOS, 2_400_000_000L},
1782
1783 {0, 0, -60, 0, MINUTES, -1L},
1784 {0, 0, -1, 999_999_999, MINUTES, 0L},
1785 {0, 0, 59, 0, MINUTES, 0L},
1786 {0, 0, 59, 999_999_999, MINUTES, 0L},
1787 {0, 0, 60, 0, MINUTES, 1L},
1788 {0, 0, 61, 0, MINUTES, 1L},
1789
1790 {0, 0, -3600, 0, HOURS, -1L},
1791 {0, 0, -1, 999_999_999, HOURS, 0L},
1792 {0, 0, 3599, 0, HOURS, 0L},
1793 {0, 0, 3599, 999_999_999, HOURS, 0L},
1794 {0, 0, 3600, 0, HOURS, 1L},
1795 {0, 0, 3601, 0, HOURS, 1L},
1796
1797 {0, 0, -86400, 0, DAYS, -1L},
1798 {0, 0, -1, 999_999_999, DAYS, 0L},
1799 {0, 0, 86399, 0, DAYS, 0L},
1800 {0, 0, 86399, 999_999_999, DAYS, 0L},
1801 {0, 0, 86400, 0, DAYS, 1L},
1802 {0, 0, 86401, 0, DAYS, 1L},
1803 };
1804 }
1805
1806 @Test(dataProvider="periodUntilUnit")
1807 public void test_until_TemporalUnit(long seconds1, int nanos1, long seconds2, long nanos2, TemporalUnit unit, long expected) {
1808 Instant i1 = Instant.ofEpochSecond(seconds1, nanos1);
1809 Instant i2 = Instant.ofEpochSecond(seconds2, nanos2);
1810 long amount = i1.until(i2, unit);
1811 assertEquals(amount, expected);
1812 }
1813
1814 @Test(dataProvider="periodUntilUnit")
1815 public void test_until_TemporalUnit_negated(long seconds1, int nanos1, long seconds2, long nanos2, TemporalUnit unit, long expected) {
1816 Instant i1 = Instant.ofEpochSecond(seconds1, nanos1);
1817 Instant i2 = Instant.ofEpochSecond(seconds2, nanos2);
1818 long amount = i2.until(i1, unit);
1819 assertEquals(amount, -expected);
1820 }
1821
1822 @Test(dataProvider="periodUntilUnit")
1823 public void test_until_TemporalUnit_between(long seconds1, int nanos1, long seconds2, long nanos2, TemporalUnit unit, long expected) {
1824 Instant i1 = Instant.ofEpochSecond(seconds1, nanos1);
1825 Instant i2 = Instant.ofEpochSecond(seconds2, nanos2);
1826 long amount = unit.between(i1, i2);
1827 assertEquals(amount, expected);
1828 }
1829
1830 @Test
1831 public void test_until_convertedType() {
1832 Instant start = Instant.ofEpochSecond(12, 3000);
1833 OffsetDateTime end = start.plusSeconds(2).atOffset(ZoneOffset.ofHours(2));
1834 assertEquals(start.until(end, SECONDS), 2);
1835 }
1836
1837 @Test(expectedExceptions=DateTimeException.class)
1838 public void test_until_invalidType() {
1839 Instant start = Instant.ofEpochSecond(12, 3000);
1840 start.until(LocalTime.of(11, 30), SECONDS);
1841 }
1842
1843 @Test(expectedExceptions = UnsupportedTemporalTypeException.class)
1844 public void test_until_TemporalUnit_unsupportedUnit() {
1845 TEST_12345_123456789.until(TEST_12345_123456789, MONTHS);
1846 }
1847
1848 @Test(expectedExceptions = NullPointerException.class)
1849 public void test_until_TemporalUnit_nullEnd() {
1850 TEST_12345_123456789.until(null, HOURS);
1851 }
1852
1853 @Test(expectedExceptions = NullPointerException.class)
1854 public void test_until_TemporalUnit_nullUnit() {
1855 TEST_12345_123456789.until(TEST_12345_123456789, null);
1856 }
1857
1858 //-----------------------------------------------------------------------
1859 // atOffset()
1860 //-----------------------------------------------------------------------
1861 @Test
1862 public void test_atOffset() {
1863 for (int i = 0; i < (24 * 60 * 60); i++) {
1864 Instant instant = Instant.ofEpochSecond(i);
1865 OffsetDateTime test = instant.atOffset(ZoneOffset.ofHours(1));
1866 assertEquals(test.getYear(), 1970);
1867 assertEquals(test.getMonthValue(), 1);
1868 assertEquals(test.getDayOfMonth(), 1 + (i >= 23 * 60 * 60 ? 1 : 0));
1869 assertEquals(test.getHour(), ((i / (60 * 60)) + 1) % 24);
1870 assertEquals(test.getMinute(), (i / 60) % 60);
1871 assertEquals(test.getSecond(), i % 60);
1872 }
1873 }
1874
1875 @Test(expectedExceptions=NullPointerException.class)
1876 public void test_atOffset_null() {
1877 TEST_12345_123456789.atOffset(null);
1878 }
1879
1880 //-----------------------------------------------------------------------
1881 // atZone()
1882 //-----------------------------------------------------------------------
1883 @Test
1884 public void test_atZone() {
1885 for (int i = 0; i < (24 * 60 * 60); i++) {
1886 Instant instant = Instant.ofEpochSecond(i);
1887 ZonedDateTime test = instant.atZone(ZoneOffset.ofHours(1));
1888 assertEquals(test.getYear(), 1970);
1889 assertEquals(test.getMonthValue(), 1);
1890 assertEquals(test.getDayOfMonth(), 1 + (i >= 23 * 60 * 60 ? 1 : 0));
1891 assertEquals(test.getHour(), ((i / (60 * 60)) + 1) % 24);
1892 assertEquals(test.getMinute(), (i / 60) % 60);
1893 assertEquals(test.getSecond(), i % 60);
1894 }
1895 }
1896
1897 @Test(expectedExceptions=NullPointerException.class)
1898 public void test_atZone_null() {
1899 TEST_12345_123456789.atZone(null);
1900 }
1901
1902 //-----------------------------------------------------------------------
1903 // toEpochMilli()
1904 //-----------------------------------------------------------------------
1905 @Test
1906 public void test_toEpochMilli() {
1907 assertEquals(Instant.ofEpochSecond(1L, 1000000).toEpochMilli(), 1001L);
1908 assertEquals(Instant.ofEpochSecond(1L, 2000000).toEpochMilli(), 1002L);
1909 assertEquals(Instant.ofEpochSecond(1L, 567).toEpochMilli(), 1000L);
1910 assertEquals(Instant.ofEpochSecond(Long.MAX_VALUE / 1000).toEpochMilli(), (Long.MAX_VALUE / 1000) * 1000);
1911 assertEquals(Instant.ofEpochSecond(Long.MIN_VALUE / 1000).toEpochMilli(), (Long.MIN_VALUE / 1000) * 1000);
1912 assertEquals(Instant.ofEpochSecond(0L, -1000000).toEpochMilli(), -1L);
1913 assertEquals(Instant.ofEpochSecond(0L, 1000000).toEpochMilli(), 1);
1914 assertEquals(Instant.ofEpochSecond(0L, 999999).toEpochMilli(), 0);
1915 assertEquals(Instant.ofEpochSecond(0L, 1).toEpochMilli(), 0);
1916 assertEquals(Instant.ofEpochSecond(0L, 0).toEpochMilli(), 0);
1917 assertEquals(Instant.ofEpochSecond(0L, -1).toEpochMilli(), -1L);
1918 assertEquals(Instant.ofEpochSecond(0L, -999999).toEpochMilli(), -1L);
1919 assertEquals(Instant.ofEpochSecond(0L, -1000000).toEpochMilli(), -1L);
1920 assertEquals(Instant.ofEpochSecond(0L, -1000001).toEpochMilli(), -2L);
1921 }
1922
1923 @Test(expectedExceptions=ArithmeticException.class)
1924 public void test_toEpochMilli_tooBig() {
1925 Instant.ofEpochSecond(Long.MAX_VALUE / 1000 + 1).toEpochMilli();
1926 }
1927
1928 @Test(expectedExceptions=ArithmeticException.class)
1929 public void test_toEpochMilli_tooSmall() {
1930 Instant.ofEpochSecond(Long.MIN_VALUE / 1000 - 1).toEpochMilli();
1931 }
1932
1933 @Test(expectedExceptions=ArithmeticException.class)
1934 public void test_toEpochMillis_overflow() {
1935 Instant.ofEpochSecond(Long.MAX_VALUE / 1000, 809_000_000).toEpochMilli();
1936 }
1937
1938 @Test(expectedExceptions=ArithmeticException.class)
1939 public void test_toEpochMillis_overflow2() {
1940 Instant.ofEpochSecond(-9223372036854776L, 1).toEpochMilli();
1941 }
1942
1943 //-----------------------------------------------------------------------
1944 // compareTo()
1945 //-----------------------------------------------------------------------
1946 @Test
1947 public void test_comparisons() {
1948 doTest_comparisons_Instant(
1949 Instant.ofEpochSecond(-2L, 0),
1950 Instant.ofEpochSecond(-2L, 999999998),
1951 Instant.ofEpochSecond(-2L, 999999999),
1952 Instant.ofEpochSecond(-1L, 0),
1953 Instant.ofEpochSecond(-1L, 1),
1954 Instant.ofEpochSecond(-1L, 999999998),
1955 Instant.ofEpochSecond(-1L, 999999999),
1956 Instant.ofEpochSecond(0L, 0),
1957 Instant.ofEpochSecond(0L, 1),
1958 Instant.ofEpochSecond(0L, 2),
1959 Instant.ofEpochSecond(0L, 999999999),
1960 Instant.ofEpochSecond(1L, 0),
1961 Instant.ofEpochSecond(2L, 0)
1962 );
1963 }
1964
1965 void doTest_comparisons_Instant(Instant... instants) {
1966 for (int i = 0; i < instants.length; i++) {
1967 Instant a = instants[i];
1968 for (int j = 0; j < instants.length; j++) {
1969 Instant b = instants[j];
1970 if (i < j) {
1971 assertEquals(a.compareTo(b) < 0, true, a + " <=> " + b);
1972 assertEquals(a.isBefore(b), true, a + " <=> " + b);
1973 assertEquals(a.isAfter(b), false, a + " <=> " + b);
1974 assertEquals(a.equals(b), false, a + " <=> " + b);
1975 } else if (i > j) {
1976 assertEquals(a.compareTo(b) > 0, true, a + " <=> " + b);
1977 assertEquals(a.isBefore(b), false, a + " <=> " + b);
1978 assertEquals(a.isAfter(b), true, a + " <=> " + b);
1979 assertEquals(a.equals(b), false, a + " <=> " + b);
1980 } else {
1981 assertEquals(a.compareTo(b), 0, a + " <=> " + b);
1982 assertEquals(a.isBefore(b), false, a + " <=> " + b);
1983 assertEquals(a.isAfter(b), false, a + " <=> " + b);
1984 assertEquals(a.equals(b), true, a + " <=> " + b);
1985 }
1986 }
1987 }
1988 }
1989
1990 @Test(expectedExceptions=NullPointerException.class)
1991 public void test_compareTo_ObjectNull() {
1992 Instant a = Instant.ofEpochSecond(0L, 0);
1993 a.compareTo(null);
1994 }
1995
1996 @Test(expectedExceptions=NullPointerException.class)
1997 public void test_isBefore_ObjectNull() {
1998 Instant a = Instant.ofEpochSecond(0L, 0);
1999 a.isBefore(null);
2000 }
2001
2002 @Test(expectedExceptions=NullPointerException.class)
2003 public void test_isAfter_ObjectNull() {
2004 Instant a = Instant.ofEpochSecond(0L, 0);
2005 a.isAfter(null);
2006 }
2007
2008 @Test(expectedExceptions=ClassCastException.class)
2009 @SuppressWarnings({"unchecked", "rawtypes"})
2010 public void compareToNonInstant() {
2011 Comparable c = Instant.ofEpochSecond(0L);
2012 c.compareTo(new Object());
2013 }
2014
2015 //-----------------------------------------------------------------------
2016 // equals()
2017 //-----------------------------------------------------------------------
2018 @Test
2019 public void test_equals() {
2020 Instant test5a = Instant.ofEpochSecond(5L, 20);
2021 Instant test5b = Instant.ofEpochSecond(5L, 20);
2022 Instant test5n = Instant.ofEpochSecond(5L, 30);
2023 Instant test6 = Instant.ofEpochSecond(6L, 20);
2024
2025 assertEquals(test5a.equals(test5a), true);
2026 assertEquals(test5a.equals(test5b), true);
2027 assertEquals(test5a.equals(test5n), false);
2028 assertEquals(test5a.equals(test6), false);
2029
2030 assertEquals(test5b.equals(test5a), true);
2031 assertEquals(test5b.equals(test5b), true);
2032 assertEquals(test5b.equals(test5n), false);
2033 assertEquals(test5b.equals(test6), false);
2034
2035 assertEquals(test5n.equals(test5a), false);
2036 assertEquals(test5n.equals(test5b), false);
2037 assertEquals(test5n.equals(test5n), true);
2038 assertEquals(test5n.equals(test6), false);
2039
2040 assertEquals(test6.equals(test5a), false);
2041 assertEquals(test6.equals(test5b), false);
2042 assertEquals(test6.equals(test5n), false);
2043 assertEquals(test6.equals(test6), true);
2044 }
2045
2046 @Test
2047 public void test_equals_null() {
2048 Instant test5 = Instant.ofEpochSecond(5L, 20);
2049 assertEquals(test5.equals(null), false);
2050 }
2051
2052 @Test
2053 public void test_equals_otherClass() {
2054 Instant test5 = Instant.ofEpochSecond(5L, 20);
2055 assertEquals(test5.equals(""), false);
2056 }
2057
2058 //-----------------------------------------------------------------------
2059 // hashCode()
2060 //-----------------------------------------------------------------------
2061 @Test
2062 public void test_hashCode() {
2063 Instant test5a = Instant.ofEpochSecond(5L, 20);
2064 Instant test5b = Instant.ofEpochSecond(5L, 20);
2065 Instant test5n = Instant.ofEpochSecond(5L, 30);
2066 Instant test6 = Instant.ofEpochSecond(6L, 20);
2067
2068 assertEquals(test5a.hashCode() == test5a.hashCode(), true);
2069 assertEquals(test5a.hashCode() == test5b.hashCode(), true);
2070 assertEquals(test5b.hashCode() == test5b.hashCode(), true);
2071
2072 assertEquals(test5a.hashCode() == test5n.hashCode(), false);
2073 assertEquals(test5a.hashCode() == test6.hashCode(), false);
2074 }
2075
2076 //-----------------------------------------------------------------------
2077 // toString()
2078 //-----------------------------------------------------------------------
2079 @DataProvider(name="toStringParse")
2080 Object[][] data_toString() {
2081 return new Object[][] {
2082 {Instant.ofEpochSecond(65L, 567), "1970-01-01T00:01:05.000000567Z"},
2083 {Instant.ofEpochSecond(65L, 560), "1970-01-01T00:01:05.000000560Z"},
2084 {Instant.ofEpochSecond(65L, 560000), "1970-01-01T00:01:05.000560Z"},
2085 {Instant.ofEpochSecond(65L, 560000000), "1970-01-01T00:01:05.560Z"},
2086
2087 {Instant.ofEpochSecond(1, 0), "1970-01-01T00:00:01Z"},
2088 {Instant.ofEpochSecond(60, 0), "1970-01-01T00:01:00Z"},
2089 {Instant.ofEpochSecond(3600, 0), "1970-01-01T01:00:00Z"},
2090 {Instant.ofEpochSecond(-1, 0), "1969-12-31T23:59:59Z"},
2091
2092 {LocalDateTime.of(0, 1, 2, 0, 0).toInstant(ZoneOffset.UTC), "0000-01-02T00:00:00Z"},
2093 {LocalDateTime.of(0, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "0000-01-01T12:30:00Z"},
2094 {LocalDateTime.of(0, 1, 1, 0, 0, 0, 1).toInstant(ZoneOffset.UTC), "0000-01-01T00:00:00.000000001Z"},
2095 {LocalDateTime.of(0, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "0000-01-01T00:00:00Z"},
2096
2097 {LocalDateTime.of(-1, 12, 31, 23, 59, 59, 999_999_999).toInstant(ZoneOffset.UTC), "-0001-12-31T23:59:59.999999999Z"},
2098 {LocalDateTime.of(-1, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-0001-12-31T12:30:00Z"},
2099 {LocalDateTime.of(-1, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "-0001-12-30T12:30:00Z"},
2100
2101 {LocalDateTime.of(-9999, 1, 2, 12, 30).toInstant(ZoneOffset.UTC), "-9999-01-02T12:30:00Z"},
2102 {LocalDateTime.of(-9999, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "-9999-01-01T12:30:00Z"},
2103 {LocalDateTime.of(-9999, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "-9999-01-01T00:00:00Z"},
2104
2105 {LocalDateTime.of(-10000, 12, 31, 23, 59, 59, 999_999_999).toInstant(ZoneOffset.UTC), "-10000-12-31T23:59:59.999999999Z"},
2106 {LocalDateTime.of(-10000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-10000-12-31T12:30:00Z"},
2107 {LocalDateTime.of(-10000, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "-10000-12-30T12:30:00Z"},
2108 {LocalDateTime.of(-15000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-15000-12-31T12:30:00Z"},
2109
2110 {LocalDateTime.of(-19999, 1, 2, 12, 30).toInstant(ZoneOffset.UTC), "-19999-01-02T12:30:00Z"},
2111 {LocalDateTime.of(-19999, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "-19999-01-01T12:30:00Z"},
2112 {LocalDateTime.of(-19999, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "-19999-01-01T00:00:00Z"},
2113
2114 {LocalDateTime.of(-20000, 12, 31, 23, 59, 59, 999_999_999).toInstant(ZoneOffset.UTC), "-20000-12-31T23:59:59.999999999Z"},
2115 {LocalDateTime.of(-20000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-20000-12-31T12:30:00Z"},
2116 {LocalDateTime.of(-20000, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "-20000-12-30T12:30:00Z"},
2117 {LocalDateTime.of(-25000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "-25000-12-31T12:30:00Z"},
2118
2119 {LocalDateTime.of(9999, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "9999-12-30T12:30:00Z"},
2120 {LocalDateTime.of(9999, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "9999-12-31T12:30:00Z"},
2121 {LocalDateTime.of(9999, 12, 31, 23, 59, 59, 999_999_999).toInstant(ZoneOffset.UTC), "9999-12-31T23:59:59.999999999Z"},
2122
2123 {LocalDateTime.of(10000, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "+10000-01-01T00:00:00Z"},
2124 {LocalDateTime.of(10000, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "+10000-01-01T12:30:00Z"},
2125 {LocalDateTime.of(10000, 1, 2, 12, 30).toInstant(ZoneOffset.UTC), "+10000-01-02T12:30:00Z"},
2126 {LocalDateTime.of(15000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "+15000-12-31T12:30:00Z"},
2127
2128 {LocalDateTime.of(19999, 12, 30, 12, 30).toInstant(ZoneOffset.UTC), "+19999-12-30T12:30:00Z"},
2129 {LocalDateTime.of(19999, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "+19999-12-31T12:30:00Z"},
2130 {LocalDateTime.of(19999, 12, 31, 23, 59, 59, 999_999_999).toInstant(ZoneOffset.UTC), "+19999-12-31T23:59:59.999999999Z"},
2131
2132 {LocalDateTime.of(20000, 1, 1, 0, 0).toInstant(ZoneOffset.UTC), "+20000-01-01T00:00:00Z"},
2133 {LocalDateTime.of(20000, 1, 1, 12, 30).toInstant(ZoneOffset.UTC), "+20000-01-01T12:30:00Z"},
2134 {LocalDateTime.of(20000, 1, 2, 12, 30).toInstant(ZoneOffset.UTC), "+20000-01-02T12:30:00Z"},
2135 {LocalDateTime.of(25000, 12, 31, 12, 30).toInstant(ZoneOffset.UTC), "+25000-12-31T12:30:00Z"},
2136
2137 {LocalDateTime.of(-999_999_999, 1, 1, 12, 30).toInstant(ZoneOffset.UTC).minus(1, DAYS), "-1000000000-12-31T12:30:00Z"},
2138 {LocalDateTime.of(999_999_999, 12, 31, 12, 30).toInstant(ZoneOffset.UTC).plus(1, DAYS), "+1000000000-01-01T12:30:00Z"},
2139
2140 {Instant.MIN, "-1000000000-01-01T00:00:00Z"},
2141 {Instant.MAX, "+1000000000-12-31T23:59:59.999999999Z"},
2142 };
2143 }
2144
2145 @Test(dataProvider="toStringParse")
2146 public void test_toString(Instant instant, String expected) {
2147 assertEquals(instant.toString(), expected);
2148 }
2149
2150 @Test(dataProvider="toStringParse")
2151 public void test_parse(Instant instant, String text) {
2152 assertEquals(Instant.parse(text), instant);
2153 }
2154
2155 @Test(dataProvider="toStringParse")
2156 public void test_parseLowercase(Instant instant, String text) {
2157 assertEquals(Instant.parse(text.toLowerCase(Locale.ENGLISH)), instant);
2158 }
2159
2160 }