001 /*
002 * Copyright 2001-2011 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.util.Locale;
023 import java.util.TimeZone;
024
025 import junit.framework.TestCase;
026 import junit.framework.TestSuite;
027
028 import org.joda.time.base.AbstractInterval;
029 import org.joda.time.chrono.BuddhistChronology;
030 import org.joda.time.chrono.CopticChronology;
031 import org.joda.time.chrono.GJChronology;
032 import org.joda.time.chrono.ISOChronology;
033 import org.joda.time.chrono.LenientChronology;
034
035 /**
036 * This class is a Junit unit test for Instant.
037 *
038 * @author Stephen Colebourne
039 */
040 public class TestInterval_Basics extends TestCase {
041 // Test in 2002/03 as time zones are more well known
042 // (before the late 90's they were all over the place)
043
044 private static final DateTimeZone MOSCOW = DateTimeZone.forID("Europe/Moscow");
045 private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris");
046 private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London");
047 private static final Chronology COPTIC_PARIS = CopticChronology.getInstance(PARIS);
048 private Interval interval37;
049 private Interval interval33;
050
051 long y2002days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
052 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 +
053 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
054 366 + 365;
055 long y2003days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
056 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 +
057 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
058 366 + 365 + 365;
059
060 // 2002-06-09
061 private long TEST_TIME_NOW =
062 (y2002days + 31L + 28L + 31L + 30L + 31L + 9L -1L) * DateTimeConstants.MILLIS_PER_DAY;
063
064 // 2002-04-05
065 private long TEST_TIME1 =
066 (y2002days + 31L + 28L + 31L + 5L -1L) * DateTimeConstants.MILLIS_PER_DAY
067 + 12L * DateTimeConstants.MILLIS_PER_HOUR
068 + 24L * DateTimeConstants.MILLIS_PER_MINUTE;
069
070 // 2003-05-06
071 private long TEST_TIME2 =
072 (y2003days + 31L + 28L + 31L + 30L + 6L -1L) * DateTimeConstants.MILLIS_PER_DAY
073 + 14L * DateTimeConstants.MILLIS_PER_HOUR
074 + 28L * DateTimeConstants.MILLIS_PER_MINUTE;
075
076 private DateTimeZone originalDateTimeZone = null;
077 private TimeZone originalTimeZone = null;
078 private Locale originalLocale = null;
079
080 public static void main(String[] args) {
081 junit.textui.TestRunner.run(suite());
082 }
083
084 public static TestSuite suite() {
085 return new TestSuite(TestInterval_Basics.class);
086 }
087
088 public TestInterval_Basics(String name) {
089 super(name);
090 }
091
092 protected void setUp() throws Exception {
093 DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW);
094 originalDateTimeZone = DateTimeZone.getDefault();
095 originalTimeZone = TimeZone.getDefault();
096 originalLocale = Locale.getDefault();
097 DateTimeZone.setDefault(PARIS);
098 TimeZone.setDefault(PARIS.toTimeZone());
099 Locale.setDefault(Locale.FRANCE);
100 interval37 = new Interval(3, 7);
101 interval33 = new Interval(3, 3);
102 }
103
104 protected void tearDown() throws Exception {
105 DateTimeUtils.setCurrentMillisSystem();
106 DateTimeZone.setDefault(originalDateTimeZone);
107 TimeZone.setDefault(originalTimeZone);
108 Locale.setDefault(originalLocale);
109 originalDateTimeZone = null;
110 originalTimeZone = null;
111 originalLocale = null;
112 }
113
114 //-----------------------------------------------------------------------
115 public void testTest() {
116 assertEquals("2002-06-09T00:00:00.000Z", new Instant(TEST_TIME_NOW).toString());
117 assertEquals("2002-04-05T12:24:00.000Z", new Instant(TEST_TIME1).toString());
118 assertEquals("2003-05-06T14:28:00.000Z", new Instant(TEST_TIME2).toString());
119 }
120
121 //-----------------------------------------------------------------------
122 public void testGetMillis() {
123 Interval test = new Interval(TEST_TIME1, TEST_TIME2);
124 assertEquals(TEST_TIME1, test.getStartMillis());
125 assertEquals(TEST_TIME1, test.getStart().getMillis());
126 assertEquals(TEST_TIME2, test.getEndMillis());
127 assertEquals(TEST_TIME2, test.getEnd().getMillis());
128 assertEquals(TEST_TIME2 - TEST_TIME1, test.toDurationMillis());
129 assertEquals(TEST_TIME2 - TEST_TIME1, test.toDuration().getMillis());
130 }
131
132 public void testGetDuration1() {
133 Interval test = new Interval(TEST_TIME1, TEST_TIME2);
134 assertEquals(TEST_TIME2 - TEST_TIME1, test.toDurationMillis());
135 assertEquals(TEST_TIME2 - TEST_TIME1, test.toDuration().getMillis());
136 }
137
138 public void testGetDuration2() {
139 Interval test = new Interval(TEST_TIME1, TEST_TIME1);
140 assertSame(Duration.ZERO, test.toDuration());
141 }
142
143 public void testEqualsHashCode() {
144 Interval test1 = new Interval(TEST_TIME1, TEST_TIME2);
145 Interval test2 = new Interval(TEST_TIME1, TEST_TIME2);
146 assertEquals(true, test1.equals(test2));
147 assertEquals(true, test2.equals(test1));
148 assertEquals(true, test1.equals(test1));
149 assertEquals(true, test2.equals(test2));
150 assertEquals(true, test1.hashCode() == test2.hashCode());
151 assertEquals(true, test1.hashCode() == test1.hashCode());
152 assertEquals(true, test2.hashCode() == test2.hashCode());
153
154 Interval test3 = new Interval(TEST_TIME_NOW, TEST_TIME2);
155 assertEquals(false, test1.equals(test3));
156 assertEquals(false, test2.equals(test3));
157 assertEquals(false, test3.equals(test1));
158 assertEquals(false, test3.equals(test2));
159 assertEquals(false, test1.hashCode() == test3.hashCode());
160 assertEquals(false, test2.hashCode() == test3.hashCode());
161
162 Interval test4 = new Interval(TEST_TIME1, TEST_TIME2, GJChronology.getInstance());
163 assertEquals(true, test4.equals(test4));
164 assertEquals(false, test1.equals(test4));
165 assertEquals(false, test2.equals(test4));
166 assertEquals(false, test4.equals(test1));
167 assertEquals(false, test4.equals(test2));
168 assertEquals(false, test1.hashCode() == test4.hashCode());
169 assertEquals(false, test2.hashCode() == test4.hashCode());
170
171 MutableInterval test5 = new MutableInterval(TEST_TIME1, TEST_TIME2);
172 assertEquals(true, test1.equals(test5));
173 assertEquals(true, test2.equals(test5));
174 assertEquals(false, test3.equals(test5));
175 assertEquals(true, test5.equals(test1));
176 assertEquals(true, test5.equals(test2));
177 assertEquals(false, test5.equals(test3));
178 assertEquals(true, test1.hashCode() == test5.hashCode());
179 assertEquals(true, test2.hashCode() == test5.hashCode());
180 assertEquals(false, test3.hashCode() == test5.hashCode());
181
182 assertEquals(false, test1.equals("Hello"));
183 assertEquals(true, test1.equals(new MockInterval()));
184 assertEquals(false, test1.equals(new DateTime(TEST_TIME1)));
185 }
186
187 class MockInterval extends AbstractInterval {
188 public MockInterval() {
189 super();
190 }
191 public Chronology getChronology() {
192 return ISOChronology.getInstance();
193 }
194 public long getStartMillis() {
195 return TEST_TIME1;
196 }
197 public long getEndMillis() {
198 return TEST_TIME2;
199 }
200 }
201
202 public void testEqualsHashCodeLenient() {
203 Interval test1 = new Interval(
204 new DateTime(TEST_TIME1, LenientChronology.getInstance(COPTIC_PARIS)),
205 new DateTime(TEST_TIME2, LenientChronology.getInstance(COPTIC_PARIS)));
206 Interval test2 = new Interval(
207 new DateTime(TEST_TIME1, LenientChronology.getInstance(COPTIC_PARIS)),
208 new DateTime(TEST_TIME2, LenientChronology.getInstance(COPTIC_PARIS)));
209 assertEquals(true, test1.equals(test2));
210 assertEquals(true, test2.equals(test1));
211 assertEquals(true, test1.equals(test1));
212 assertEquals(true, test2.equals(test2));
213 assertEquals(true, test1.hashCode() == test2.hashCode());
214 assertEquals(true, test1.hashCode() == test1.hashCode());
215 assertEquals(true, test2.hashCode() == test2.hashCode());
216 }
217
218 public void testEqualsHashCodeStrict() {
219 Interval test1 = new Interval(
220 new DateTime(TEST_TIME1, LenientChronology.getInstance(COPTIC_PARIS)),
221 new DateTime(TEST_TIME2, LenientChronology.getInstance(COPTIC_PARIS)));
222 Interval test2 = new Interval(
223 new DateTime(TEST_TIME1, LenientChronology.getInstance(COPTIC_PARIS)),
224 new DateTime(TEST_TIME2, LenientChronology.getInstance(COPTIC_PARIS)));
225 assertEquals(true, test1.equals(test2));
226 assertEquals(true, test2.equals(test1));
227 assertEquals(true, test1.equals(test1));
228 assertEquals(true, test2.equals(test2));
229 assertEquals(true, test1.hashCode() == test2.hashCode());
230 assertEquals(true, test1.hashCode() == test1.hashCode());
231 assertEquals(true, test2.hashCode() == test2.hashCode());
232 }
233
234 //-----------------------------------------------------------------------
235 public void test_useCase_ContainsOverlapAbutGap() {
236 // this is a simple test to ensure that the use case of these methods is OK
237 // when comparing any two intervals they can be in one and only one of these states
238 // (a) have a gap between them, (b) abut or (c) overlap
239 // contains is a subset of overlap
240 Interval test1020 = new Interval(10, 20);
241
242 // [4,8) [10,20) - gap
243 Interval interval = new Interval(4, 8);
244 assertNotNull(test1020.gap(interval));
245 assertEquals(false, test1020.abuts(interval));
246 assertEquals(false, test1020.overlaps(interval));
247 assertEquals(false, test1020.contains(interval));
248 assertNotNull(interval.gap(test1020));
249 assertEquals(false, interval.abuts(test1020));
250 assertEquals(false, interval.overlaps(test1020));
251 assertEquals(false, interval.contains(test1020));
252
253 // [6,10) [10,20) - abuts
254 interval = new Interval(6, 10);
255 assertNull(test1020.gap(interval));
256 assertEquals(true, test1020.abuts(interval));
257 assertEquals(false, test1020.overlaps(interval));
258 assertEquals(false, test1020.contains(interval));
259 assertNull(interval.gap(test1020));
260 assertEquals(true, interval.abuts(test1020));
261 assertEquals(false, interval.overlaps(test1020));
262 assertEquals(false, interval.contains(test1020));
263
264 // [8,12) [10,20) - overlaps
265 interval = new Interval(8, 12);
266 assertNull(test1020.gap(interval));
267 assertEquals(false, test1020.abuts(interval));
268 assertEquals(true, test1020.overlaps(interval));
269 assertEquals(false, test1020.contains(interval));
270 assertNull(interval.gap(test1020));
271 assertEquals(false, interval.abuts(test1020));
272 assertEquals(true, interval.overlaps(test1020));
273 assertEquals(false, interval.contains(test1020));
274
275 // [10,14) [10,20) - overlaps and contains-one-way
276 interval = new Interval(10, 14);
277 assertNull(test1020.gap(interval));
278 assertEquals(false, test1020.abuts(interval));
279 assertEquals(true, test1020.overlaps(interval));
280 assertEquals(true, test1020.contains(interval));
281 assertNull(interval.gap(test1020));
282 assertEquals(false, interval.abuts(test1020));
283 assertEquals(true, interval.overlaps(test1020));
284 assertEquals(false, interval.contains(test1020));
285
286 // [10,20) [10,20) - overlaps and contains-both-ways
287 assertNull(test1020.gap(interval));
288 assertEquals(false, test1020.abuts(test1020));
289 assertEquals(true, test1020.overlaps(test1020));
290 assertEquals(true, test1020.contains(test1020));
291
292 // [10,20) [16,20) - overlaps and contains-one-way
293 interval = new Interval(16, 20);
294 assertNull(test1020.gap(interval));
295 assertEquals(false, test1020.abuts(interval));
296 assertEquals(true, test1020.overlaps(interval));
297 assertEquals(true, test1020.contains(interval));
298 assertNull(interval.gap(test1020));
299 assertEquals(false, interval.abuts(test1020));
300 assertEquals(true, interval.overlaps(test1020));
301 assertEquals(false, interval.contains(test1020));
302
303 // [10,20) [18,22) - overlaps
304 interval = new Interval(18, 22);
305 assertNull(test1020.gap(interval));
306 assertEquals(false, test1020.abuts(interval));
307 assertEquals(true, test1020.overlaps(interval));
308 assertEquals(false, test1020.contains(interval));
309 assertNull(interval.gap(test1020));
310 assertEquals(false, interval.abuts(test1020));
311 assertEquals(true, interval.overlaps(test1020));
312 assertEquals(false, interval.contains(test1020));
313
314 // [10,20) [20,24) - abuts
315 interval = new Interval(20, 24);
316 assertNull(test1020.gap(interval));
317 assertEquals(true, test1020.abuts(interval));
318 assertEquals(false, test1020.overlaps(interval));
319 assertEquals(false, test1020.contains(interval));
320 assertNull(interval.gap(test1020));
321 assertEquals(true, interval.abuts(test1020));
322 assertEquals(false, interval.overlaps(test1020));
323 assertEquals(false, interval.contains(test1020));
324
325 // [10,20) [22,26) - gap
326 interval = new Interval(22, 26);
327 assertNotNull(test1020.gap(interval));
328 assertEquals(false, test1020.abuts(interval));
329 assertEquals(false, test1020.overlaps(interval));
330 assertEquals(false, test1020.contains(interval));
331 assertNotNull(interval.gap(test1020));
332 assertEquals(false, interval.abuts(test1020));
333 assertEquals(false, interval.overlaps(test1020));
334 assertEquals(false, interval.contains(test1020));
335 }
336
337 //-----------------------------------------------------------------------
338 public void test_useCase_ContainsOverlapAbutGap_zeroDuration() {
339 // this is a simple test to ensure that the use case of these methods
340 // is OK when considering a zero duration inerval
341 // when comparing any two intervals they can be in one and only one of these states
342 // (a) have a gap between them, (b) abut or (c) overlap
343 // contains is a subset of overlap
344 Interval test1020 = new Interval(10, 20);
345
346 // [8,8) [10,20) - gap
347 Interval interval = new Interval(8, 8);
348 assertNotNull(test1020.gap(interval));
349 assertEquals(false, test1020.abuts(interval));
350 assertEquals(false, test1020.overlaps(interval));
351 assertEquals(false, test1020.contains(interval));
352 assertNotNull(interval.gap(test1020));
353 assertEquals(false, interval.abuts(test1020));
354 assertEquals(false, interval.overlaps(test1020));
355 assertEquals(false, interval.contains(test1020));
356
357 // [10,10) [10,20) - abuts and contains-one-way
358 interval = new Interval(10, 10);
359 assertNull(test1020.gap(interval));
360 assertEquals(true, test1020.abuts(interval));
361 assertEquals(false, test1020.overlaps(interval)); // abuts, so can't overlap
362 assertEquals(true, test1020.contains(interval)); // normal contains zero-duration
363 assertNull(interval.gap(test1020));
364 assertEquals(true, interval.abuts(test1020));
365 assertEquals(false, interval.overlaps(test1020)); // abuts, so can't overlap
366 assertEquals(false, interval.contains(test1020)); // zero-duration does not contain normal
367
368 // [12,12) [10,20) - contains-one-way and overlaps
369 interval = new Interval(12, 12);
370 assertNull(test1020.gap(interval));
371 assertEquals(false, test1020.abuts(interval));
372 assertEquals(true, test1020.overlaps(interval));
373 assertEquals(true, test1020.contains(interval)); // normal contains zero-duration
374 assertNull(interval.gap(test1020));
375 assertEquals(false, interval.abuts(test1020));
376 assertEquals(true, interval.overlaps(test1020));
377 assertEquals(false, interval.contains(test1020)); // zero-duration does not contain normal
378
379 // [10,20) [20,20) - abuts
380 interval = new Interval(20, 20);
381 assertNull(test1020.gap(interval));
382 assertEquals(true, test1020.abuts(interval));
383 assertEquals(false, test1020.overlaps(interval));
384 assertEquals(false, test1020.contains(interval));
385 assertNull(interval.gap(test1020));
386 assertEquals(true, interval.abuts(test1020));
387 assertEquals(false, interval.overlaps(test1020));
388 assertEquals(false, interval.contains(test1020));
389
390 // [10,20) [22,22) - gap
391 interval = new Interval(22, 22);
392 assertNotNull(test1020.gap(interval));
393 assertEquals(false, test1020.abuts(interval));
394 assertEquals(false, test1020.overlaps(interval));
395 assertEquals(false, test1020.contains(interval));
396 assertNotNull(interval.gap(test1020));
397 assertEquals(false, interval.abuts(test1020));
398 assertEquals(false, interval.overlaps(test1020));
399 assertEquals(false, interval.contains(test1020));
400 }
401
402 //-----------------------------------------------------------------------
403 public void test_useCase_ContainsOverlapAbutGap_bothZeroDuration() {
404 // this is a simple test to ensure that the use case of these methods
405 // is OK when considering two zero duration inervals
406 // this is the simplest case, as the two intervals either have a gap or not
407 // if not, then they are equal and abut
408 Interval test0808 = new Interval(8, 8);
409 Interval test1010 = new Interval(10, 10);
410
411 // [8,8) [10,10) - gap
412 assertNotNull(test1010.gap(test0808));
413 assertEquals(false, test1010.abuts(test0808));
414 assertEquals(false, test1010.overlaps(test0808));
415 assertEquals(false, test1010.contains(test0808));
416 assertNotNull(test0808.gap(test1010));
417 assertEquals(false, test0808.abuts(test1010));
418 assertEquals(false, test0808.overlaps(test1010));
419 assertEquals(false, test0808.contains(test1010));
420
421 // [10,10) [10,10) - abuts
422 assertNull(test1010.gap(test1010));
423 assertEquals(true, test1010.abuts(test1010));
424 assertEquals(false, test1010.overlaps(test1010));
425 assertEquals(false, test1010.contains(test1010));
426 }
427
428 //-----------------------------------------------------------------------
429 public void testContains_long() {
430 assertEquals(false, interval37.contains(2)); // value before
431 assertEquals(true, interval37.contains(3));
432 assertEquals(true, interval37.contains(4));
433 assertEquals(true, interval37.contains(5));
434 assertEquals(true, interval37.contains(6));
435 assertEquals(false, interval37.contains(7)); // value after
436 assertEquals(false, interval37.contains(8)); // value after
437 }
438
439 public void testContains_long_zeroDuration() {
440 assertEquals(false, interval33.contains(2)); // value before
441 assertEquals(false, interval33.contains(3)); // zero length duration contains nothing
442 assertEquals(false, interval33.contains(4)); // value after
443 }
444
445 //-----------------------------------------------------------------------
446 public void testContainsNow() {
447 DateTimeUtils.setCurrentMillisFixed(2);
448 assertEquals(false, interval37.containsNow()); // value before
449 DateTimeUtils.setCurrentMillisFixed(3);
450 assertEquals(true, interval37.containsNow());
451 DateTimeUtils.setCurrentMillisFixed(4);
452 assertEquals(true, interval37.containsNow());
453 DateTimeUtils.setCurrentMillisFixed(6);
454 assertEquals(true, interval37.containsNow());
455 DateTimeUtils.setCurrentMillisFixed(7);
456 assertEquals(false, interval37.containsNow()); // value after
457 DateTimeUtils.setCurrentMillisFixed(8);
458 assertEquals(false, interval37.containsNow()); // value after
459
460 DateTimeUtils.setCurrentMillisFixed(2);
461 assertEquals(false, interval33.containsNow()); // value before
462 DateTimeUtils.setCurrentMillisFixed(3);
463 assertEquals(false, interval33.containsNow()); // zero length duration contains nothing
464 DateTimeUtils.setCurrentMillisFixed(4);
465 assertEquals(false, interval33.containsNow()); // value after
466 }
467
468 //-----------------------------------------------------------------------
469 public void testContains_RI() {
470 assertEquals(false, interval37.contains(new Instant(2))); // value before
471 assertEquals(true, interval37.contains(new Instant(3)));
472 assertEquals(true, interval37.contains(new Instant(4)));
473 assertEquals(true, interval37.contains(new Instant(5)));
474 assertEquals(true, interval37.contains(new Instant(6)));
475 assertEquals(false, interval37.contains(new Instant(7))); // value after
476 assertEquals(false, interval37.contains(new Instant(8))); // value after
477 }
478
479 public void testContains_RI_null() {
480 DateTimeUtils.setCurrentMillisFixed(2);
481 assertEquals(false, interval37.contains((ReadableInstant) null)); // value before
482 DateTimeUtils.setCurrentMillisFixed(3);
483 assertEquals(true, interval37.contains((ReadableInstant) null));
484 DateTimeUtils.setCurrentMillisFixed(4);
485 assertEquals(true, interval37.contains((ReadableInstant) null));
486 DateTimeUtils.setCurrentMillisFixed(6);
487 assertEquals(true, interval37.contains((ReadableInstant) null));
488 DateTimeUtils.setCurrentMillisFixed(7);
489 assertEquals(false, interval37.contains((ReadableInstant) null)); // value after
490 DateTimeUtils.setCurrentMillisFixed(8);
491 assertEquals(false, interval37.contains((ReadableInstant) null)); // value after
492 }
493
494 public void testContains_RI_zeroDuration() {
495 assertEquals(false, interval33.contains(new Instant(2))); // value before
496 assertEquals(false, interval33.contains(new Instant(3))); // zero length duration contains nothing
497 assertEquals(false, interval33.contains(new Instant(4))); // value after
498 }
499
500 //-----------------------------------------------------------------------
501 public void testContains_RInterval() {
502 assertEquals(false, interval37.contains(new Interval(1, 2))); // gap before
503 assertEquals(false, interval37.contains(new Interval(2, 2))); // gap before
504
505 assertEquals(false, interval37.contains(new Interval(2, 3))); // abuts before
506 assertEquals(true, interval37.contains(new Interval(3, 3)));
507
508 assertEquals(false, interval37.contains(new Interval(2, 4))); // starts before
509 assertEquals(true, interval37.contains(new Interval(3, 4)));
510 assertEquals(true, interval37.contains(new Interval(4, 4)));
511
512 assertEquals(false, interval37.contains(new Interval(2, 6))); // starts before
513 assertEquals(true, interval37.contains(new Interval(3, 6)));
514 assertEquals(true, interval37.contains(new Interval(4, 6)));
515 assertEquals(true, interval37.contains(new Interval(5, 6)));
516 assertEquals(true, interval37.contains(new Interval(6, 6)));
517
518 assertEquals(false, interval37.contains(new Interval(2, 7))); // starts before
519 assertEquals(true, interval37.contains(new Interval(3, 7)));
520 assertEquals(true, interval37.contains(new Interval(4, 7)));
521 assertEquals(true, interval37.contains(new Interval(5, 7)));
522 assertEquals(true, interval37.contains(new Interval(6, 7)));
523 assertEquals(false, interval37.contains(new Interval(7, 7))); // abuts after
524
525 assertEquals(false, interval37.contains(new Interval(2, 8))); // ends after
526 assertEquals(false, interval37.contains(new Interval(3, 8))); // ends after
527 assertEquals(false, interval37.contains(new Interval(4, 8))); // ends after
528 assertEquals(false, interval37.contains(new Interval(5, 8))); // ends after
529 assertEquals(false, interval37.contains(new Interval(6, 8))); // ends after
530 assertEquals(false, interval37.contains(new Interval(7, 8))); // abuts after
531 assertEquals(false, interval37.contains(new Interval(8, 8))); // gap after
532
533 assertEquals(false, interval37.contains(new Interval(8, 9))); // gap after
534 assertEquals(false, interval37.contains(new Interval(9, 9))); // gap after
535 }
536
537 public void testContains_RInterval_null() {
538 DateTimeUtils.setCurrentMillisFixed(2);
539 assertEquals(false, interval37.contains((ReadableInterval) null)); // gap before
540 DateTimeUtils.setCurrentMillisFixed(3);
541 assertEquals(true, interval37.contains((ReadableInterval) null));
542 DateTimeUtils.setCurrentMillisFixed(4);
543 assertEquals(true, interval37.contains((ReadableInterval) null));
544 DateTimeUtils.setCurrentMillisFixed(6);
545 assertEquals(true, interval37.contains((ReadableInterval) null));
546 DateTimeUtils.setCurrentMillisFixed(7);
547 assertEquals(false, interval37.contains((ReadableInterval) null)); // abuts after
548 DateTimeUtils.setCurrentMillisFixed(8);
549 assertEquals(false, interval37.contains((ReadableInterval) null)); // gap after
550 }
551
552 public void testContains_RInterval_zeroDuration() {
553 assertEquals(false, interval33.contains(interval33)); // zero length duration contains nothing
554 assertEquals(false, interval33.contains(interval37)); // zero-duration cannot contain anything
555 assertEquals(true, interval37.contains(interval33));
556 assertEquals(false, interval33.contains(new Interval(1, 2))); // zero-duration cannot contain anything
557 assertEquals(false, interval33.contains(new Interval(8, 9))); // zero-duration cannot contain anything
558 assertEquals(false, interval33.contains(new Interval(1, 9))); // zero-duration cannot contain anything
559
560 DateTimeUtils.setCurrentMillisFixed(2);
561 assertEquals(false, interval33.contains((ReadableInterval) null)); // gap before
562 DateTimeUtils.setCurrentMillisFixed(3);
563 assertEquals(false, interval33.contains((ReadableInterval) null)); // zero length duration contains nothing
564 DateTimeUtils.setCurrentMillisFixed(4);
565 assertEquals(false, interval33.contains((ReadableInterval) null)); // gap after
566 }
567
568 //-----------------------------------------------------------------------
569 public void testOverlaps_RInterval() {
570 assertEquals(false, interval37.overlaps(new Interval(1, 2))); // gap before
571 assertEquals(false, interval37.overlaps(new Interval(2, 2))); // gap before
572
573 assertEquals(false, interval37.overlaps(new Interval(2, 3))); // abuts before
574 assertEquals(false, interval37.overlaps(new Interval(3, 3))); // abuts before
575
576 assertEquals(true, interval37.overlaps(new Interval(2, 4)));
577 assertEquals(true, interval37.overlaps(new Interval(3, 4)));
578 assertEquals(true, interval37.overlaps(new Interval(4, 4)));
579
580 assertEquals(true, interval37.overlaps(new Interval(2, 6)));
581 assertEquals(true, interval37.overlaps(new Interval(3, 6)));
582 assertEquals(true, interval37.overlaps(new Interval(4, 6)));
583 assertEquals(true, interval37.overlaps(new Interval(5, 6)));
584 assertEquals(true, interval37.overlaps(new Interval(6, 6)));
585
586 assertEquals(true, interval37.overlaps(new Interval(2, 7)));
587 assertEquals(true, interval37.overlaps(new Interval(3, 7)));
588 assertEquals(true, interval37.overlaps(new Interval(4, 7)));
589 assertEquals(true, interval37.overlaps(new Interval(5, 7)));
590 assertEquals(true, interval37.overlaps(new Interval(6, 7)));
591 assertEquals(false, interval37.overlaps(new Interval(7, 7))); // abuts after
592
593 assertEquals(true, interval37.overlaps(new Interval(2, 8)));
594 assertEquals(true, interval37.overlaps(new Interval(3, 8)));
595 assertEquals(true, interval37.overlaps(new Interval(4, 8)));
596 assertEquals(true, interval37.overlaps(new Interval(5, 8)));
597 assertEquals(true, interval37.overlaps(new Interval(6, 8)));
598 assertEquals(false, interval37.overlaps(new Interval(7, 8))); // abuts after
599 assertEquals(false, interval37.overlaps(new Interval(8, 8))); // gap after
600
601 assertEquals(false, interval37.overlaps(new Interval(8, 9))); // gap after
602 assertEquals(false, interval37.overlaps(new Interval(9, 9))); // gap after
603 }
604
605 public void testOverlaps_RInterval_null() {
606 DateTimeUtils.setCurrentMillisFixed(2);
607 assertEquals(false, interval37.overlaps((ReadableInterval) null)); // gap before
608 DateTimeUtils.setCurrentMillisFixed(3);
609 assertEquals(false, interval37.overlaps((ReadableInterval) null)); // abuts before
610 DateTimeUtils.setCurrentMillisFixed(4);
611 assertEquals(true, interval37.overlaps((ReadableInterval) null));
612 DateTimeUtils.setCurrentMillisFixed(6);
613 assertEquals(true, interval37.overlaps((ReadableInterval) null));
614 DateTimeUtils.setCurrentMillisFixed(7);
615 assertEquals(false, interval37.overlaps((ReadableInterval) null)); // abuts after
616 DateTimeUtils.setCurrentMillisFixed(8);
617 assertEquals(false, interval37.overlaps((ReadableInterval) null)); // gap after
618
619 DateTimeUtils.setCurrentMillisFixed(3);
620 assertEquals(false, interval33.overlaps((ReadableInterval) null)); // abuts before and after
621 }
622
623 public void testOverlaps_RInterval_zeroDuration() {
624 assertEquals(false, interval33.overlaps(interval33)); // abuts before and after
625 assertEquals(false, interval33.overlaps(interval37)); // abuts before
626 assertEquals(false, interval37.overlaps(interval33)); // abuts before
627 assertEquals(false, interval33.overlaps(new Interval(1, 2)));
628 assertEquals(false, interval33.overlaps(new Interval(8, 9)));
629 assertEquals(true, interval33.overlaps(new Interval(1, 9)));
630 }
631
632 //-----------------------------------------------------------------------
633 public void testOverlap_RInterval() {
634 assertEquals(null, interval37.overlap(new Interval(1, 2))); // gap before
635 assertEquals(null, interval37.overlap(new Interval(2, 2))); // gap before
636
637 assertEquals(null, interval37.overlap(new Interval(2, 3))); // abuts before
638 assertEquals(null, interval37.overlap(new Interval(3, 3))); // abuts before
639
640 assertEquals(new Interval(3, 4), interval37.overlap(new Interval(2, 4))); // truncated start
641 assertEquals(new Interval(3, 4), interval37.overlap(new Interval(3, 4)));
642 assertEquals(new Interval(4, 4), interval37.overlap(new Interval(4, 4)));
643
644 assertEquals(new Interval(3, 7), interval37.overlap(new Interval(2, 7))); // truncated start
645 assertEquals(new Interval(3, 7), interval37.overlap(new Interval(3, 7)));
646 assertEquals(new Interval(4, 7), interval37.overlap(new Interval(4, 7)));
647 assertEquals(new Interval(5, 7), interval37.overlap(new Interval(5, 7)));
648 assertEquals(new Interval(6, 7), interval37.overlap(new Interval(6, 7)));
649 assertEquals(null, interval37.overlap(new Interval(7, 7))); // abuts after
650
651 assertEquals(new Interval(3, 7), interval37.overlap(new Interval(2, 8))); // truncated start and end
652 assertEquals(new Interval(3, 7), interval37.overlap(new Interval(3, 8))); // truncated end
653 assertEquals(new Interval(4, 7), interval37.overlap(new Interval(4, 8))); // truncated end
654 assertEquals(new Interval(5, 7), interval37.overlap(new Interval(5, 8))); // truncated end
655 assertEquals(new Interval(6, 7), interval37.overlap(new Interval(6, 8))); // truncated end
656 assertEquals(null, interval37.overlap(new Interval(7, 8))); // abuts after
657 assertEquals(null, interval37.overlap(new Interval(8, 8))); // gap after
658 }
659
660 public void testOverlap_RInterval_null() {
661 DateTimeUtils.setCurrentMillisFixed(2);
662 assertEquals(null, interval37.overlap((ReadableInterval) null)); // gap before
663 DateTimeUtils.setCurrentMillisFixed(3);
664 assertEquals(null, interval37.overlap((ReadableInterval) null)); // abuts before
665 DateTimeUtils.setCurrentMillisFixed(4);
666 assertEquals(new Interval(4, 4), interval37.overlap((ReadableInterval) null));
667 DateTimeUtils.setCurrentMillisFixed(6);
668 assertEquals(new Interval(6, 6), interval37.overlap((ReadableInterval) null));
669 DateTimeUtils.setCurrentMillisFixed(7);
670 assertEquals(null, interval37.overlap((ReadableInterval) null)); // abuts after
671 DateTimeUtils.setCurrentMillisFixed(8);
672 assertEquals(null, interval37.overlap((ReadableInterval) null)); // gap after
673
674 DateTimeUtils.setCurrentMillisFixed(3);
675 assertEquals(null, interval33.overlap((ReadableInterval) null)); // abuts before and after
676 }
677
678 public void testOverlap_RInterval_zone() {
679 Interval testA = new Interval(new DateTime(3, LONDON), new DateTime(7, LONDON));
680 assertEquals(ISOChronology.getInstance(LONDON), testA.getChronology());
681
682 Interval testB = new Interval(new DateTime(4, MOSCOW), new DateTime(8, MOSCOW));
683 assertEquals(ISOChronology.getInstance(MOSCOW), testB.getChronology());
684
685 Interval resultAB = testA.overlap(testB);
686 assertEquals(ISOChronology.getInstance(LONDON), resultAB.getChronology());
687
688 Interval resultBA = testB.overlap(testA);
689 assertEquals(ISOChronology.getInstance(MOSCOW), resultBA.getChronology());
690 }
691
692 public void testOverlap_RInterval_zoneUTC() {
693 Interval testA = new Interval(new Instant(3), new Instant(7));
694 assertEquals(ISOChronology.getInstanceUTC(), testA.getChronology());
695
696 Interval testB = new Interval(new Instant(4), new Instant(8));
697 assertEquals(ISOChronology.getInstanceUTC(), testB.getChronology());
698
699 Interval result = testA.overlap(testB);
700 assertEquals(ISOChronology.getInstanceUTC(), result.getChronology());
701 }
702
703 //-----------------------------------------------------------------------
704 public void testGap_RInterval() {
705 assertEquals(new Interval(1, 3), interval37.gap(new Interval(0, 1)));
706 assertEquals(new Interval(1, 3), interval37.gap(new Interval(1, 1)));
707
708 assertEquals(null, interval37.gap(new Interval(2, 3))); // abuts before
709 assertEquals(null, interval37.gap(new Interval(3, 3))); // abuts before
710
711 assertEquals(null, interval37.gap(new Interval(4, 6))); // overlaps
712
713 assertEquals(null, interval37.gap(new Interval(3, 7))); // overlaps
714 assertEquals(null, interval37.gap(new Interval(6, 7))); // overlaps
715 assertEquals(null, interval37.gap(new Interval(7, 7))); // abuts after
716
717 assertEquals(null, interval37.gap(new Interval(6, 8))); // overlaps
718 assertEquals(null, interval37.gap(new Interval(7, 8))); // abuts after
719 assertEquals(new Interval(7, 8), interval37.gap(new Interval(8, 8)));
720
721 assertEquals(null, interval37.gap(new Interval(6, 9))); // overlaps
722 assertEquals(null, interval37.gap(new Interval(7, 9))); // abuts after
723 assertEquals(new Interval(7, 8), interval37.gap(new Interval(8, 9)));
724 assertEquals(new Interval(7, 9), interval37.gap(new Interval(9, 9)));
725 }
726
727 public void testGap_RInterval_null() {
728 DateTimeUtils.setCurrentMillisFixed(2);
729 assertEquals(new Interval(2, 3), interval37.gap((ReadableInterval) null));
730 DateTimeUtils.setCurrentMillisFixed(3);
731 assertEquals(null, interval37.gap((ReadableInterval) null)); // abuts before
732 DateTimeUtils.setCurrentMillisFixed(4);
733 assertEquals(null, interval37.gap((ReadableInterval) null)); // overlaps
734 DateTimeUtils.setCurrentMillisFixed(6);
735 assertEquals(null, interval37.gap((ReadableInterval) null)); // overlaps
736 DateTimeUtils.setCurrentMillisFixed(7);
737 assertEquals(null, interval37.gap((ReadableInterval) null)); // abuts after
738 DateTimeUtils.setCurrentMillisFixed(8);
739 assertEquals(new Interval(7, 8), interval37.gap((ReadableInterval) null));
740 }
741
742 public void testGap_RInterval_zone() {
743 Interval testA = new Interval(new DateTime(3, LONDON), new DateTime(7, LONDON));
744 assertEquals(ISOChronology.getInstance(LONDON), testA.getChronology());
745
746 Interval testB = new Interval(new DateTime(1, MOSCOW), new DateTime(2, MOSCOW));
747 assertEquals(ISOChronology.getInstance(MOSCOW), testB.getChronology());
748
749 Interval resultAB = testA.gap(testB);
750 assertEquals(ISOChronology.getInstance(LONDON), resultAB.getChronology());
751
752 Interval resultBA = testB.gap(testA);
753 assertEquals(ISOChronology.getInstance(MOSCOW), resultBA.getChronology());
754 }
755
756 public void testGap_RInterval_zoneUTC() {
757 Interval testA = new Interval(new Instant(3), new Instant(7));
758 assertEquals(ISOChronology.getInstanceUTC(), testA.getChronology());
759
760 Interval testB = new Interval(new Instant(1), new Instant(2));
761 assertEquals(ISOChronology.getInstanceUTC(), testB.getChronology());
762
763 Interval result = testA.gap(testB);
764 assertEquals(ISOChronology.getInstanceUTC(), result.getChronology());
765 }
766
767 //-----------------------------------------------------------------------
768 public void testAbuts_RInterval() {
769 assertEquals(false, interval37.abuts(new Interval(1, 2))); // gap before
770 assertEquals(false, interval37.abuts(new Interval(2, 2))); // gap before
771
772 assertEquals(true, interval37.abuts(new Interval(2, 3)));
773 assertEquals(true, interval37.abuts(new Interval(3, 3)));
774
775 assertEquals(false, interval37.abuts(new Interval(2, 4))); // overlaps
776 assertEquals(false, interval37.abuts(new Interval(3, 4))); // overlaps
777 assertEquals(false, interval37.abuts(new Interval(4, 4))); // overlaps
778
779 assertEquals(false, interval37.abuts(new Interval(2, 6))); // overlaps
780 assertEquals(false, interval37.abuts(new Interval(3, 6))); // overlaps
781 assertEquals(false, interval37.abuts(new Interval(4, 6))); // overlaps
782 assertEquals(false, interval37.abuts(new Interval(5, 6))); // overlaps
783 assertEquals(false, interval37.abuts(new Interval(6, 6))); // overlaps
784
785 assertEquals(false, interval37.abuts(new Interval(2, 7))); // overlaps
786 assertEquals(false, interval37.abuts(new Interval(3, 7))); // overlaps
787 assertEquals(false, interval37.abuts(new Interval(4, 7))); // overlaps
788 assertEquals(false, interval37.abuts(new Interval(5, 7))); // overlaps
789 assertEquals(false, interval37.abuts(new Interval(6, 7))); // overlaps
790 assertEquals(true, interval37.abuts(new Interval(7, 7)));
791
792 assertEquals(false, interval37.abuts(new Interval(2, 8))); // overlaps
793 assertEquals(false, interval37.abuts(new Interval(3, 8))); // overlaps
794 assertEquals(false, interval37.abuts(new Interval(4, 8))); // overlaps
795 assertEquals(false, interval37.abuts(new Interval(5, 8))); // overlaps
796 assertEquals(false, interval37.abuts(new Interval(6, 8))); // overlaps
797 assertEquals(true, interval37.abuts(new Interval(7, 8)));
798 assertEquals(false, interval37.abuts(new Interval(8, 8))); // gap after
799
800 assertEquals(false, interval37.abuts(new Interval(8, 9))); // gap after
801 assertEquals(false, interval37.abuts(new Interval(9, 9))); // gap after
802 }
803
804 public void testAbuts_RInterval_null() {
805 DateTimeUtils.setCurrentMillisFixed(2);
806 assertEquals(false, interval37.abuts((ReadableInterval) null)); // gap before
807 DateTimeUtils.setCurrentMillisFixed(3);
808 assertEquals(true, interval37.abuts((ReadableInterval) null));
809 DateTimeUtils.setCurrentMillisFixed(4);
810 assertEquals(false, interval37.abuts((ReadableInterval) null)); // overlaps
811 DateTimeUtils.setCurrentMillisFixed(6);
812 assertEquals(false, interval37.abuts((ReadableInterval) null)); // overlaps
813 DateTimeUtils.setCurrentMillisFixed(7);
814 assertEquals(true, interval37.abuts((ReadableInterval) null));
815 DateTimeUtils.setCurrentMillisFixed(8);
816 assertEquals(false, interval37.abuts((ReadableInterval) null)); // gap after
817 }
818
819 // -----------------------------------------------------------------------
820 public void testIsBefore_long() {
821 assertEquals(false, interval37.isBefore(2));
822 assertEquals(false, interval37.isBefore(3));
823 assertEquals(false, interval37.isBefore(4));
824 assertEquals(false, interval37.isBefore(5));
825 assertEquals(false, interval37.isBefore(6));
826 assertEquals(true, interval37.isBefore(7));
827 assertEquals(true, interval37.isBefore(8));
828 }
829
830 public void testIsBeforeNow() {
831 DateTimeUtils.setCurrentMillisFixed(2);
832 assertEquals(false, interval37.isBeforeNow());
833 DateTimeUtils.setCurrentMillisFixed(3);
834 assertEquals(false, interval37.isBeforeNow());
835 DateTimeUtils.setCurrentMillisFixed(4);
836 assertEquals(false, interval37.isBeforeNow());
837 DateTimeUtils.setCurrentMillisFixed(6);
838 assertEquals(false, interval37.isBeforeNow());
839 DateTimeUtils.setCurrentMillisFixed(7);
840 assertEquals(true, interval37.isBeforeNow());
841 DateTimeUtils.setCurrentMillisFixed(8);
842 assertEquals(true, interval37.isBeforeNow());
843 }
844
845 public void testIsBefore_RI() {
846 assertEquals(false, interval37.isBefore(new Instant(2)));
847 assertEquals(false, interval37.isBefore(new Instant(3)));
848 assertEquals(false, interval37.isBefore(new Instant(4)));
849 assertEquals(false, interval37.isBefore(new Instant(5)));
850 assertEquals(false, interval37.isBefore(new Instant(6)));
851 assertEquals(true, interval37.isBefore(new Instant(7)));
852 assertEquals(true, interval37.isBefore(new Instant(8)));
853 }
854
855 public void testIsBefore_RI_null() {
856 DateTimeUtils.setCurrentMillisFixed(2);
857 assertEquals(false, interval37.isBefore((ReadableInstant) null));
858 DateTimeUtils.setCurrentMillisFixed(3);
859 assertEquals(false, interval37.isBefore((ReadableInstant) null));
860 DateTimeUtils.setCurrentMillisFixed(4);
861 assertEquals(false, interval37.isBefore((ReadableInstant) null));
862 DateTimeUtils.setCurrentMillisFixed(6);
863 assertEquals(false, interval37.isBefore((ReadableInstant) null));
864 DateTimeUtils.setCurrentMillisFixed(7);
865 assertEquals(true, interval37.isBefore((ReadableInstant) null));
866 DateTimeUtils.setCurrentMillisFixed(8);
867 assertEquals(true, interval37.isBefore((ReadableInstant) null));
868 }
869
870 public void testIsBefore_RInterval() {
871 assertEquals(false, interval37.isBefore(new Interval(Long.MIN_VALUE, 2)));
872 assertEquals(false, interval37.isBefore(new Interval(Long.MIN_VALUE, 3)));
873 assertEquals(false, interval37.isBefore(new Interval(Long.MIN_VALUE, 4)));
874
875 assertEquals(false, interval37.isBefore(new Interval(6, Long.MAX_VALUE)));
876 assertEquals(true, interval37.isBefore(new Interval(7, Long.MAX_VALUE)));
877 assertEquals(true, interval37.isBefore(new Interval(8, Long.MAX_VALUE)));
878 }
879
880 public void testIsBefore_RInterval_null() {
881 DateTimeUtils.setCurrentMillisFixed(2);
882 assertEquals(false, interval37.isBefore((ReadableInterval) null));
883 DateTimeUtils.setCurrentMillisFixed(3);
884 assertEquals(false, interval37.isBefore((ReadableInterval) null));
885 DateTimeUtils.setCurrentMillisFixed(4);
886 assertEquals(false, interval37.isBefore((ReadableInterval) null));
887 DateTimeUtils.setCurrentMillisFixed(6);
888 assertEquals(false, interval37.isBefore((ReadableInterval) null));
889 DateTimeUtils.setCurrentMillisFixed(7);
890 assertEquals(true, interval37.isBefore((ReadableInterval) null));
891 DateTimeUtils.setCurrentMillisFixed(8);
892 assertEquals(true, interval37.isBefore((ReadableInterval) null));
893 }
894
895 //-----------------------------------------------------------------------
896 public void testIsAfter_long() {
897 assertEquals(true, interval37.isAfter(2));
898 assertEquals(false, interval37.isAfter(3));
899 assertEquals(false, interval37.isAfter(4));
900 assertEquals(false, interval37.isAfter(5));
901 assertEquals(false, interval37.isAfter(6));
902 assertEquals(false, interval37.isAfter(7));
903 assertEquals(false, interval37.isAfter(8));
904 }
905
906 public void testIsAfterNow() {
907 DateTimeUtils.setCurrentMillisFixed(2);
908 assertEquals(true, interval37.isAfterNow());
909 DateTimeUtils.setCurrentMillisFixed(3);
910 assertEquals(false, interval37.isAfterNow());
911 DateTimeUtils.setCurrentMillisFixed(4);
912 assertEquals(false, interval37.isAfterNow());
913 DateTimeUtils.setCurrentMillisFixed(6);
914 assertEquals(false, interval37.isAfterNow());
915 DateTimeUtils.setCurrentMillisFixed(7);
916 assertEquals(false, interval37.isAfterNow());
917 DateTimeUtils.setCurrentMillisFixed(8);
918 assertEquals(false, interval37.isAfterNow());
919 }
920
921 public void testIsAfter_RI() {
922 assertEquals(true, interval37.isAfter(new Instant(2)));
923 assertEquals(false, interval37.isAfter(new Instant(3)));
924 assertEquals(false, interval37.isAfter(new Instant(4)));
925 assertEquals(false, interval37.isAfter(new Instant(5)));
926 assertEquals(false, interval37.isAfter(new Instant(6)));
927 assertEquals(false, interval37.isAfter(new Instant(7)));
928 assertEquals(false, interval37.isAfter(new Instant(8)));
929 }
930
931 public void testIsAfter_RI_null() {
932 DateTimeUtils.setCurrentMillisFixed(2);
933 assertEquals(true, interval37.isAfter((ReadableInstant) null));
934 DateTimeUtils.setCurrentMillisFixed(3);
935 assertEquals(false, interval37.isAfter((ReadableInstant) null));
936 DateTimeUtils.setCurrentMillisFixed(4);
937 assertEquals(false, interval37.isAfter((ReadableInstant) null));
938 DateTimeUtils.setCurrentMillisFixed(6);
939 assertEquals(false, interval37.isAfter((ReadableInstant) null));
940 DateTimeUtils.setCurrentMillisFixed(7);
941 assertEquals(false, interval37.isAfter((ReadableInstant) null));
942 DateTimeUtils.setCurrentMillisFixed(8);
943 assertEquals(false, interval37.isAfter((ReadableInstant) null));
944 }
945
946 public void testIsAfter_RInterval() {
947 assertEquals(true, interval37.isAfter(new Interval(Long.MIN_VALUE, 2)));
948 assertEquals(true, interval37.isAfter(new Interval(Long.MIN_VALUE, 3)));
949 assertEquals(false, interval37.isAfter(new Interval(Long.MIN_VALUE, 4)));
950
951 assertEquals(false, interval37.isAfter(new Interval(6, Long.MAX_VALUE)));
952 assertEquals(false, interval37.isAfter(new Interval(7, Long.MAX_VALUE)));
953 assertEquals(false, interval37.isAfter(new Interval(8, Long.MAX_VALUE)));
954 }
955
956 public void testIsAfter_RInterval_null() {
957 DateTimeUtils.setCurrentMillisFixed(2);
958 assertEquals(true, interval37.isAfter((ReadableInterval) null));
959 DateTimeUtils.setCurrentMillisFixed(3);
960 assertEquals(true, interval37.isAfter((ReadableInterval) null));
961 DateTimeUtils.setCurrentMillisFixed(4);
962 assertEquals(false, interval37.isAfter((ReadableInterval) null));
963 DateTimeUtils.setCurrentMillisFixed(6);
964 assertEquals(false, interval37.isAfter((ReadableInterval) null));
965 DateTimeUtils.setCurrentMillisFixed(7);
966 assertEquals(false, interval37.isAfter((ReadableInterval) null));
967 DateTimeUtils.setCurrentMillisFixed(8);
968 assertEquals(false, interval37.isAfter((ReadableInterval) null));
969 }
970
971 //-----------------------------------------------------------------------
972 public void testToInterval1() {
973 Interval test = new Interval(TEST_TIME1, TEST_TIME2, COPTIC_PARIS);
974 Interval result = test.toInterval();
975 assertSame(test, result);
976 }
977
978 //-----------------------------------------------------------------------
979 public void testToMutableInterval1() {
980 Interval test = new Interval(TEST_TIME1, TEST_TIME2, COPTIC_PARIS);
981 MutableInterval result = test.toMutableInterval();
982 assertEquals(test, result);
983 }
984
985 //-----------------------------------------------------------------------
986 public void testToPeriod() {
987 DateTime dt1 = new DateTime(2004, 6, 9, 7, 8, 9, 10, COPTIC_PARIS);
988 DateTime dt2 = new DateTime(2005, 8, 13, 12, 14, 16, 18, COPTIC_PARIS);
989 Interval base = new Interval(dt1, dt2);
990
991 Period test = base.toPeriod();
992 Period expected = new Period(dt1, dt2, PeriodType.standard());
993 assertEquals(expected, test);
994 }
995
996 //-----------------------------------------------------------------------
997 public void testToPeriod_PeriodType1() {
998 DateTime dt1 = new DateTime(2004, 6, 9, 7, 8, 9, 10, COPTIC_PARIS);
999 DateTime dt2 = new DateTime(2005, 8, 13, 12, 14, 16, 18, COPTIC_PARIS);
1000 Interval base = new Interval(dt1, dt2);
1001
1002 Period test = base.toPeriod(null);
1003 Period expected = new Period(dt1, dt2, PeriodType.standard());
1004 assertEquals(expected, test);
1005 }
1006
1007 public void testToPeriod_PeriodType2() {
1008 DateTime dt1 = new DateTime(2004, 6, 9, 7, 8, 9, 10);
1009 DateTime dt2 = new DateTime(2005, 8, 13, 12, 14, 16, 18);
1010 Interval base = new Interval(dt1, dt2);
1011
1012 Period test = base.toPeriod(PeriodType.yearWeekDayTime());
1013 Period expected = new Period(dt1, dt2, PeriodType.yearWeekDayTime());
1014 assertEquals(expected, test);
1015 }
1016
1017 //-----------------------------------------------------------------------
1018 public void testSerialization() throws Exception {
1019 Interval test = new Interval(TEST_TIME1, TEST_TIME2, COPTIC_PARIS);
1020
1021 ByteArrayOutputStream baos = new ByteArrayOutputStream();
1022 ObjectOutputStream oos = new ObjectOutputStream(baos);
1023 oos.writeObject(test);
1024 byte[] bytes = baos.toByteArray();
1025 oos.close();
1026
1027 ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
1028 ObjectInputStream ois = new ObjectInputStream(bais);
1029 Interval result = (Interval) ois.readObject();
1030 ois.close();
1031
1032 assertEquals(test, result);
1033 }
1034
1035 //-----------------------------------------------------------------------
1036 public void testToString() {
1037 DateTime dt1 = new DateTime(2004, 6, 9, 7, 8, 9, 10, DateTimeZone.UTC);
1038 DateTime dt2 = new DateTime(2005, 8, 13, 12, 14, 16, 18, DateTimeZone.UTC);
1039 Interval test = new Interval(dt1, dt2);
1040 assertEquals("2004-06-09T07:08:09.010Z/2005-08-13T12:14:16.018Z", test.toString());
1041 }
1042
1043 public void testToString_reparse() {
1044 DateTime dt1 = new DateTime(2004, 6, 9, 7, 8, 9, 10, DateTimeZone.getDefault());
1045 DateTime dt2 = new DateTime(2005, 8, 13, 12, 14, 16, 18, DateTimeZone.getDefault());
1046 Interval test = new Interval(dt1, dt2);
1047 assertEquals(test, new Interval(test.toString()));
1048 }
1049
1050 //-----------------------------------------------------------------------
1051 public void testWithChronology1() {
1052 Interval base = new Interval(TEST_TIME1, TEST_TIME2, COPTIC_PARIS);
1053 Interval test = base.withChronology(BuddhistChronology.getInstance());
1054 assertEquals(new Interval(TEST_TIME1, TEST_TIME2, BuddhistChronology.getInstance()), test);
1055 }
1056
1057 public void testWithChronology2() {
1058 Interval base = new Interval(TEST_TIME1, TEST_TIME2, COPTIC_PARIS);
1059 Interval test = base.withChronology(null);
1060 assertEquals(new Interval(TEST_TIME1, TEST_TIME2, ISOChronology.getInstance()), test);
1061 }
1062
1063 public void testWithChronology3() {
1064 Interval base = new Interval(TEST_TIME1, TEST_TIME2, COPTIC_PARIS);
1065 Interval test = base.withChronology(COPTIC_PARIS);
1066 assertSame(base, test);
1067 }
1068
1069 //-----------------------------------------------------------------------
1070 public void testWithStartMillis_long1() {
1071 Interval base = new Interval(TEST_TIME1, TEST_TIME2, COPTIC_PARIS);
1072 Interval test = base.withStartMillis(TEST_TIME1 - 1);
1073 assertEquals(new Interval(TEST_TIME1 - 1, TEST_TIME2, COPTIC_PARIS), test);
1074 }
1075
1076 public void testWithStartMillis_long2() {
1077 Interval test = new Interval(TEST_TIME1, TEST_TIME2);
1078 try {
1079 test.withStartMillis(TEST_TIME2 + 1);
1080 fail();
1081 } catch (IllegalArgumentException ex) {}
1082 }
1083
1084 public void testWithStartMillis_long3() {
1085 Interval base = new Interval(TEST_TIME1, TEST_TIME2, COPTIC_PARIS);
1086 Interval test = base.withStartMillis(TEST_TIME1);
1087 assertSame(base, test);
1088 }
1089
1090 //-----------------------------------------------------------------------
1091 public void testWithStartInstant_RI1() {
1092 Interval base = new Interval(TEST_TIME1, TEST_TIME2, COPTIC_PARIS);
1093 Interval test = base.withStart(new Instant(TEST_TIME1 - 1));
1094 assertEquals(new Interval(TEST_TIME1 - 1, TEST_TIME2, COPTIC_PARIS), test);
1095 }
1096
1097 public void testWithStartInstant_RI2() {
1098 Interval test = new Interval(TEST_TIME1, TEST_TIME2);
1099 try {
1100 test.withStart(new Instant(TEST_TIME2 + 1));
1101 fail();
1102 } catch (IllegalArgumentException ex) {}
1103 }
1104
1105 public void testWithStartInstant_RI3() {
1106 Interval base = new Interval(TEST_TIME1, TEST_TIME2, COPTIC_PARIS);
1107 Interval test = base.withStart(null);
1108 assertEquals(new Interval(TEST_TIME_NOW, TEST_TIME2, COPTIC_PARIS), test);
1109 }
1110
1111 //-----------------------------------------------------------------------
1112 public void testWithEndMillis_long1() {
1113 Interval base = new Interval(TEST_TIME1, TEST_TIME2, COPTIC_PARIS);
1114 Interval test = base.withEndMillis(TEST_TIME2 - 1);
1115 assertEquals(new Interval(TEST_TIME1, TEST_TIME2 - 1, COPTIC_PARIS), test);
1116 }
1117
1118 public void testWithEndMillis_long2() {
1119 Interval test = new Interval(TEST_TIME1, TEST_TIME2);
1120 try {
1121 test.withEndMillis(TEST_TIME1 - 1);
1122 fail();
1123 } catch (IllegalArgumentException ex) {}
1124 }
1125
1126 public void testWithEndMillis_long3() {
1127 Interval base = new Interval(TEST_TIME1, TEST_TIME2, COPTIC_PARIS);
1128 Interval test = base.withEndMillis(TEST_TIME2);
1129 assertSame(base, test);
1130 }
1131
1132 //-----------------------------------------------------------------------
1133 public void testWithEndInstant_RI1() {
1134 Interval base = new Interval(TEST_TIME1, TEST_TIME2, COPTIC_PARIS);
1135 Interval test = base.withEnd(new Instant(TEST_TIME2 - 1));
1136 assertEquals(new Interval(TEST_TIME1, TEST_TIME2 - 1, COPTIC_PARIS), test);
1137 }
1138
1139 public void testWithEndInstant_RI2() {
1140 Interval test = new Interval(TEST_TIME1, TEST_TIME2);
1141 try {
1142 test.withEnd(new Instant(TEST_TIME1 - 1));
1143 fail();
1144 } catch (IllegalArgumentException ex) {}
1145 }
1146
1147 public void testWithEndInstant_RI3() {
1148 Interval base = new Interval(TEST_TIME1, TEST_TIME2, COPTIC_PARIS);
1149 Interval test = base.withEnd(null);
1150 assertEquals(new Interval(TEST_TIME1, TEST_TIME_NOW, COPTIC_PARIS), test);
1151 }
1152
1153 //-----------------------------------------------------------------------
1154 public void testWithDurationAfterStart1() throws Throwable {
1155 Duration dur = new Duration(TEST_TIME2 - TEST_TIME_NOW);
1156 Interval base = new Interval(TEST_TIME_NOW, TEST_TIME_NOW, COPTIC_PARIS);
1157 Interval test = base.withDurationAfterStart(dur);
1158
1159 assertEquals(new Interval(TEST_TIME_NOW, TEST_TIME2, COPTIC_PARIS), test);
1160 }
1161
1162 public void testWithDurationAfterStart2() throws Throwable {
1163 Interval base = new Interval(TEST_TIME_NOW, TEST_TIME2, COPTIC_PARIS);
1164 Interval test = base.withDurationAfterStart(null);
1165
1166 assertEquals(new Interval(TEST_TIME_NOW, TEST_TIME_NOW, COPTIC_PARIS), test);
1167 }
1168
1169 public void testWithDurationAfterStart3() throws Throwable {
1170 Duration dur = new Duration(-1);
1171 Interval base = new Interval(TEST_TIME_NOW, TEST_TIME_NOW);
1172 try {
1173 base.withDurationAfterStart(dur);
1174 fail();
1175 } catch (IllegalArgumentException ex) {}
1176 }
1177
1178 public void testWithDurationAfterStart4() throws Throwable {
1179 Interval base = new Interval(TEST_TIME_NOW, TEST_TIME2, COPTIC_PARIS);
1180 Interval test = base.withDurationAfterStart(base.toDuration());
1181
1182 assertSame(base, test);
1183 }
1184
1185 //-----------------------------------------------------------------------
1186 public void testWithDurationBeforeEnd1() throws Throwable {
1187 Duration dur = new Duration(TEST_TIME_NOW - TEST_TIME1);
1188 Interval base = new Interval(TEST_TIME_NOW, TEST_TIME_NOW, COPTIC_PARIS);
1189 Interval test = base.withDurationBeforeEnd(dur);
1190
1191 assertEquals(new Interval(TEST_TIME1, TEST_TIME_NOW, COPTIC_PARIS), test);
1192 }
1193
1194 public void testWithDurationBeforeEnd2() throws Throwable {
1195 Interval base = new Interval(TEST_TIME_NOW, TEST_TIME2, COPTIC_PARIS);
1196 Interval test = base.withDurationBeforeEnd(null);
1197
1198 assertEquals(new Interval(TEST_TIME2, TEST_TIME2, COPTIC_PARIS), test);
1199 }
1200
1201 public void testWithDurationBeforeEnd3() throws Throwable {
1202 Duration dur = new Duration(-1);
1203 Interval base = new Interval(TEST_TIME_NOW, TEST_TIME_NOW);
1204 try {
1205 base.withDurationBeforeEnd(dur);
1206 fail();
1207 } catch (IllegalArgumentException ex) {}
1208 }
1209
1210 public void testWithDurationBeforeEnd4() throws Throwable {
1211 Interval base = new Interval(TEST_TIME_NOW, TEST_TIME2, COPTIC_PARIS);
1212 Interval test = base.withDurationBeforeEnd(base.toDuration());
1213
1214 assertSame(base, test);
1215 }
1216
1217 //-----------------------------------------------------------------------
1218 public void testWithPeriodAfterStart1() throws Throwable {
1219 DateTime dt = new DateTime(TEST_TIME_NOW, COPTIC_PARIS);
1220 Period dur = new Period(0, 6, 0, 0, 1, 0, 0, 0);
1221
1222 Interval base = new Interval(dt, dt);
1223 Interval test = base.withPeriodAfterStart(dur);
1224 assertEquals(new Interval(dt, dur), test);
1225 }
1226
1227 public void testWithPeriodAfterStart2() throws Throwable {
1228 Interval base = new Interval(TEST_TIME_NOW, TEST_TIME2, COPTIC_PARIS);
1229 Interval test = base.withPeriodAfterStart(null);
1230
1231 assertEquals(new Interval(TEST_TIME_NOW, TEST_TIME_NOW, COPTIC_PARIS), test);
1232 }
1233
1234 public void testWithPeriodAfterStart3() throws Throwable {
1235 Period per = new Period(0, 0, 0, 0, 0, 0, 0, -1);
1236 Interval base = new Interval(TEST_TIME_NOW, TEST_TIME_NOW);
1237 try {
1238 base.withPeriodAfterStart(per);
1239 fail();
1240 } catch (IllegalArgumentException ex) {}
1241 }
1242
1243 //-----------------------------------------------------------------------
1244 public void testWithPeriodBeforeEnd1() throws Throwable {
1245 DateTime dt = new DateTime(TEST_TIME_NOW, COPTIC_PARIS);
1246 Period dur = new Period(0, 6, 0, 0, 1, 0, 0, 0);
1247
1248 Interval base = new Interval(dt, dt);
1249 Interval test = base.withPeriodBeforeEnd(dur);
1250 assertEquals(new Interval(dur, dt), test);
1251 }
1252
1253 public void testWithPeriodBeforeEnd2() throws Throwable {
1254 Interval base = new Interval(TEST_TIME_NOW, TEST_TIME2, COPTIC_PARIS);
1255 Interval test = base.withPeriodBeforeEnd(null);
1256
1257 assertEquals(new Interval(TEST_TIME2, TEST_TIME2, COPTIC_PARIS), test);
1258 }
1259
1260 public void testWithPeriodBeforeEnd3() throws Throwable {
1261 Period per = new Period(0, 0, 0, 0, 0, 0, 0, -1);
1262 Interval base = new Interval(TEST_TIME_NOW, TEST_TIME_NOW);
1263 try {
1264 base.withPeriodBeforeEnd(per);
1265 fail();
1266 } catch (IllegalArgumentException ex) {}
1267 }
1268
1269 }