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 }