001 /* 002 * Copyright 2001-2009 Stephen Colebourne 003 * 004 * Licensed under the Apache License, Version 2.0 (the "License"); 005 * you may not use this file except in compliance with the License. 006 * You may obtain a copy of the License at 007 * 008 * http://www.apache.org/licenses/LICENSE-2.0 009 * 010 * Unless required by applicable law or agreed to in writing, software 011 * distributed under the License is distributed on an "AS IS" BASIS, 012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 013 * See the License for the specific language governing permissions and 014 * limitations under the License. 015 */ 016 package org.joda.time; 017 018 import java.io.ByteArrayInputStream; 019 import java.io.ByteArrayOutputStream; 020 import java.io.ObjectInputStream; 021 import java.io.ObjectOutputStream; 022 import java.util.Calendar; 023 import java.util.Date; 024 import java.util.GregorianCalendar; 025 import java.util.Locale; 026 import java.util.TimeZone; 027 028 import junit.framework.TestCase; 029 import junit.framework.TestSuite; 030 031 import org.joda.time.base.AbstractInstant; 032 import org.joda.time.chrono.BaseChronology; 033 import org.joda.time.chrono.BuddhistChronology; 034 import org.joda.time.chrono.CopticChronology; 035 import org.joda.time.chrono.GJChronology; 036 import org.joda.time.chrono.GregorianChronology; 037 import org.joda.time.chrono.ISOChronology; 038 import org.joda.time.field.UnsupportedDateTimeField; 039 import org.joda.time.field.UnsupportedDurationField; 040 import org.joda.time.format.DateTimeFormat; 041 import org.joda.time.format.DateTimeFormatter; 042 043 /** 044 * This class is a Junit unit test for DateTime. 045 * 046 * @author Stephen Colebourne 047 */ 048 public class TestDateTime_Basics extends TestCase { 049 // Test in 2002/03 as time zones are more well known 050 // (before the late 90's they were all over the place) 051 052 private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris"); 053 private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London"); 054 055 // the default time zone is set to LONDON in setUp() 056 // we have to hard code LONDON here (instead of ISOChronology.getInstance() etc.) 057 // as TestAll sets up a different time zone for better all-round testing 058 private static final ISOChronology ISO_UTC = ISOChronology.getInstanceUTC(); 059 private static final ISOChronology ISO_DEFAULT = ISOChronology.getInstance(LONDON); 060 private static final ISOChronology ISO_PARIS = ISOChronology.getInstance(PARIS); 061 private static final GJChronology GJ_DEFAULT = GJChronology.getInstance(LONDON); 062 private static final GregorianChronology GREGORIAN_DEFAULT = GregorianChronology.getInstance(LONDON); 063 private static final GregorianChronology GREGORIAN_PARIS = GregorianChronology.getInstance(PARIS); 064 private static final BuddhistChronology BUDDHIST_UTC = BuddhistChronology.getInstanceUTC(); 065 private static final BuddhistChronology BUDDHIST_DEFAULT = BuddhistChronology.getInstance(LONDON); 066 private static final CopticChronology COPTIC_DEFAULT = CopticChronology.getInstance(LONDON); 067 068 long y2002days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 069 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 070 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 071 366 + 365; 072 long y2003days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 073 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 074 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 075 366 + 365 + 365; 076 077 // 2002-06-09 078 private long TEST_TIME_NOW = 079 (y2002days + 31L + 28L + 31L + 30L + 31L + 9L -1L) * DateTimeConstants.MILLIS_PER_DAY; 080 081 // 2002-04-05 082 private long TEST_TIME1 = 083 (y2002days + 31L + 28L + 31L + 5L -1L) * DateTimeConstants.MILLIS_PER_DAY 084 + 12L * DateTimeConstants.MILLIS_PER_HOUR 085 + 24L * DateTimeConstants.MILLIS_PER_MINUTE; 086 087 // 2003-05-06 088 private long TEST_TIME2 = 089 (y2003days + 31L + 28L + 31L + 30L + 6L -1L) * DateTimeConstants.MILLIS_PER_DAY 090 + 14L * DateTimeConstants.MILLIS_PER_HOUR 091 + 28L * DateTimeConstants.MILLIS_PER_MINUTE; 092 093 private DateTimeZone originalDateTimeZone = null; 094 private TimeZone originalTimeZone = null; 095 private Locale originalLocale = null; 096 097 public static void main(String[] args) { 098 junit.textui.TestRunner.run(suite()); 099 } 100 101 public static TestSuite suite() { 102 return new TestSuite(TestDateTime_Basics.class); 103 } 104 105 public TestDateTime_Basics(String name) { 106 super(name); 107 } 108 109 protected void setUp() throws Exception { 110 DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW); 111 originalDateTimeZone = DateTimeZone.getDefault(); 112 originalTimeZone = TimeZone.getDefault(); 113 originalLocale = Locale.getDefault(); 114 DateTimeZone.setDefault(LONDON); 115 TimeZone.setDefault(TimeZone.getTimeZone("Europe/London")); 116 Locale.setDefault(Locale.UK); 117 } 118 119 protected void tearDown() throws Exception { 120 DateTimeUtils.setCurrentMillisSystem(); 121 DateTimeZone.setDefault(originalDateTimeZone); 122 TimeZone.setDefault(originalTimeZone); 123 Locale.setDefault(originalLocale); 124 originalDateTimeZone = null; 125 originalTimeZone = null; 126 originalLocale = null; 127 } 128 129 //----------------------------------------------------------------------- 130 public void testTest() { 131 assertEquals("2002-06-09T00:00:00.000Z", new Instant(TEST_TIME_NOW).toString()); 132 assertEquals("2002-04-05T12:24:00.000Z", new Instant(TEST_TIME1).toString()); 133 assertEquals("2003-05-06T14:28:00.000Z", new Instant(TEST_TIME2).toString()); 134 } 135 136 //----------------------------------------------------------------------- 137 public void testGet_DateTimeField() { 138 DateTime test = new DateTime(); 139 assertEquals(1, test.get(ISO_DEFAULT.era())); 140 assertEquals(20, test.get(ISO_DEFAULT.centuryOfEra())); 141 assertEquals(2, test.get(ISO_DEFAULT.yearOfCentury())); 142 assertEquals(2002, test.get(ISO_DEFAULT.yearOfEra())); 143 assertEquals(2002, test.get(ISO_DEFAULT.year())); 144 assertEquals(6, test.get(ISO_DEFAULT.monthOfYear())); 145 assertEquals(9, test.get(ISO_DEFAULT.dayOfMonth())); 146 assertEquals(2002, test.get(ISO_DEFAULT.weekyear())); 147 assertEquals(23, test.get(ISO_DEFAULT.weekOfWeekyear())); 148 assertEquals(7, test.get(ISO_DEFAULT.dayOfWeek())); 149 assertEquals(160, test.get(ISO_DEFAULT.dayOfYear())); 150 assertEquals(0, test.get(ISO_DEFAULT.halfdayOfDay())); 151 assertEquals(1, test.get(ISO_DEFAULT.hourOfHalfday())); 152 assertEquals(1, test.get(ISO_DEFAULT.clockhourOfDay())); 153 assertEquals(1, test.get(ISO_DEFAULT.clockhourOfHalfday())); 154 assertEquals(1, test.get(ISO_DEFAULT.hourOfDay())); 155 assertEquals(0, test.get(ISO_DEFAULT.minuteOfHour())); 156 assertEquals(60, test.get(ISO_DEFAULT.minuteOfDay())); 157 assertEquals(0, test.get(ISO_DEFAULT.secondOfMinute())); 158 assertEquals(60 * 60, test.get(ISO_DEFAULT.secondOfDay())); 159 assertEquals(0, test.get(ISO_DEFAULT.millisOfSecond())); 160 assertEquals(60 * 60 * 1000, test.get(ISO_DEFAULT.millisOfDay())); 161 try { 162 test.get((DateTimeField) null); 163 fail(); 164 } catch (IllegalArgumentException ex) {} 165 } 166 167 public void testGet_DateTimeFieldType() { 168 DateTime test = new DateTime(); 169 assertEquals(1, test.get(DateTimeFieldType.era())); 170 assertEquals(20, test.get(DateTimeFieldType.centuryOfEra())); 171 assertEquals(2, test.get(DateTimeFieldType.yearOfCentury())); 172 assertEquals(2002, test.get(DateTimeFieldType.yearOfEra())); 173 assertEquals(2002, test.get(DateTimeFieldType.year())); 174 assertEquals(6, test.get(DateTimeFieldType.monthOfYear())); 175 assertEquals(9, test.get(DateTimeFieldType.dayOfMonth())); 176 assertEquals(2002, test.get(DateTimeFieldType.weekyear())); 177 assertEquals(23, test.get(DateTimeFieldType.weekOfWeekyear())); 178 assertEquals(7, test.get(DateTimeFieldType.dayOfWeek())); 179 assertEquals(160, test.get(DateTimeFieldType.dayOfYear())); 180 assertEquals(0, test.get(DateTimeFieldType.halfdayOfDay())); 181 assertEquals(1, test.get(DateTimeFieldType.hourOfHalfday())); 182 assertEquals(1, test.get(DateTimeFieldType.clockhourOfDay())); 183 assertEquals(1, test.get(DateTimeFieldType.clockhourOfHalfday())); 184 assertEquals(1, test.get(DateTimeFieldType.hourOfDay())); 185 assertEquals(0, test.get(DateTimeFieldType.minuteOfHour())); 186 assertEquals(60, test.get(DateTimeFieldType.minuteOfDay())); 187 assertEquals(0, test.get(DateTimeFieldType.secondOfMinute())); 188 assertEquals(60 * 60, test.get(DateTimeFieldType.secondOfDay())); 189 assertEquals(0, test.get(DateTimeFieldType.millisOfSecond())); 190 assertEquals(60 * 60 * 1000, test.get(DateTimeFieldType.millisOfDay())); 191 try { 192 test.get((DateTimeFieldType) null); 193 fail(); 194 } catch (IllegalArgumentException ex) {} 195 } 196 197 public void testIsSupported_DateTimeFieldType() { 198 DateTime test = new DateTime(); 199 assertEquals(true, test.isSupported(DateTimeFieldType.era())); 200 assertEquals(true, test.isSupported(DateTimeFieldType.centuryOfEra())); 201 assertEquals(true, test.isSupported(DateTimeFieldType.yearOfCentury())); 202 assertEquals(true, test.isSupported(DateTimeFieldType.yearOfEra())); 203 assertEquals(true, test.isSupported(DateTimeFieldType.year())); 204 assertEquals(true, test.isSupported(DateTimeFieldType.monthOfYear())); 205 assertEquals(true, test.isSupported(DateTimeFieldType.dayOfMonth())); 206 assertEquals(true, test.isSupported(DateTimeFieldType.weekyear())); 207 assertEquals(true, test.isSupported(DateTimeFieldType.weekOfWeekyear())); 208 assertEquals(true, test.isSupported(DateTimeFieldType.dayOfWeek())); 209 assertEquals(true, test.isSupported(DateTimeFieldType.dayOfYear())); 210 assertEquals(true, test.isSupported(DateTimeFieldType.halfdayOfDay())); 211 assertEquals(true, test.isSupported(DateTimeFieldType.hourOfHalfday())); 212 assertEquals(true, test.isSupported(DateTimeFieldType.clockhourOfDay())); 213 assertEquals(true, test.isSupported(DateTimeFieldType.clockhourOfHalfday())); 214 assertEquals(true, test.isSupported(DateTimeFieldType.hourOfDay())); 215 assertEquals(true, test.isSupported(DateTimeFieldType.minuteOfHour())); 216 assertEquals(true, test.isSupported(DateTimeFieldType.minuteOfDay())); 217 assertEquals(true, test.isSupported(DateTimeFieldType.secondOfMinute())); 218 assertEquals(true, test.isSupported(DateTimeFieldType.secondOfDay())); 219 assertEquals(true, test.isSupported(DateTimeFieldType.millisOfSecond())); 220 assertEquals(true, test.isSupported(DateTimeFieldType.millisOfDay())); 221 assertEquals(false, test.isSupported(null)); 222 } 223 224 //----------------------------------------------------------------------- 225 public void testGetters() { 226 DateTime test = new DateTime(); 227 228 assertEquals(ISO_DEFAULT, test.getChronology()); 229 assertEquals(LONDON, test.getZone()); 230 assertEquals(TEST_TIME_NOW, test.getMillis()); 231 232 assertEquals(1, test.getEra()); 233 assertEquals(20, test.getCenturyOfEra()); 234 assertEquals(2, test.getYearOfCentury()); 235 assertEquals(2002, test.getYearOfEra()); 236 assertEquals(2002, test.getYear()); 237 assertEquals(6, test.getMonthOfYear()); 238 assertEquals(9, test.getDayOfMonth()); 239 assertEquals(2002, test.getWeekyear()); 240 assertEquals(23, test.getWeekOfWeekyear()); 241 assertEquals(7, test.getDayOfWeek()); 242 assertEquals(160, test.getDayOfYear()); 243 assertEquals(1, test.getHourOfDay()); 244 assertEquals(0, test.getMinuteOfHour()); 245 assertEquals(60, test.getMinuteOfDay()); 246 assertEquals(0, test.getSecondOfMinute()); 247 assertEquals(60 * 60, test.getSecondOfDay()); 248 assertEquals(0, test.getMillisOfSecond()); 249 assertEquals(60 * 60 * 1000, test.getMillisOfDay()); 250 } 251 252 public void testWithers() { 253 DateTime test = new DateTime(1970, 6, 9, 10, 20, 30, 40, GJ_DEFAULT); 254 check(test.withYear(2000), 2000, 6, 9, 10, 20, 30, 40); 255 check(test.withMonthOfYear(2), 1970, 2, 9, 10, 20, 30, 40); 256 check(test.withDayOfMonth(2), 1970, 6, 2, 10, 20, 30, 40); 257 check(test.withDayOfYear(6), 1970, 1, 6, 10, 20, 30, 40); 258 check(test.withDayOfWeek(6), 1970, 6, 13, 10, 20, 30, 40); 259 check(test.withWeekOfWeekyear(6), 1970, 2, 3, 10, 20, 30, 40); 260 check(test.withWeekyear(1971), 1971, 6, 15, 10, 20, 30, 40); 261 check(test.withYearOfCentury(60), 1960, 6, 9, 10, 20, 30, 40); 262 check(test.withCenturyOfEra(21), 2070, 6, 9, 10, 20, 30, 40); 263 check(test.withYearOfEra(1066), 1066, 6, 9, 10, 20, 30, 40); 264 check(test.withEra(DateTimeConstants.BC), -1970, 6, 9, 10, 20, 30, 40); 265 check(test.withHourOfDay(6), 1970, 6, 9, 6, 20, 30, 40); 266 check(test.withMinuteOfHour(6), 1970, 6, 9, 10, 6, 30, 40); 267 check(test.withSecondOfMinute(6), 1970, 6, 9, 10, 20, 6, 40); 268 check(test.withMillisOfSecond(6), 1970, 6, 9, 10, 20, 30, 6); 269 check(test.withMillisOfDay(61234), 1970, 6, 9, 0, 1, 1, 234); 270 271 try { 272 test.withMonthOfYear(0); 273 fail(); 274 } catch (IllegalArgumentException ex) {} 275 try { 276 test.withMonthOfYear(13); 277 fail(); 278 } catch (IllegalArgumentException ex) {} 279 } 280 281 //----------------------------------------------------------------------- 282 public void testEqualsHashCode() { 283 DateTime test1 = new DateTime(TEST_TIME1); 284 DateTime test2 = new DateTime(TEST_TIME1); 285 assertEquals(true, test1.equals(test2)); 286 assertEquals(true, test2.equals(test1)); 287 assertEquals(true, test1.equals(test1)); 288 assertEquals(true, test2.equals(test2)); 289 assertEquals(true, test1.hashCode() == test2.hashCode()); 290 assertEquals(true, test1.hashCode() == test1.hashCode()); 291 assertEquals(true, test2.hashCode() == test2.hashCode()); 292 293 DateTime test3 = new DateTime(TEST_TIME2); 294 assertEquals(false, test1.equals(test3)); 295 assertEquals(false, test2.equals(test3)); 296 assertEquals(false, test3.equals(test1)); 297 assertEquals(false, test3.equals(test2)); 298 assertEquals(false, test1.hashCode() == test3.hashCode()); 299 assertEquals(false, test2.hashCode() == test3.hashCode()); 300 301 assertEquals(false, test1.equals("Hello")); 302 assertEquals(true, test1.equals(new MockInstant())); 303 assertEquals(false, test1.equals(new DateTime(TEST_TIME1, GREGORIAN_DEFAULT))); 304 assertEquals(true, new DateTime(TEST_TIME1, new MockEqualsChronology()).equals(new DateTime(TEST_TIME1, new MockEqualsChronology()))); 305 assertEquals(false, new DateTime(TEST_TIME1, new MockEqualsChronology()).equals(new DateTime(TEST_TIME1, ISO_DEFAULT))); 306 } 307 308 class MockInstant extends AbstractInstant { 309 public String toString() { 310 return null; 311 } 312 public long getMillis() { 313 return TEST_TIME1; 314 } 315 public Chronology getChronology() { 316 return ISO_DEFAULT; 317 } 318 } 319 320 class MockEqualsChronology extends BaseChronology { 321 public boolean equals(Object obj) { 322 return obj instanceof MockEqualsChronology; 323 } 324 public DateTimeZone getZone() { 325 return null; 326 } 327 public Chronology withUTC() { 328 return this; 329 } 330 public Chronology withZone(DateTimeZone zone) { 331 return this; 332 } 333 public String toString() { 334 return ""; 335 } 336 } 337 338 public void testCompareTo() { 339 DateTime test1 = new DateTime(TEST_TIME1); 340 DateTime test1a = new DateTime(TEST_TIME1); 341 assertEquals(0, test1.compareTo(test1a)); 342 assertEquals(0, test1a.compareTo(test1)); 343 assertEquals(0, test1.compareTo(test1)); 344 assertEquals(0, test1a.compareTo(test1a)); 345 346 DateTime test2 = new DateTime(TEST_TIME2); 347 assertEquals(-1, test1.compareTo(test2)); 348 assertEquals(+1, test2.compareTo(test1)); 349 350 DateTime test3 = new DateTime(TEST_TIME2, GREGORIAN_PARIS); 351 assertEquals(-1, test1.compareTo(test3)); 352 assertEquals(+1, test3.compareTo(test1)); 353 assertEquals(0, test3.compareTo(test2)); 354 355 assertEquals(+1, test2.compareTo(new MockInstant())); 356 assertEquals(0, test1.compareTo(new MockInstant())); 357 358 try { 359 test1.compareTo(null); 360 fail(); 361 } catch (NullPointerException ex) {} 362 // try { 363 // test1.compareTo(new Date()); 364 // fail(); 365 // } catch (ClassCastException ex) {} 366 } 367 368 //----------------------------------------------------------------------- 369 public void testIsEqual_long() { 370 assertEquals(false, new DateTime(TEST_TIME1).isEqual(TEST_TIME2)); 371 assertEquals(true, new DateTime(TEST_TIME1).isEqual(TEST_TIME1)); 372 assertEquals(false, new DateTime(TEST_TIME2).isEqual(TEST_TIME1)); 373 } 374 375 public void testIsEqualNow() { 376 assertEquals(false, new DateTime(TEST_TIME_NOW - 1).isEqualNow()); 377 assertEquals(true, new DateTime(TEST_TIME_NOW).isEqualNow()); 378 assertEquals(false, new DateTime(TEST_TIME_NOW + 1).isEqualNow()); 379 } 380 381 public void testIsEqual_RI() { 382 DateTime test1 = new DateTime(TEST_TIME1); 383 DateTime test1a = new DateTime(TEST_TIME1); 384 assertEquals(true, test1.isEqual(test1a)); 385 assertEquals(true, test1a.isEqual(test1)); 386 assertEquals(true, test1.isEqual(test1)); 387 assertEquals(true, test1a.isEqual(test1a)); 388 389 DateTime test2 = new DateTime(TEST_TIME2); 390 assertEquals(false, test1.isEqual(test2)); 391 assertEquals(false, test2.isEqual(test1)); 392 393 DateTime test3 = new DateTime(TEST_TIME2, GREGORIAN_PARIS); 394 assertEquals(false, test1.isEqual(test3)); 395 assertEquals(false, test3.isEqual(test1)); 396 assertEquals(true, test3.isEqual(test2)); 397 398 assertEquals(false, test2.isEqual(new MockInstant())); 399 assertEquals(true, test1.isEqual(new MockInstant())); 400 401 assertEquals(false, new DateTime(TEST_TIME_NOW + 1).isEqual(null)); 402 assertEquals(true, new DateTime(TEST_TIME_NOW).isEqual(null)); 403 assertEquals(false, new DateTime(TEST_TIME_NOW - 1).isEqual(null)); 404 } 405 406 //----------------------------------------------------------------------- 407 public void testIsBefore_long() { 408 assertEquals(true, new DateTime(TEST_TIME1).isBefore(TEST_TIME2)); 409 assertEquals(false, new DateTime(TEST_TIME1).isBefore(TEST_TIME1)); 410 assertEquals(false, new DateTime(TEST_TIME2).isBefore(TEST_TIME1)); 411 } 412 413 public void testIsBeforeNow() { 414 assertEquals(true, new DateTime(TEST_TIME_NOW - 1).isBeforeNow()); 415 assertEquals(false, new DateTime(TEST_TIME_NOW).isBeforeNow()); 416 assertEquals(false, new DateTime(TEST_TIME_NOW + 1).isBeforeNow()); 417 } 418 419 public void testIsBefore_RI() { 420 DateTime test1 = new DateTime(TEST_TIME1); 421 DateTime test1a = new DateTime(TEST_TIME1); 422 assertEquals(false, test1.isBefore(test1a)); 423 assertEquals(false, test1a.isBefore(test1)); 424 assertEquals(false, test1.isBefore(test1)); 425 assertEquals(false, test1a.isBefore(test1a)); 426 427 DateTime test2 = new DateTime(TEST_TIME2); 428 assertEquals(true, test1.isBefore(test2)); 429 assertEquals(false, test2.isBefore(test1)); 430 431 DateTime test3 = new DateTime(TEST_TIME2, GREGORIAN_PARIS); 432 assertEquals(true, test1.isBefore(test3)); 433 assertEquals(false, test3.isBefore(test1)); 434 assertEquals(false, test3.isBefore(test2)); 435 436 assertEquals(false, test2.isBefore(new MockInstant())); 437 assertEquals(false, test1.isBefore(new MockInstant())); 438 439 assertEquals(false, new DateTime(TEST_TIME_NOW + 1).isBefore(null)); 440 assertEquals(false, new DateTime(TEST_TIME_NOW).isBefore(null)); 441 assertEquals(true, new DateTime(TEST_TIME_NOW - 1).isBefore(null)); 442 } 443 444 //----------------------------------------------------------------------- 445 public void testIsAfter_long() { 446 assertEquals(false, new DateTime(TEST_TIME1).isAfter(TEST_TIME2)); 447 assertEquals(false, new DateTime(TEST_TIME1).isAfter(TEST_TIME1)); 448 assertEquals(true, new DateTime(TEST_TIME2).isAfter(TEST_TIME1)); 449 } 450 451 public void testIsAfterNow() { 452 assertEquals(false, new DateTime(TEST_TIME_NOW - 1).isAfterNow()); 453 assertEquals(false, new DateTime(TEST_TIME_NOW).isAfterNow()); 454 assertEquals(true, new DateTime(TEST_TIME_NOW + 1).isAfterNow()); 455 } 456 457 public void testIsAfter_RI() { 458 DateTime test1 = new DateTime(TEST_TIME1); 459 DateTime test1a = new DateTime(TEST_TIME1); 460 assertEquals(false, test1.isAfter(test1a)); 461 assertEquals(false, test1a.isAfter(test1)); 462 assertEquals(false, test1.isAfter(test1)); 463 assertEquals(false, test1a.isAfter(test1a)); 464 465 DateTime test2 = new DateTime(TEST_TIME2); 466 assertEquals(false, test1.isAfter(test2)); 467 assertEquals(true, test2.isAfter(test1)); 468 469 DateTime test3 = new DateTime(TEST_TIME2, GREGORIAN_PARIS); 470 assertEquals(false, test1.isAfter(test3)); 471 assertEquals(true, test3.isAfter(test1)); 472 assertEquals(false, test3.isAfter(test2)); 473 474 assertEquals(true, test2.isAfter(new MockInstant())); 475 assertEquals(false, test1.isAfter(new MockInstant())); 476 477 assertEquals(true, new DateTime(TEST_TIME_NOW + 1).isAfter(null)); 478 assertEquals(false, new DateTime(TEST_TIME_NOW).isAfter(null)); 479 assertEquals(false, new DateTime(TEST_TIME_NOW - 1).isAfter(null)); 480 } 481 482 //----------------------------------------------------------------------- 483 public void testSerialization() throws Exception { 484 DateTime test = new DateTime(TEST_TIME_NOW); 485 486 ByteArrayOutputStream baos = new ByteArrayOutputStream(); 487 ObjectOutputStream oos = new ObjectOutputStream(baos); 488 oos.writeObject(test); 489 byte[] bytes = baos.toByteArray(); 490 oos.close(); 491 492 ByteArrayInputStream bais = new ByteArrayInputStream(bytes); 493 ObjectInputStream ois = new ObjectInputStream(bais); 494 DateTime result = (DateTime) ois.readObject(); 495 ois.close(); 496 497 assertEquals(test, result); 498 } 499 500 //----------------------------------------------------------------------- 501 public void testToString() { 502 DateTime test = new DateTime(TEST_TIME_NOW); 503 assertEquals("2002-06-09T01:00:00.000+01:00", test.toString()); 504 505 test = new DateTime(TEST_TIME_NOW, PARIS); 506 assertEquals("2002-06-09T02:00:00.000+02:00", test.toString()); 507 } 508 509 public void testToString_String() { 510 DateTime test = new DateTime(TEST_TIME_NOW); 511 assertEquals("2002 01", test.toString("yyyy HH")); 512 assertEquals("2002-06-09T01:00:00.000+01:00", test.toString((String) null)); 513 } 514 515 public void testToString_String_Locale() { 516 DateTime test = new DateTime(TEST_TIME_NOW); 517 assertEquals("Sun 9/6", test.toString("EEE d/M", Locale.ENGLISH)); 518 assertEquals("dim. 9/6", test.toString("EEE d/M", Locale.FRENCH)); 519 assertEquals("2002-06-09T01:00:00.000+01:00", test.toString(null, Locale.ENGLISH)); 520 assertEquals("Sun 9/6", test.toString("EEE d/M", null)); 521 assertEquals("2002-06-09T01:00:00.000+01:00", test.toString(null, null)); 522 } 523 524 public void testToString_DTFormatter() { 525 DateMidnight test = new DateMidnight(TEST_TIME_NOW); 526 assertEquals("2002 00", test.toString(DateTimeFormat.forPattern("yyyy HH"))); 527 assertEquals("2002-06-09T00:00:00.000+01:00", test.toString((DateTimeFormatter) null)); 528 } 529 530 //----------------------------------------------------------------------- 531 public void testToInstant() { 532 DateTime test = new DateTime(TEST_TIME1); 533 Instant result = test.toInstant(); 534 assertEquals(TEST_TIME1, result.getMillis()); 535 } 536 537 public void testToDateTime() { 538 DateTime test = new DateTime(TEST_TIME1); 539 DateTime result = test.toDateTime(); 540 assertSame(test, result); 541 } 542 543 public void testToDateTimeISO() { 544 DateTime test = new DateTime(TEST_TIME1); 545 DateTime result = test.toDateTimeISO(); 546 assertSame(test, result); 547 548 test = new DateTime(TEST_TIME1, ISO_PARIS); 549 result = test.toDateTimeISO(); 550 assertSame(DateTime.class, result.getClass()); 551 assertSame(ISOChronology.class, result.getChronology().getClass()); 552 assertEquals(test.getMillis(), result.getMillis()); 553 assertEquals(ISO_PARIS, result.getChronology()); 554 assertNotSame(test, result); 555 556 test = new DateTime(TEST_TIME1, BUDDHIST_DEFAULT); 557 result = test.toDateTimeISO(); 558 assertSame(DateTime.class, result.getClass()); 559 assertSame(ISOChronology.class, result.getChronology().getClass()); 560 assertEquals(test.getMillis(), result.getMillis()); 561 assertEquals(ISO_DEFAULT, result.getChronology()); 562 assertNotSame(test, result); 563 564 test = new DateTime(TEST_TIME1, new MockNullZoneChronology()); 565 result = test.toDateTimeISO(); 566 assertSame(DateTime.class, result.getClass()); 567 assertSame(ISOChronology.class, result.getChronology().getClass()); 568 assertEquals(test.getMillis(), result.getMillis()); 569 assertEquals(ISO_DEFAULT, result.getChronology()); 570 assertNotSame(test, result); 571 } 572 573 public void testToDateTime_DateTimeZone() { 574 DateTime test = new DateTime(TEST_TIME1); 575 DateTime result = test.toDateTime(LONDON); 576 assertSame(test, result); 577 578 test = new DateTime(TEST_TIME1); 579 result = test.toDateTime(PARIS); 580 assertEquals(test.getMillis(), result.getMillis()); 581 assertEquals(PARIS, result.getZone()); 582 583 test = new DateTime(TEST_TIME1, PARIS); 584 result = test.toDateTime((DateTimeZone) null); 585 assertEquals(test.getMillis(), result.getMillis()); 586 assertEquals(LONDON, result.getZone()); 587 588 test = new DateTime(TEST_TIME1); 589 result = test.toDateTime((DateTimeZone) null); 590 assertSame(test, result); 591 } 592 593 public void testToDateTime_Chronology() { 594 DateTime test = new DateTime(TEST_TIME1); 595 DateTime result = test.toDateTime(ISO_DEFAULT); 596 assertSame(test, result); 597 598 test = new DateTime(TEST_TIME1); 599 result = test.toDateTime(GREGORIAN_PARIS); 600 assertEquals(test.getMillis(), result.getMillis()); 601 assertEquals(GREGORIAN_PARIS, result.getChronology()); 602 603 test = new DateTime(TEST_TIME1, GREGORIAN_PARIS); 604 result = test.toDateTime((Chronology) null); 605 assertEquals(test.getMillis(), result.getMillis()); 606 assertEquals(ISO_DEFAULT, result.getChronology()); 607 608 test = new DateTime(TEST_TIME1); 609 result = test.toDateTime((Chronology) null); 610 assertSame(test, result); 611 } 612 613 public void testToMutableDateTime() { 614 DateTime test = new DateTime(TEST_TIME1, PARIS); 615 MutableDateTime result = test.toMutableDateTime(); 616 assertEquals(test.getMillis(), result.getMillis()); 617 assertEquals(ISO_PARIS, result.getChronology()); 618 } 619 620 public void testToMutableDateTimeISO() { 621 DateTime test = new DateTime(TEST_TIME1, PARIS); 622 MutableDateTime result = test.toMutableDateTimeISO(); 623 assertSame(MutableDateTime.class, result.getClass()); 624 assertSame(ISOChronology.class, result.getChronology().getClass()); 625 assertEquals(test.getMillis(), result.getMillis()); 626 assertEquals(ISO_PARIS, result.getChronology()); 627 } 628 629 public void testToMutableDateTime_DateTimeZone() { 630 DateTime test = new DateTime(TEST_TIME1); 631 MutableDateTime result = test.toMutableDateTime(LONDON); 632 assertEquals(test.getMillis(), result.getMillis()); 633 assertEquals(ISO_DEFAULT, result.getChronology()); 634 635 test = new DateTime(TEST_TIME1); 636 result = test.toMutableDateTime(PARIS); 637 assertEquals(test.getMillis(), result.getMillis()); 638 assertEquals(ISO_PARIS, result.getChronology()); 639 640 test = new DateTime(TEST_TIME1, PARIS); 641 result = test.toMutableDateTime((DateTimeZone) null); 642 assertEquals(test.getMillis(), result.getMillis()); 643 assertEquals(ISO_DEFAULT, result.getChronology()); 644 645 test = new DateTime(TEST_TIME1); 646 result = test.toMutableDateTime((DateTimeZone) null); 647 assertEquals(test.getMillis(), result.getMillis()); 648 assertEquals(ISO_DEFAULT, result.getChronology()); 649 } 650 651 public void testToMutableDateTime_Chronology() { 652 DateTime test = new DateTime(TEST_TIME1); 653 MutableDateTime result = test.toMutableDateTime(ISO_DEFAULT); 654 assertEquals(test.getMillis(), result.getMillis()); 655 assertEquals(ISO_DEFAULT, result.getChronology()); 656 657 test = new DateTime(TEST_TIME1); 658 result = test.toMutableDateTime(GREGORIAN_PARIS); 659 assertEquals(test.getMillis(), result.getMillis()); 660 assertEquals(GREGORIAN_PARIS, result.getChronology()); 661 662 test = new DateTime(TEST_TIME1, GREGORIAN_PARIS); 663 result = test.toMutableDateTime((Chronology) null); 664 assertEquals(test.getMillis(), result.getMillis()); 665 assertEquals(ISO_DEFAULT, result.getChronology()); 666 667 test = new DateTime(TEST_TIME1); 668 result = test.toMutableDateTime((Chronology) null); 669 assertEquals(test.getMillis(), result.getMillis()); 670 assertEquals(ISO_DEFAULT, result.getChronology()); 671 } 672 673 public void testToDate() { 674 DateTime test = new DateTime(TEST_TIME1); 675 Date result = test.toDate(); 676 assertEquals(test.getMillis(), result.getTime()); 677 } 678 679 public void testToCalendar_Locale() { 680 DateTime test = new DateTime(TEST_TIME1); 681 Calendar result = test.toCalendar(null); 682 assertEquals(test.getMillis(), result.getTime().getTime()); 683 assertEquals(TimeZone.getTimeZone("Europe/London"), result.getTimeZone()); 684 685 test = new DateTime(TEST_TIME1, PARIS); 686 result = test.toCalendar(null); 687 assertEquals(test.getMillis(), result.getTime().getTime()); 688 assertEquals(TimeZone.getTimeZone("Europe/Paris"), result.getTimeZone()); 689 690 test = new DateTime(TEST_TIME1, PARIS); 691 result = test.toCalendar(Locale.UK); 692 assertEquals(test.getMillis(), result.getTime().getTime()); 693 assertEquals(TimeZone.getTimeZone("Europe/Paris"), result.getTimeZone()); 694 } 695 696 public void testToGregorianCalendar() { 697 DateTime test = new DateTime(TEST_TIME1); 698 GregorianCalendar result = test.toGregorianCalendar(); 699 assertEquals(test.getMillis(), result.getTime().getTime()); 700 assertEquals(TimeZone.getTimeZone("Europe/London"), result.getTimeZone()); 701 702 test = new DateTime(TEST_TIME1, PARIS); 703 result = test.toGregorianCalendar(); 704 assertEquals(test.getMillis(), result.getTime().getTime()); 705 assertEquals(TimeZone.getTimeZone("Europe/Paris"), result.getTimeZone()); 706 } 707 708 //----------------------------------------------------------------------- 709 public void testToDateMidnight() { 710 DateTime base = new DateTime(TEST_TIME1, COPTIC_DEFAULT); 711 DateMidnight test = base.toDateMidnight(); 712 assertEquals(new DateMidnight(base, COPTIC_DEFAULT), test); 713 } 714 715 public void testToYearMonthDay() { 716 DateTime base = new DateTime(TEST_TIME1, COPTIC_DEFAULT); 717 YearMonthDay test = base.toYearMonthDay(); 718 assertEquals(new YearMonthDay(TEST_TIME1, COPTIC_DEFAULT), test); 719 } 720 721 public void testToTimeOfDay() { 722 DateTime base = new DateTime(TEST_TIME1, COPTIC_DEFAULT); 723 TimeOfDay test = base.toTimeOfDay(); 724 assertEquals(new TimeOfDay(TEST_TIME1, COPTIC_DEFAULT), test); 725 } 726 727 public void testToLocalDateTime() { 728 DateTime base = new DateTime(TEST_TIME1, COPTIC_DEFAULT); 729 LocalDateTime test = base.toLocalDateTime(); 730 assertEquals(new LocalDateTime(TEST_TIME1, COPTIC_DEFAULT), test); 731 } 732 733 public void testToLocalDate() { 734 DateTime base = new DateTime(TEST_TIME1, COPTIC_DEFAULT); 735 LocalDate test = base.toLocalDate(); 736 assertEquals(new LocalDate(TEST_TIME1, COPTIC_DEFAULT), test); 737 } 738 739 public void testToLocalTime() { 740 DateTime base = new DateTime(TEST_TIME1, COPTIC_DEFAULT); 741 LocalTime test = base.toLocalTime(); 742 assertEquals(new LocalTime(TEST_TIME1, COPTIC_DEFAULT), test); 743 } 744 745 //----------------------------------------------------------------------- 746 public void testWithMillis_long() { 747 DateTime test = new DateTime(TEST_TIME1); 748 DateTime result = test.withMillis(TEST_TIME2); 749 assertEquals(TEST_TIME2, result.getMillis()); 750 assertEquals(test.getChronology(), result.getChronology()); 751 752 test = new DateTime(TEST_TIME1, GREGORIAN_PARIS); 753 result = test.withMillis(TEST_TIME2); 754 assertEquals(TEST_TIME2, result.getMillis()); 755 assertEquals(test.getChronology(), result.getChronology()); 756 757 test = new DateTime(TEST_TIME1); 758 result = test.withMillis(TEST_TIME1); 759 assertSame(test, result); 760 } 761 762 public void testWithChronology_Chronology() { 763 DateTime test = new DateTime(TEST_TIME1); 764 DateTime result = test.withChronology(GREGORIAN_PARIS); 765 assertEquals(test.getMillis(), result.getMillis()); 766 assertEquals(GREGORIAN_PARIS, result.getChronology()); 767 768 test = new DateTime(TEST_TIME1, GREGORIAN_PARIS); 769 result = test.withChronology(null); 770 assertEquals(test.getMillis(), result.getMillis()); 771 assertEquals(ISO_DEFAULT, result.getChronology()); 772 773 test = new DateTime(TEST_TIME1); 774 result = test.withChronology(null); 775 assertEquals(test.getMillis(), result.getMillis()); 776 assertEquals(ISO_DEFAULT, result.getChronology()); 777 778 test = new DateTime(TEST_TIME1); 779 result = test.withChronology(ISO_DEFAULT); 780 assertSame(test, result); 781 } 782 783 public void testWithZone_DateTimeZone() { 784 DateTime test = new DateTime(TEST_TIME1); 785 DateTime result = test.withZone(PARIS); 786 assertEquals(test.getMillis(), result.getMillis()); 787 assertEquals(ISO_PARIS, result.getChronology()); 788 789 test = new DateTime(TEST_TIME1, GREGORIAN_PARIS); 790 result = test.withZone(null); 791 assertEquals(test.getMillis(), result.getMillis()); 792 assertEquals(GREGORIAN_DEFAULT, result.getChronology()); 793 794 test = new DateTime(TEST_TIME1); 795 result = test.withZone(null); 796 assertSame(test, result); 797 } 798 799 public void testWithZoneRetainFields_DateTimeZone() { 800 DateTime test = new DateTime(TEST_TIME1); 801 DateTime result = test.withZoneRetainFields(PARIS); 802 assertEquals(test.getMillis() - DateTimeConstants.MILLIS_PER_HOUR, result.getMillis()); 803 assertEquals(ISO_PARIS, result.getChronology()); 804 805 test = new DateTime(TEST_TIME1); 806 result = test.withZoneRetainFields(LONDON); 807 assertSame(test, result); 808 809 test = new DateTime(TEST_TIME1); 810 result = test.withZoneRetainFields(null); 811 assertSame(test, result); 812 813 test = new DateTime(TEST_TIME1, GREGORIAN_PARIS); 814 result = test.withZoneRetainFields(null); 815 assertEquals(test.getMillis() + DateTimeConstants.MILLIS_PER_HOUR, result.getMillis()); 816 assertEquals(GREGORIAN_DEFAULT, result.getChronology()); 817 818 test = new DateTime(TEST_TIME1, new MockNullZoneChronology()); 819 result = test.withZoneRetainFields(LONDON); 820 assertSame(test, result); 821 } 822 823 //----------------------------------------------------------------------- 824 public void testWithDate_int_int_int() { 825 DateTime test = new DateTime(2002, 4, 5, 1, 2, 3, 4, ISO_UTC); 826 DateTime result = test.withDate(2003, 5, 6); 827 DateTime expected = new DateTime(2003, 5, 6, 1, 2, 3, 4, ISO_UTC); 828 assertEquals(expected, result); 829 830 test = new DateTime(TEST_TIME1); 831 try { 832 test.withDate(2003, 13, 1); 833 fail(); 834 } catch (IllegalArgumentException ex) {} 835 } 836 837 public void testWithTime_int_int_int() { 838 DateTime test = new DateTime(TEST_TIME1 - 12345L, BUDDHIST_UTC); 839 DateTime result = test.withTime(12, 24, 0, 0); 840 assertEquals(TEST_TIME1, result.getMillis()); 841 assertEquals(BUDDHIST_UTC, result.getChronology()); 842 843 test = new DateTime(TEST_TIME1); 844 try { 845 test.withTime(25, 1, 1, 1); 846 fail(); 847 } catch (IllegalArgumentException ex) {} 848 } 849 850 public void testWithFields_RPartial() { 851 DateTime test = new DateTime(2004, 5, 6, 7, 8, 9, 0); 852 DateTime result = test.withFields(new YearMonthDay(2003, 4, 5)); 853 DateTime expected = new DateTime(2003, 4, 5, 7, 8, 9, 0); 854 assertEquals(expected, result); 855 856 test = new DateTime(TEST_TIME1); 857 result = test.withFields(null); 858 assertSame(test, result); 859 } 860 861 //----------------------------------------------------------------------- 862 public void testWithField1() { 863 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0); 864 DateTime result = test.withField(DateTimeFieldType.year(), 2006); 865 866 assertEquals(new DateTime(2004, 6, 9, 0, 0, 0, 0), test); 867 assertEquals(new DateTime(2006, 6, 9, 0, 0, 0, 0), result); 868 } 869 870 public void testWithField2() { 871 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0); 872 try { 873 test.withField(null, 6); 874 fail(); 875 } catch (IllegalArgumentException ex) {} 876 } 877 878 //----------------------------------------------------------------------- 879 public void testWithFieldAdded1() { 880 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0); 881 DateTime result = test.withFieldAdded(DurationFieldType.years(), 6); 882 883 assertEquals(new DateTime(2004, 6, 9, 0, 0, 0, 0), test); 884 assertEquals(new DateTime(2010, 6, 9, 0, 0, 0, 0), result); 885 } 886 887 public void testWithFieldAdded2() { 888 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0); 889 try { 890 test.withFieldAdded(null, 0); 891 fail(); 892 } catch (IllegalArgumentException ex) {} 893 } 894 895 public void testWithFieldAdded3() { 896 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0); 897 try { 898 test.withFieldAdded(null, 6); 899 fail(); 900 } catch (IllegalArgumentException ex) {} 901 } 902 903 public void testWithFieldAdded4() { 904 DateTime test = new DateTime(2004, 6, 9, 0, 0, 0, 0); 905 DateTime result = test.withFieldAdded(DurationFieldType.years(), 0); 906 assertSame(test, result); 907 } 908 909 //----------------------------------------------------------------------- 910 public void testWithDurationAdded_long_int() { 911 DateTime test = new DateTime(TEST_TIME1, BUDDHIST_DEFAULT); 912 DateTime result = test.withDurationAdded(123456789L, 1); 913 DateTime expected = new DateTime(TEST_TIME1 + 123456789L, BUDDHIST_DEFAULT); 914 assertEquals(expected, result); 915 916 result = test.withDurationAdded(123456789L, 0); 917 assertSame(test, result); 918 919 result = test.withDurationAdded(123456789L, 2); 920 expected = new DateTime(TEST_TIME1 + (2L * 123456789L), BUDDHIST_DEFAULT); 921 assertEquals(expected, result); 922 923 result = test.withDurationAdded(123456789L, -3); 924 expected = new DateTime(TEST_TIME1 - (3L * 123456789L), BUDDHIST_DEFAULT); 925 assertEquals(expected, result); 926 } 927 928 //----------------------------------------------------------------------- 929 public void testWithDurationAdded_RD_int() { 930 DateTime test = new DateTime(TEST_TIME1, BUDDHIST_DEFAULT); 931 DateTime result = test.withDurationAdded(new Duration(123456789L), 1); 932 DateTime expected = new DateTime(TEST_TIME1 + 123456789L, BUDDHIST_DEFAULT); 933 assertEquals(expected, result); 934 935 result = test.withDurationAdded(null, 1); 936 assertSame(test, result); 937 938 result = test.withDurationAdded(new Duration(123456789L), 0); 939 assertSame(test, result); 940 941 result = test.withDurationAdded(new Duration(123456789L), 2); 942 expected = new DateTime(TEST_TIME1 + (2L * 123456789L), BUDDHIST_DEFAULT); 943 assertEquals(expected, result); 944 945 result = test.withDurationAdded(new Duration(123456789L), -3); 946 expected = new DateTime(TEST_TIME1 - (3L * 123456789L), BUDDHIST_DEFAULT); 947 assertEquals(expected, result); 948 } 949 950 //----------------------------------------------------------------------- 951 public void testWithDurationAdded_RP_int() { 952 DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT); 953 DateTime result = test.withPeriodAdded(new Period(1, 2, 3, 4, 5, 6, 7, 8), 1); 954 DateTime expected = new DateTime(2003, 7, 28, 6, 8, 10, 12, BUDDHIST_DEFAULT); 955 assertEquals(expected, result); 956 957 result = test.withPeriodAdded(null, 1); 958 assertSame(test, result); 959 960 result = test.withPeriodAdded(new Period(1, 2, 3, 4, 5, 6, 7, 8), 0); 961 assertSame(test, result); 962 963 result = test.withPeriodAdded(new Period(1, 2, 0, 4, 5, 6, 7, 8), 3); 964 expected = new DateTime(2005, 11, 15, 16, 20, 24, 28, BUDDHIST_DEFAULT); 965 assertEquals(expected, result); 966 967 result = test.withPeriodAdded(new Period(1, 2, 0, 1, 1, 2, 3, 4), -1); 968 expected = new DateTime(2001, 3, 2, 0, 0, 0, 0, BUDDHIST_DEFAULT); 969 assertEquals(expected, result); 970 } 971 972 //----------------------------------------------------------------------- 973 public void testPlus_long() { 974 DateTime test = new DateTime(TEST_TIME1, BUDDHIST_DEFAULT); 975 DateTime result = test.plus(123456789L); 976 DateTime expected = new DateTime(TEST_TIME1 + 123456789L, BUDDHIST_DEFAULT); 977 assertEquals(expected, result); 978 } 979 980 public void testPlus_RD() { 981 DateTime test = new DateTime(TEST_TIME1, BUDDHIST_DEFAULT); 982 DateTime result = test.plus(new Duration(123456789L)); 983 DateTime expected = new DateTime(TEST_TIME1 + 123456789L, BUDDHIST_DEFAULT); 984 assertEquals(expected, result); 985 986 result = test.plus((ReadableDuration) null); 987 assertSame(test, result); 988 } 989 990 public void testPlus_RP() { 991 DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT); 992 DateTime result = test.plus(new Period(1, 2, 3, 4, 5, 6, 7, 8)); 993 DateTime expected = new DateTime(2003, 7, 28, 6, 8, 10, 12, BUDDHIST_DEFAULT); 994 assertEquals(expected, result); 995 996 result = test.plus((ReadablePeriod) null); 997 assertSame(test, result); 998 } 999 1000 public void testPlusYears_int() { 1001 DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1002 DateTime result = test.plusYears(1); 1003 DateTime expected = new DateTime(2003, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1004 assertEquals(expected, result); 1005 1006 result = test.plusYears(0); 1007 assertSame(test, result); 1008 } 1009 1010 public void testPlusMonths_int() { 1011 DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1012 DateTime result = test.plusMonths(1); 1013 DateTime expected = new DateTime(2002, 6, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1014 assertEquals(expected, result); 1015 1016 result = test.plusMonths(0); 1017 assertSame(test, result); 1018 } 1019 1020 public void testPlusWeeks_int() { 1021 DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1022 DateTime result = test.plusWeeks(1); 1023 DateTime expected = new DateTime(2002, 5, 10, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1024 assertEquals(expected, result); 1025 1026 result = test.plusWeeks(0); 1027 assertSame(test, result); 1028 } 1029 1030 public void testPlusDays_int() { 1031 DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1032 DateTime result = test.plusDays(1); 1033 DateTime expected = new DateTime(2002, 5, 4, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1034 assertEquals(expected, result); 1035 1036 result = test.plusDays(0); 1037 assertSame(test, result); 1038 } 1039 1040 public void testPlusHours_int() { 1041 DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1042 DateTime result = test.plusHours(1); 1043 DateTime expected = new DateTime(2002, 5, 3, 2, 2, 3, 4, BUDDHIST_DEFAULT); 1044 assertEquals(expected, result); 1045 1046 result = test.plusHours(0); 1047 assertSame(test, result); 1048 } 1049 1050 public void testPlusMinutes_int() { 1051 DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1052 DateTime result = test.plusMinutes(1); 1053 DateTime expected = new DateTime(2002, 5, 3, 1, 3, 3, 4, BUDDHIST_DEFAULT); 1054 assertEquals(expected, result); 1055 1056 result = test.plusMinutes(0); 1057 assertSame(test, result); 1058 } 1059 1060 public void testPlusSeconds_int() { 1061 DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1062 DateTime result = test.plusSeconds(1); 1063 DateTime expected = new DateTime(2002, 5, 3, 1, 2, 4, 4, BUDDHIST_DEFAULT); 1064 assertEquals(expected, result); 1065 1066 result = test.plusSeconds(0); 1067 assertSame(test, result); 1068 } 1069 1070 public void testPlusMillis_int() { 1071 DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1072 DateTime result = test.plusMillis(1); 1073 DateTime expected = new DateTime(2002, 5, 3, 1, 2, 3, 5, BUDDHIST_DEFAULT); 1074 assertEquals(expected, result); 1075 1076 result = test.plusMillis(0); 1077 assertSame(test, result); 1078 } 1079 1080 //----------------------------------------------------------------------- 1081 public void testMinus_long() { 1082 DateTime test = new DateTime(TEST_TIME1, BUDDHIST_DEFAULT); 1083 DateTime result = test.minus(123456789L); 1084 DateTime expected = new DateTime(TEST_TIME1 - 123456789L, BUDDHIST_DEFAULT); 1085 assertEquals(expected, result); 1086 } 1087 1088 public void testMinus_RD() { 1089 DateTime test = new DateTime(TEST_TIME1, BUDDHIST_DEFAULT); 1090 DateTime result = test.minus(new Duration(123456789L)); 1091 DateTime expected = new DateTime(TEST_TIME1 - 123456789L, BUDDHIST_DEFAULT); 1092 assertEquals(expected, result); 1093 1094 result = test.minus((ReadableDuration) null); 1095 assertSame(test, result); 1096 } 1097 1098 public void testMinus_RP() { 1099 DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1100 DateTime result = test.minus(new Period(1, 1, 1, 1, 1, 1, 1, 1)); 1101 DateTime expected = new DateTime(2001, 3, 26, 0, 1, 2, 3, BUDDHIST_DEFAULT); 1102 assertEquals(expected, result); 1103 1104 result = test.minus((ReadablePeriod) null); 1105 assertSame(test, result); 1106 } 1107 1108 public void testMinusYears_int() { 1109 DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1110 DateTime result = test.minusYears(1); 1111 DateTime expected = new DateTime(2001, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1112 assertEquals(expected, result); 1113 1114 result = test.minusYears(0); 1115 assertSame(test, result); 1116 } 1117 1118 public void testMinusMonths_int() { 1119 DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1120 DateTime result = test.minusMonths(1); 1121 DateTime expected = new DateTime(2002, 4, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1122 assertEquals(expected, result); 1123 1124 result = test.minusMonths(0); 1125 assertSame(test, result); 1126 } 1127 1128 public void testMinusWeeks_int() { 1129 DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1130 DateTime result = test.minusWeeks(1); 1131 DateTime expected = new DateTime(2002, 4, 26, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1132 assertEquals(expected, result); 1133 1134 result = test.minusWeeks(0); 1135 assertSame(test, result); 1136 } 1137 1138 public void testMinusDays_int() { 1139 DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1140 DateTime result = test.minusDays(1); 1141 DateTime expected = new DateTime(2002, 5, 2, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1142 assertEquals(expected, result); 1143 1144 result = test.minusDays(0); 1145 assertSame(test, result); 1146 } 1147 1148 public void testMinusHours_int() { 1149 DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1150 DateTime result = test.minusHours(1); 1151 DateTime expected = new DateTime(2002, 5, 3, 0, 2, 3, 4, BUDDHIST_DEFAULT); 1152 assertEquals(expected, result); 1153 1154 result = test.minusHours(0); 1155 assertSame(test, result); 1156 } 1157 1158 public void testMinusMinutes_int() { 1159 DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1160 DateTime result = test.minusMinutes(1); 1161 DateTime expected = new DateTime(2002, 5, 3, 1, 1, 3, 4, BUDDHIST_DEFAULT); 1162 assertEquals(expected, result); 1163 1164 result = test.minusMinutes(0); 1165 assertSame(test, result); 1166 } 1167 1168 public void testMinusSeconds_int() { 1169 DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1170 DateTime result = test.minusSeconds(1); 1171 DateTime expected = new DateTime(2002, 5, 3, 1, 2, 2, 4, BUDDHIST_DEFAULT); 1172 assertEquals(expected, result); 1173 1174 result = test.minusSeconds(0); 1175 assertSame(test, result); 1176 } 1177 1178 public void testMinusMillis_int() { 1179 DateTime test = new DateTime(2002, 5, 3, 1, 2, 3, 4, BUDDHIST_DEFAULT); 1180 DateTime result = test.minusMillis(1); 1181 DateTime expected = new DateTime(2002, 5, 3, 1, 2, 3, 3, BUDDHIST_DEFAULT); 1182 assertEquals(expected, result); 1183 1184 result = test.minusMillis(0); 1185 assertSame(test, result); 1186 } 1187 1188 //----------------------------------------------------------------------- 1189 public void testProperty() { 1190 DateTime test = new DateTime(); 1191 assertEquals(test.year(), test.property(DateTimeFieldType.year())); 1192 assertEquals(test.dayOfWeek(), test.property(DateTimeFieldType.dayOfWeek())); 1193 assertEquals(test.secondOfMinute(), test.property(DateTimeFieldType.secondOfMinute())); 1194 assertEquals(test.millisOfSecond(), test.property(DateTimeFieldType.millisOfSecond())); 1195 DateTimeFieldType bad = new DateTimeFieldType("bad") { 1196 public DurationFieldType getDurationType() { 1197 return DurationFieldType.weeks(); 1198 } 1199 public DurationFieldType getRangeDurationType() { 1200 return null; 1201 } 1202 public DateTimeField getField(Chronology chronology) { 1203 return UnsupportedDateTimeField.getInstance(this, UnsupportedDurationField.getInstance(getDurationType())); 1204 } 1205 }; 1206 try { 1207 test.property(bad); 1208 fail(); 1209 } catch (IllegalArgumentException ex) {} 1210 try { 1211 test.property(null); 1212 fail(); 1213 } catch (IllegalArgumentException ex) {} 1214 } 1215 1216 //----------------------------------------------------------------------- 1217 private void check(DateTime test, int year, int month, int day, int hour, int min, int sec, int mil) { 1218 assertEquals(year, test.getYear()); 1219 assertEquals(month, test.getMonthOfYear()); 1220 assertEquals(day, test.getDayOfMonth()); 1221 assertEquals(hour, test.getHourOfDay()); 1222 assertEquals(min, test.getMinuteOfHour()); 1223 assertEquals(sec, test.getSecondOfMinute()); 1224 assertEquals(mil, test.getMillisOfSecond()); 1225 } 1226 1227 }