001 /*
002 * Copyright 2001-2009 Stephen Colebourne
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016 package org.joda.time;
017
018 import java.io.ByteArrayInputStream;
019 import java.io.ByteArrayOutputStream;
020 import java.io.ObjectInputStream;
021 import java.io.ObjectOutputStream;
022 import java.lang.reflect.Modifier;
023 import java.util.Date;
024 import java.util.Locale;
025 import java.util.TimeZone;
026
027 import junit.framework.TestCase;
028 import junit.framework.TestSuite;
029
030 import org.joda.time.base.AbstractInstant;
031 import org.joda.time.chrono.GregorianChronology;
032 import org.joda.time.chrono.ISOChronology;
033
034 /**
035 * This class is a Junit unit test for Instant.
036 *
037 * @author Stephen Colebourne
038 */
039 public class TestInstant_Basics extends TestCase {
040 // Test in 2002/03 as time zones are more well known
041 // (before the late 90's they were all over the place)
042
043 private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris");
044 private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London");
045
046 long y2002days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
047 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 +
048 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
049 366 + 365;
050 long y2003days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
051 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 +
052 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
053 366 + 365 + 365;
054
055 // 2002-06-09
056 private long TEST_TIME_NOW =
057 (y2002days + 31L + 28L + 31L + 30L + 31L + 9L -1L) * DateTimeConstants.MILLIS_PER_DAY;
058
059 // 2002-04-05
060 private long TEST_TIME1 =
061 (y2002days + 31L + 28L + 31L + 5L -1L) * DateTimeConstants.MILLIS_PER_DAY
062 + 12L * DateTimeConstants.MILLIS_PER_HOUR
063 + 24L * DateTimeConstants.MILLIS_PER_MINUTE;
064
065 // 2003-05-06
066 private long TEST_TIME2 =
067 (y2003days + 31L + 28L + 31L + 30L + 6L -1L) * DateTimeConstants.MILLIS_PER_DAY
068 + 14L * DateTimeConstants.MILLIS_PER_HOUR
069 + 28L * DateTimeConstants.MILLIS_PER_MINUTE;
070
071 private DateTimeZone originalDateTimeZone = null;
072 private TimeZone originalTimeZone = null;
073 private Locale originalLocale = null;
074
075 public static void main(String[] args) {
076 junit.textui.TestRunner.run(suite());
077 }
078
079 public static TestSuite suite() {
080 return new TestSuite(TestInstant_Basics.class);
081 }
082
083 public TestInstant_Basics(String name) {
084 super(name);
085 }
086
087 protected void setUp() throws Exception {
088 DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW);
089 originalDateTimeZone = DateTimeZone.getDefault();
090 originalTimeZone = TimeZone.getDefault();
091 originalLocale = Locale.getDefault();
092 DateTimeZone.setDefault(LONDON);
093 TimeZone.setDefault(TimeZone.getTimeZone("Europe/London"));
094 Locale.setDefault(Locale.UK);
095 }
096
097 protected void tearDown() throws Exception {
098 DateTimeUtils.setCurrentMillisSystem();
099 DateTimeZone.setDefault(originalDateTimeZone);
100 TimeZone.setDefault(originalTimeZone);
101 Locale.setDefault(originalLocale);
102 originalDateTimeZone = null;
103 originalTimeZone = null;
104 originalLocale = null;
105 }
106
107 //-----------------------------------------------------------------------
108 public void testTest() {
109 assertEquals("2002-06-09T00:00:00.000Z", new Instant(TEST_TIME_NOW).toString());
110 assertEquals("2002-04-05T12:24:00.000Z", new Instant(TEST_TIME1).toString());
111 assertEquals("2003-05-06T14:28:00.000Z", new Instant(TEST_TIME2).toString());
112 }
113
114 //-----------------------------------------------------------------------
115 public void testGet_DateTimeFieldType() {
116 Instant test = new Instant(); // 2002-06-09
117 assertEquals(1, test.get(DateTimeFieldType.era()));
118 assertEquals(20, test.get(DateTimeFieldType.centuryOfEra()));
119 assertEquals(2, test.get(DateTimeFieldType.yearOfCentury()));
120 assertEquals(2002, test.get(DateTimeFieldType.yearOfEra()));
121 assertEquals(2002, test.get(DateTimeFieldType.year()));
122 assertEquals(6, test.get(DateTimeFieldType.monthOfYear()));
123 assertEquals(9, test.get(DateTimeFieldType.dayOfMonth()));
124 assertEquals(2002, test.get(DateTimeFieldType.weekyear()));
125 assertEquals(23, test.get(DateTimeFieldType.weekOfWeekyear()));
126 assertEquals(7, test.get(DateTimeFieldType.dayOfWeek()));
127 assertEquals(160, test.get(DateTimeFieldType.dayOfYear()));
128 assertEquals(0, test.get(DateTimeFieldType.halfdayOfDay()));
129 assertEquals(0, test.get(DateTimeFieldType.hourOfHalfday())); // UTC zone
130 assertEquals(24, test.get(DateTimeFieldType.clockhourOfDay())); // UTC zone
131 assertEquals(12, test.get(DateTimeFieldType.clockhourOfHalfday())); // UTC zone
132 assertEquals(0, test.get(DateTimeFieldType.hourOfDay())); // UTC zone
133 assertEquals(0, test.get(DateTimeFieldType.minuteOfHour()));
134 assertEquals(0, test.get(DateTimeFieldType.minuteOfDay()));
135 assertEquals(0, test.get(DateTimeFieldType.secondOfMinute()));
136 assertEquals(0, test.get(DateTimeFieldType.secondOfDay()));
137 assertEquals(0, test.get(DateTimeFieldType.millisOfSecond()));
138 assertEquals(0, test.get(DateTimeFieldType.millisOfDay()));
139 try {
140 test.get((DateTimeFieldType) null);
141 fail();
142 } catch (IllegalArgumentException ex) {}
143 }
144
145 public void testGet_DateTimeField() {
146 Instant test = new Instant(); // 2002-06-09
147 assertEquals(1, test.get(ISOChronology.getInstance().era()));
148 assertEquals(20, test.get(ISOChronology.getInstance().centuryOfEra()));
149 assertEquals(2, test.get(ISOChronology.getInstance().yearOfCentury()));
150 assertEquals(2002, test.get(ISOChronology.getInstance().yearOfEra()));
151 assertEquals(2002, test.get(ISOChronology.getInstance().year()));
152 assertEquals(6, test.get(ISOChronology.getInstance().monthOfYear()));
153 assertEquals(9, test.get(ISOChronology.getInstance().dayOfMonth()));
154 assertEquals(2002, test.get(ISOChronology.getInstance().weekyear()));
155 assertEquals(23, test.get(ISOChronology.getInstance().weekOfWeekyear()));
156 assertEquals(7, test.get(ISOChronology.getInstance().dayOfWeek()));
157 assertEquals(160, test.get(ISOChronology.getInstance().dayOfYear()));
158 assertEquals(0, test.get(ISOChronology.getInstance().halfdayOfDay()));
159 assertEquals(1, test.get(ISOChronology.getInstance().hourOfHalfday()));
160 assertEquals(1, test.get(ISOChronology.getInstance().clockhourOfDay()));
161 assertEquals(1, test.get(ISOChronology.getInstance().clockhourOfHalfday()));
162 assertEquals(1, test.get(ISOChronology.getInstance().hourOfDay()));
163 assertEquals(0, test.get(ISOChronology.getInstance().minuteOfHour()));
164 assertEquals(60, test.get(ISOChronology.getInstance().minuteOfDay()));
165 assertEquals(0, test.get(ISOChronology.getInstance().secondOfMinute()));
166 assertEquals(60 * 60, test.get(ISOChronology.getInstance().secondOfDay()));
167 assertEquals(0, test.get(ISOChronology.getInstance().millisOfSecond()));
168 assertEquals(60 * 60 * 1000, test.get(ISOChronology.getInstance().millisOfDay()));
169 try {
170 test.get((DateTimeField) null);
171 fail();
172 } catch (IllegalArgumentException ex) {}
173 }
174
175 public void testGetMethods() {
176 Instant test = new Instant();
177
178 assertEquals(ISOChronology.getInstanceUTC(), test.getChronology());
179 assertEquals(DateTimeZone.UTC, test.getZone());
180 assertEquals(TEST_TIME_NOW, test.getMillis());
181 }
182
183 public void testEqualsHashCode() {
184 Instant test1 = new Instant(TEST_TIME1);
185 Instant test2 = new Instant(TEST_TIME1);
186 assertEquals(true, test1.equals(test2));
187 assertEquals(true, test2.equals(test1));
188 assertEquals(true, test1.equals(test1));
189 assertEquals(true, test2.equals(test2));
190 assertEquals(true, test1.hashCode() == test2.hashCode());
191 assertEquals(true, test1.hashCode() == test1.hashCode());
192 assertEquals(true, test2.hashCode() == test2.hashCode());
193
194 Instant test3 = new Instant(TEST_TIME2);
195 assertEquals(false, test1.equals(test3));
196 assertEquals(false, test2.equals(test3));
197 assertEquals(false, test3.equals(test1));
198 assertEquals(false, test3.equals(test2));
199 assertEquals(false, test1.hashCode() == test3.hashCode());
200 assertEquals(false, test2.hashCode() == test3.hashCode());
201
202 assertEquals(false, test1.equals("Hello"));
203 assertEquals(true, test1.equals(new MockInstant()));
204 assertEquals(false, test1.equals(new DateTime(TEST_TIME1)));
205 }
206
207 class MockInstant extends AbstractInstant {
208 public String toString() {
209 return null;
210 }
211 public long getMillis() {
212 return TEST_TIME1;
213 }
214 public Chronology getChronology() {
215 return ISOChronology.getInstanceUTC();
216 }
217 }
218
219 public void testCompareTo() {
220 Instant test1 = new Instant(TEST_TIME1);
221 Instant test1a = new Instant(TEST_TIME1);
222 assertEquals(0, test1.compareTo(test1a));
223 assertEquals(0, test1a.compareTo(test1));
224 assertEquals(0, test1.compareTo(test1));
225 assertEquals(0, test1a.compareTo(test1a));
226
227 Instant test2 = new Instant(TEST_TIME2);
228 assertEquals(-1, test1.compareTo(test2));
229 assertEquals(+1, test2.compareTo(test1));
230
231 DateTime test3 = new DateTime(TEST_TIME2, GregorianChronology.getInstance(PARIS));
232 assertEquals(-1, test1.compareTo(test3));
233 assertEquals(+1, test3.compareTo(test1));
234 assertEquals(0, test3.compareTo(test2));
235
236 assertEquals(+1, test2.compareTo(new MockInstant()));
237 assertEquals(0, test1.compareTo(new MockInstant()));
238
239 try {
240 test1.compareTo(null);
241 fail();
242 } catch (NullPointerException ex) {}
243 // try {
244 // test1.compareTo(new Date());
245 // fail();
246 // } catch (ClassCastException ex) {}
247 }
248
249 //-----------------------------------------------------------------------
250 public void testIsEqual_long() {
251 assertEquals(false, new Instant(TEST_TIME1).isEqual(TEST_TIME2));
252 assertEquals(true, new Instant(TEST_TIME1).isEqual(TEST_TIME1));
253 assertEquals(false, new Instant(TEST_TIME2).isEqual(TEST_TIME1));
254 }
255
256 public void testIsEqualNow() {
257 assertEquals(false, new Instant(TEST_TIME_NOW - 1).isEqualNow());
258 assertEquals(true, new Instant(TEST_TIME_NOW).isEqualNow());
259 assertEquals(false, new Instant(TEST_TIME_NOW + 1).isEqualNow());
260 }
261
262 public void testIsEqual_RI() {
263 Instant test1 = new Instant(TEST_TIME1);
264 Instant test1a = new Instant(TEST_TIME1);
265 assertEquals(true, test1.isEqual(test1a));
266 assertEquals(true, test1a.isEqual(test1));
267 assertEquals(true, test1.isEqual(test1));
268 assertEquals(true, test1a.isEqual(test1a));
269
270 Instant test2 = new Instant(TEST_TIME2);
271 assertEquals(false, test1.isEqual(test2));
272 assertEquals(false, test2.isEqual(test1));
273
274 DateTime test3 = new DateTime(TEST_TIME2, GregorianChronology.getInstance(PARIS));
275 assertEquals(false, test1.isEqual(test3));
276 assertEquals(false, test3.isEqual(test1));
277 assertEquals(true, test3.isEqual(test2));
278
279 assertEquals(false, test2.isEqual(new MockInstant()));
280 assertEquals(true, test1.isEqual(new MockInstant()));
281
282 assertEquals(false, new Instant(TEST_TIME_NOW + 1).isEqual(null));
283 assertEquals(true, new Instant(TEST_TIME_NOW).isEqual(null));
284 assertEquals(false, new Instant(TEST_TIME_NOW - 1).isEqual(null));
285 }
286
287 //-----------------------------------------------------------------------
288 public void testIsBefore_long() {
289 assertEquals(true, new Instant(TEST_TIME1).isBefore(TEST_TIME2));
290 assertEquals(false, new Instant(TEST_TIME1).isBefore(TEST_TIME1));
291 assertEquals(false, new Instant(TEST_TIME2).isBefore(TEST_TIME1));
292 }
293
294 public void testIsBeforeNow() {
295 assertEquals(true, new Instant(TEST_TIME_NOW - 1).isBeforeNow());
296 assertEquals(false, new Instant(TEST_TIME_NOW).isBeforeNow());
297 assertEquals(false, new Instant(TEST_TIME_NOW + 1).isBeforeNow());
298 }
299
300 public void testIsBefore_RI() {
301 Instant test1 = new Instant(TEST_TIME1);
302 Instant test1a = new Instant(TEST_TIME1);
303 assertEquals(false, test1.isBefore(test1a));
304 assertEquals(false, test1a.isBefore(test1));
305 assertEquals(false, test1.isBefore(test1));
306 assertEquals(false, test1a.isBefore(test1a));
307
308 Instant test2 = new Instant(TEST_TIME2);
309 assertEquals(true, test1.isBefore(test2));
310 assertEquals(false, test2.isBefore(test1));
311
312 DateTime test3 = new DateTime(TEST_TIME2, GregorianChronology.getInstance(PARIS));
313 assertEquals(true, test1.isBefore(test3));
314 assertEquals(false, test3.isBefore(test1));
315 assertEquals(false, test3.isBefore(test2));
316
317 assertEquals(false, test2.isBefore(new MockInstant()));
318 assertEquals(false, test1.isBefore(new MockInstant()));
319
320 assertEquals(false, new Instant(TEST_TIME_NOW + 1).isBefore(null));
321 assertEquals(false, new Instant(TEST_TIME_NOW).isBefore(null));
322 assertEquals(true, new Instant(TEST_TIME_NOW - 1).isBefore(null));
323 }
324
325 //-----------------------------------------------------------------------
326 public void testIsAfter_long() {
327 assertEquals(false, new Instant(TEST_TIME1).isAfter(TEST_TIME2));
328 assertEquals(false, new Instant(TEST_TIME1).isAfter(TEST_TIME1));
329 assertEquals(true, new Instant(TEST_TIME2).isAfter(TEST_TIME1));
330 }
331
332 public void testIsAfterNow() {
333 assertEquals(false, new Instant(TEST_TIME_NOW - 1).isAfterNow());
334 assertEquals(false, new Instant(TEST_TIME_NOW).isAfterNow());
335 assertEquals(true, new Instant(TEST_TIME_NOW + 1).isAfterNow());
336 }
337
338 public void testIsAfter_RI() {
339 Instant test1 = new Instant(TEST_TIME1);
340 Instant test1a = new Instant(TEST_TIME1);
341 assertEquals(false, test1.isAfter(test1a));
342 assertEquals(false, test1a.isAfter(test1));
343 assertEquals(false, test1.isAfter(test1));
344 assertEquals(false, test1a.isAfter(test1a));
345
346 Instant test2 = new Instant(TEST_TIME2);
347 assertEquals(false, test1.isAfter(test2));
348 assertEquals(true, test2.isAfter(test1));
349
350 DateTime test3 = new DateTime(TEST_TIME2, GregorianChronology.getInstance(PARIS));
351 assertEquals(false, test1.isAfter(test3));
352 assertEquals(true, test3.isAfter(test1));
353 assertEquals(false, test3.isAfter(test2));
354
355 assertEquals(true, test2.isAfter(new MockInstant()));
356 assertEquals(false, test1.isAfter(new MockInstant()));
357
358 assertEquals(true, new Instant(TEST_TIME_NOW + 1).isAfter(null));
359 assertEquals(false, new Instant(TEST_TIME_NOW).isAfter(null));
360 assertEquals(false, new Instant(TEST_TIME_NOW - 1).isAfter(null));
361 }
362
363 //-----------------------------------------------------------------------
364 public void testSerialization() throws Exception {
365 Instant test = new Instant(TEST_TIME_NOW);
366
367 ByteArrayOutputStream baos = new ByteArrayOutputStream();
368 ObjectOutputStream oos = new ObjectOutputStream(baos);
369 oos.writeObject(test);
370 byte[] bytes = baos.toByteArray();
371 oos.close();
372
373 ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
374 ObjectInputStream ois = new ObjectInputStream(bais);
375 Instant result = (Instant) ois.readObject();
376 ois.close();
377
378 assertEquals(test, result);
379 }
380
381 //-----------------------------------------------------------------------
382 public void testToString() {
383 Instant test = new Instant(TEST_TIME_NOW);
384 assertEquals("2002-06-09T00:00:00.000Z", test.toString());
385 }
386
387 //-----------------------------------------------------------------------
388 public void testToInstant() {
389 Instant test = new Instant(TEST_TIME1);
390 Instant result = test.toInstant();
391 assertSame(test, result);
392 }
393
394 public void testToDateTime() {
395 Instant test = new Instant(TEST_TIME1);
396 DateTime result = test.toDateTime();
397 assertEquals(TEST_TIME1, result.getMillis());
398 assertEquals(ISOChronology.getInstance(), result.getChronology());
399 }
400
401 public void testToDateTimeISO() {
402 Instant test = new Instant(TEST_TIME1);
403 DateTime result = test.toDateTimeISO();
404 assertSame(DateTime.class, result.getClass());
405 assertSame(ISOChronology.class, result.getChronology().getClass());
406 assertEquals(test.getMillis(), result.getMillis());
407 assertEquals(ISOChronology.getInstance(), result.getChronology());
408 }
409
410 public void testToDateTime_DateTimeZone() {
411 Instant test = new Instant(TEST_TIME1);
412 DateTime result = test.toDateTime(LONDON);
413 assertEquals(test.getMillis(), result.getMillis());
414 assertEquals(ISOChronology.getInstance(LONDON), result.getChronology());
415
416 test = new Instant(TEST_TIME1);
417 result = test.toDateTime(PARIS);
418 assertEquals(test.getMillis(), result.getMillis());
419 assertEquals(ISOChronology.getInstance(PARIS), result.getChronology());
420
421 test = new Instant(TEST_TIME1);
422 result = test.toDateTime((DateTimeZone) null);
423 assertEquals(test.getMillis(), result.getMillis());
424 assertEquals(ISOChronology.getInstance(), result.getChronology());
425 }
426
427 public void testToDateTime_Chronology() {
428 Instant test = new Instant(TEST_TIME1);
429 DateTime result = test.toDateTime(ISOChronology.getInstance());
430 assertEquals(test.getMillis(), result.getMillis());
431 assertEquals(ISOChronology.getInstance(), result.getChronology());
432
433 test = new Instant(TEST_TIME1);
434 result = test.toDateTime(GregorianChronology.getInstance(PARIS));
435 assertEquals(test.getMillis(), result.getMillis());
436 assertEquals(GregorianChronology.getInstance(PARIS), result.getChronology());
437
438 test = new Instant(TEST_TIME1);
439 result = test.toDateTime((Chronology) null);
440 assertEquals(ISOChronology.getInstance(), result.getChronology());
441 }
442
443 public void testToMutableDateTime() {
444 Instant test = new Instant(TEST_TIME1);
445 MutableDateTime result = test.toMutableDateTime();
446 assertEquals(test.getMillis(), result.getMillis());
447 assertEquals(ISOChronology.getInstance(), result.getChronology());
448 }
449
450 public void testToMutableDateTimeISO() {
451 Instant test = new Instant(TEST_TIME1);
452 MutableDateTime result = test.toMutableDateTimeISO();
453 assertSame(MutableDateTime.class, result.getClass());
454 assertSame(ISOChronology.class, result.getChronology().getClass());
455 assertEquals(test.getMillis(), result.getMillis());
456 assertEquals(ISOChronology.getInstance(), result.getChronology());
457 }
458
459 public void testToMutableDateTime_DateTimeZone() {
460 Instant test = new Instant(TEST_TIME1);
461 MutableDateTime result = test.toMutableDateTime(LONDON);
462 assertEquals(test.getMillis(), result.getMillis());
463 assertEquals(ISOChronology.getInstance(), result.getChronology());
464
465 test = new Instant(TEST_TIME1);
466 result = test.toMutableDateTime(PARIS);
467 assertEquals(test.getMillis(), result.getMillis());
468 assertEquals(ISOChronology.getInstance(PARIS), result.getChronology());
469
470 test = new Instant(TEST_TIME1);
471 result = test.toMutableDateTime((DateTimeZone) null);
472 assertEquals(test.getMillis(), result.getMillis());
473 assertEquals(ISOChronology.getInstance(), result.getChronology());
474 }
475
476 public void testToMutableDateTime_Chronology() {
477 Instant test = new Instant(TEST_TIME1);
478 MutableDateTime result = test.toMutableDateTime(ISOChronology.getInstance());
479 assertEquals(test.getMillis(), result.getMillis());
480 assertEquals(ISOChronology.getInstance(), result.getChronology());
481
482 test = new Instant(TEST_TIME1);
483 result = test.toMutableDateTime(GregorianChronology.getInstance(PARIS));
484 assertEquals(test.getMillis(), result.getMillis());
485 assertEquals(GregorianChronology.getInstance(PARIS), result.getChronology());
486
487 test = new Instant(TEST_TIME1);
488 result = test.toMutableDateTime((Chronology) null);
489 assertEquals(test.getMillis(), result.getMillis());
490 assertEquals(ISOChronology.getInstance(), result.getChronology());
491 }
492
493 public void testToDate() {
494 Instant test = new Instant(TEST_TIME1);
495 Date result = test.toDate();
496 assertEquals(test.getMillis(), result.getTime());
497 }
498
499 //-----------------------------------------------------------------------
500 public void testWithMillis_long() {
501 Instant test = new Instant(TEST_TIME1);
502 Instant result = test.withMillis(TEST_TIME2);
503 assertEquals(TEST_TIME2, result.getMillis());
504 assertEquals(test.getChronology(), result.getChronology());
505
506 test = new Instant(TEST_TIME1);
507 result = test.withMillis(TEST_TIME1);
508 assertSame(test, result);
509 }
510
511 //-----------------------------------------------------------------------
512 public void testWithDurationAdded_long_int() {
513 Instant test = new Instant(TEST_TIME1);
514 Instant result = test.withDurationAdded(123456789L, 1);
515 Instant expected = new Instant(TEST_TIME1 + 123456789L);
516 assertEquals(expected, result);
517
518 result = test.withDurationAdded(123456789L, 0);
519 assertSame(test, result);
520
521 result = test.withDurationAdded(123456789L, 2);
522 expected = new Instant(TEST_TIME1 + (2L * 123456789L));
523 assertEquals(expected, result);
524
525 result = test.withDurationAdded(123456789L, -3);
526 expected = new Instant(TEST_TIME1 - (3L * 123456789L));
527 assertEquals(expected, result);
528 }
529
530 //-----------------------------------------------------------------------
531 public void testWithDurationAdded_RD_int() {
532 Instant test = new Instant(TEST_TIME1);
533 Instant result = test.withDurationAdded(new Duration(123456789L), 1);
534 Instant expected = new Instant(TEST_TIME1 + 123456789L);
535 assertEquals(expected, result);
536
537 result = test.withDurationAdded(null, 1);
538 assertSame(test, result);
539
540 result = test.withDurationAdded(new Duration(123456789L), 0);
541 assertSame(test, result);
542
543 result = test.withDurationAdded(new Duration(123456789L), 2);
544 expected = new Instant(TEST_TIME1 + (2L * 123456789L));
545 assertEquals(expected, result);
546
547 result = test.withDurationAdded(new Duration(123456789L), -3);
548 expected = new Instant(TEST_TIME1 - (3L * 123456789L));
549 assertEquals(expected, result);
550 }
551
552 //-----------------------------------------------------------------------
553 public void testPlus_long() {
554 Instant test = new Instant(TEST_TIME1);
555 Instant result = test.plus(123456789L);
556 Instant expected = new Instant(TEST_TIME1 + 123456789L);
557 assertEquals(expected, result);
558 }
559
560 public void testPlus_RD() {
561 Instant test = new Instant(TEST_TIME1);
562 Instant result = test.plus(new Duration(123456789L));
563 Instant expected = new Instant(TEST_TIME1 + 123456789L);
564 assertEquals(expected, result);
565
566 result = test.plus((ReadableDuration) null);
567 assertSame(test, result);
568 }
569
570 //-----------------------------------------------------------------------
571 public void testMinus_long() {
572 Instant test = new Instant(TEST_TIME1);
573 Instant result = test.minus(123456789L);
574 Instant expected = new Instant(TEST_TIME1 - 123456789L);
575 assertEquals(expected, result);
576 }
577
578 public void testMinus_RD() {
579 Instant test = new Instant(TEST_TIME1);
580 Instant result = test.minus(new Duration(123456789L));
581 Instant expected = new Instant(TEST_TIME1 - 123456789L);
582 assertEquals(expected, result);
583
584 result = test.minus((ReadableDuration) null);
585 assertSame(test, result);
586 }
587
588 //-----------------------------------------------------------------------
589 public void testImmutable() {
590 assertTrue(Modifier.isFinal(Instant.class.getModifiers()));
591 }
592
593 }