001 /* 002 * Copyright 2001-2007 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.util.Locale; 019 import java.util.TimeZone; 020 021 import junit.framework.TestCase; 022 import junit.framework.TestSuite; 023 024 import org.joda.time.chrono.CopticChronology; 025 import org.joda.time.chrono.ISOChronology; 026 027 /** 028 * This class is a JUnit test for Duration. 029 * 030 * @author Stephen Colebourne 031 */ 032 public class TestPeriod_Constructors extends TestCase { 033 // Test in 2002/03 as time zones are more well known 034 // (before the late 90's they were all over the place) 035 036 private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London"); 037 038 long y2002days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 039 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 040 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 041 366 + 365; 042 long y2003days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 043 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 044 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 045 366 + 365 + 365; 046 047 // 2002-06-09 048 private long TEST_TIME_NOW = 049 (y2002days + 31L + 28L + 31L + 30L + 31L + 9L -1L) * DateTimeConstants.MILLIS_PER_DAY; 050 051 private DateTimeZone originalDateTimeZone = null; 052 private TimeZone originalTimeZone = null; 053 private Locale originalLocale = null; 054 055 public static void main(String[] args) { 056 junit.textui.TestRunner.run(suite()); 057 } 058 059 public static TestSuite suite() { 060 return new TestSuite(TestPeriod_Constructors.class); 061 } 062 063 public TestPeriod_Constructors(String name) { 064 super(name); 065 } 066 067 protected void setUp() throws Exception { 068 DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW); 069 originalDateTimeZone = DateTimeZone.getDefault(); 070 originalTimeZone = TimeZone.getDefault(); 071 originalLocale = Locale.getDefault(); 072 DateTimeZone.setDefault(LONDON); 073 TimeZone.setDefault(TimeZone.getTimeZone("Europe/London")); 074 Locale.setDefault(Locale.UK); 075 } 076 077 protected void tearDown() throws Exception { 078 DateTimeUtils.setCurrentMillisSystem(); 079 DateTimeZone.setDefault(originalDateTimeZone); 080 TimeZone.setDefault(originalTimeZone); 081 Locale.setDefault(originalLocale); 082 originalDateTimeZone = null; 083 originalTimeZone = null; 084 originalLocale = null; 085 } 086 087 //----------------------------------------------------------------------- 088 public void testConstants() throws Throwable { 089 Period test = Period.ZERO; 090 assertEquals(PeriodType.standard(), test.getPeriodType()); 091 assertEquals(0, test.getYears()); 092 assertEquals(0, test.getMonths()); 093 assertEquals(0, test.getWeeks()); 094 assertEquals(0, test.getDays()); 095 assertEquals(0, test.getHours()); 096 assertEquals(0, test.getMinutes()); 097 assertEquals(0, test.getSeconds()); 098 assertEquals(0, test.getMillis()); 099 } 100 101 //----------------------------------------------------------------------- 102 public void testParse_noFormatter() throws Throwable { 103 assertEquals(new Period(1, 2, 3, 4, 5, 6, 7, 890), Period.parse("P1Y2M3W4DT5H6M7.890S")); 104 } 105 106 //----------------------------------------------------------------------- 107 public void testConstructor1() throws Throwable { 108 Period test = new Period(); 109 assertEquals(PeriodType.standard(), test.getPeriodType()); 110 assertEquals(0, test.getYears()); 111 assertEquals(0, test.getMonths()); 112 assertEquals(0, test.getWeeks()); 113 assertEquals(0, test.getDays()); 114 assertEquals(0, test.getHours()); 115 assertEquals(0, test.getMinutes()); 116 assertEquals(0, test.getSeconds()); 117 assertEquals(0, test.getMillis()); 118 } 119 120 //----------------------------------------------------------------------- 121 public void testConstructor_long1() throws Throwable { 122 long length = 4 * DateTimeConstants.MILLIS_PER_DAY + 123 5 * DateTimeConstants.MILLIS_PER_HOUR + 124 6 * DateTimeConstants.MILLIS_PER_MINUTE + 125 7 * DateTimeConstants.MILLIS_PER_SECOND + 8; 126 Period test = new Period(length); 127 assertEquals(PeriodType.standard(), test.getPeriodType()); 128 assertEquals(0, test.getYears()); 129 assertEquals(0, test.getMonths()); 130 assertEquals(0, test.getWeeks()); 131 assertEquals(0, test.getDays()); 132 assertEquals((4 * 24) + 5, test.getHours()); 133 assertEquals(6, test.getMinutes()); 134 assertEquals(7, test.getSeconds()); 135 assertEquals(8, test.getMillis()); 136 } 137 138 public void testConstructor_long2() throws Throwable { 139 long length = 140 5 * DateTimeConstants.MILLIS_PER_HOUR + 141 6 * DateTimeConstants.MILLIS_PER_MINUTE + 142 7 * DateTimeConstants.MILLIS_PER_SECOND + 8; 143 Period test = new Period(length); 144 assertEquals(PeriodType.standard(), test.getPeriodType()); 145 assertEquals(0, test.getYears()); 146 assertEquals(0, test.getMonths()); 147 assertEquals(0, test.getWeeks()); 148 assertEquals(0, test.getDays()); 149 assertEquals(5, test.getHours()); 150 assertEquals(6, test.getMinutes()); 151 assertEquals(7, test.getSeconds()); 152 assertEquals(8, test.getMillis()); 153 } 154 155 public void testConstructor_long3() throws Throwable { 156 long length = 157 (4L + (3L * 7L) + (2L * 30L) + 365L) * DateTimeConstants.MILLIS_PER_DAY + 158 5L * DateTimeConstants.MILLIS_PER_HOUR + 159 6L * DateTimeConstants.MILLIS_PER_MINUTE + 160 7L * DateTimeConstants.MILLIS_PER_SECOND + 8L; 161 Period test = new Period(length); 162 assertEquals(PeriodType.standard(), test.getPeriodType()); 163 // only time fields are precise in AllType 164 assertEquals(0, test.getYears()); // (4 + (3 * 7) + (2 * 30) + 365) == 450 165 assertEquals(0, test.getMonths()); 166 assertEquals(0, test.getWeeks()); 167 assertEquals(0, test.getDays()); 168 assertEquals((450 * 24) + 5, test.getHours()); 169 assertEquals(6, test.getMinutes()); 170 assertEquals(7, test.getSeconds()); 171 assertEquals(8, test.getMillis()); 172 } 173 174 public void testConstructor_long_fixedZone() throws Throwable { 175 DateTimeZone zone = DateTimeZone.getDefault(); 176 try { 177 DateTimeZone.setDefault(DateTimeZone.forOffsetHours(2)); 178 long length = 179 (4L + (3L * 7L) + (2L * 30L) + 365L) * DateTimeConstants.MILLIS_PER_DAY + 180 5L * DateTimeConstants.MILLIS_PER_HOUR + 181 6L * DateTimeConstants.MILLIS_PER_MINUTE + 182 7L * DateTimeConstants.MILLIS_PER_SECOND + 8L; 183 Period test = new Period(length); 184 assertEquals(PeriodType.standard(), test.getPeriodType()); 185 // only time fields are precise in AllType 186 assertEquals(0, test.getYears()); // (4 + (3 * 7) + (2 * 30) + 365) == 450 187 assertEquals(0, test.getMonths()); 188 assertEquals(0, test.getWeeks()); 189 assertEquals(0, test.getDays()); 190 assertEquals((450 * 24) + 5, test.getHours()); 191 assertEquals(6, test.getMinutes()); 192 assertEquals(7, test.getSeconds()); 193 assertEquals(8, test.getMillis()); 194 } finally { 195 DateTimeZone.setDefault(zone); 196 } 197 } 198 199 //----------------------------------------------------------------------- 200 public void testConstructor_long_PeriodType1() throws Throwable { 201 long length = 4 * DateTimeConstants.MILLIS_PER_DAY + 202 5 * DateTimeConstants.MILLIS_PER_HOUR + 203 6 * DateTimeConstants.MILLIS_PER_MINUTE + 204 7 * DateTimeConstants.MILLIS_PER_SECOND + 8; 205 Period test = new Period(length, (PeriodType) null); 206 assertEquals(PeriodType.standard(), test.getPeriodType()); 207 assertEquals(0, test.getYears()); 208 assertEquals(0, test.getMonths()); 209 assertEquals(0, test.getWeeks()); 210 assertEquals(0, test.getDays()); 211 assertEquals((4 * 24) + 5, test.getHours()); 212 assertEquals(6, test.getMinutes()); 213 assertEquals(7, test.getSeconds()); 214 assertEquals(8, test.getMillis()); 215 } 216 217 public void testConstructor_long_PeriodType2() throws Throwable { 218 long length = 4 * DateTimeConstants.MILLIS_PER_DAY + 219 5 * DateTimeConstants.MILLIS_PER_HOUR + 220 6 * DateTimeConstants.MILLIS_PER_MINUTE + 221 7 * DateTimeConstants.MILLIS_PER_SECOND + 8; 222 Period test = new Period(length, PeriodType.millis()); 223 assertEquals(PeriodType.millis(), test.getPeriodType()); 224 assertEquals(0, test.getYears()); 225 assertEquals(0, test.getMonths()); 226 assertEquals(0, test.getWeeks()); 227 assertEquals(0, test.getDays()); 228 assertEquals(0, test.getHours()); 229 assertEquals(0, test.getMinutes()); 230 assertEquals(0, test.getSeconds()); 231 assertEquals(length, test.getMillis()); 232 } 233 234 public void testConstructor_long_PeriodType3() throws Throwable { 235 long length = 4 * DateTimeConstants.MILLIS_PER_DAY + 236 5 * DateTimeConstants.MILLIS_PER_HOUR + 237 6 * DateTimeConstants.MILLIS_PER_MINUTE + 238 7 * DateTimeConstants.MILLIS_PER_SECOND + 8; 239 Period test = new Period(length, PeriodType.dayTime()); 240 assertEquals(PeriodType.dayTime(), test.getPeriodType()); 241 assertEquals(0, test.getYears()); 242 assertEquals(0, test.getMonths()); 243 assertEquals(0, test.getWeeks()); 244 assertEquals(0, test.getDays()); 245 assertEquals((4 * 24) + 5, test.getHours()); 246 assertEquals(6, test.getMinutes()); 247 assertEquals(7, test.getSeconds()); 248 assertEquals(8, test.getMillis()); 249 } 250 251 public void testConstructor_long_PeriodType4() throws Throwable { 252 long length = 253 5 * DateTimeConstants.MILLIS_PER_HOUR + 254 6 * DateTimeConstants.MILLIS_PER_MINUTE + 255 7 * DateTimeConstants.MILLIS_PER_SECOND + 8; 256 Period test = new Period(length, PeriodType.standard().withMillisRemoved()); 257 assertEquals(PeriodType.standard().withMillisRemoved(), test.getPeriodType()); 258 assertEquals(0, test.getYears()); 259 assertEquals(0, test.getMonths()); 260 assertEquals(0, test.getWeeks()); 261 assertEquals(0, test.getDays()); 262 assertEquals(5, test.getHours()); 263 assertEquals(6, test.getMinutes()); 264 assertEquals(7, test.getSeconds()); 265 assertEquals(0, test.getMillis()); 266 } 267 268 //----------------------------------------------------------------------- 269 public void testConstructor_long_Chronology1() throws Throwable { 270 long length = 4 * DateTimeConstants.MILLIS_PER_DAY + 271 5 * DateTimeConstants.MILLIS_PER_HOUR + 272 6 * DateTimeConstants.MILLIS_PER_MINUTE + 273 7 * DateTimeConstants.MILLIS_PER_SECOND + 8; 274 Period test = new Period(length, ISOChronology.getInstance()); 275 assertEquals(PeriodType.standard(), test.getPeriodType()); 276 assertEquals(0, test.getYears()); 277 assertEquals(0, test.getMonths()); 278 assertEquals(0, test.getWeeks()); 279 assertEquals(0, test.getDays()); 280 assertEquals((4 * 24) + 5, test.getHours()); 281 assertEquals(6, test.getMinutes()); 282 assertEquals(7, test.getSeconds()); 283 assertEquals(8, test.getMillis()); 284 } 285 286 public void testConstructor_long_Chronology2() throws Throwable { 287 long length = 4 * DateTimeConstants.MILLIS_PER_DAY + 288 5 * DateTimeConstants.MILLIS_PER_HOUR + 289 6 * DateTimeConstants.MILLIS_PER_MINUTE + 290 7 * DateTimeConstants.MILLIS_PER_SECOND + 8; 291 Period test = new Period(length, ISOChronology.getInstanceUTC()); 292 assertEquals(PeriodType.standard(), test.getPeriodType()); 293 assertEquals(0, test.getYears()); 294 assertEquals(0, test.getMonths()); 295 assertEquals(0, test.getWeeks()); 296 assertEquals(4, test.getDays()); 297 assertEquals(5, test.getHours()); 298 assertEquals(6, test.getMinutes()); 299 assertEquals(7, test.getSeconds()); 300 assertEquals(8, test.getMillis()); 301 } 302 303 public void testConstructor_long_Chronology3() throws Throwable { 304 long length = 4 * DateTimeConstants.MILLIS_PER_DAY + 305 5 * DateTimeConstants.MILLIS_PER_HOUR + 306 6 * DateTimeConstants.MILLIS_PER_MINUTE + 307 7 * DateTimeConstants.MILLIS_PER_SECOND + 8; 308 Period test = new Period(length, (Chronology) null); 309 assertEquals(PeriodType.standard(), test.getPeriodType()); 310 assertEquals(0, test.getYears()); 311 assertEquals(0, test.getMonths()); 312 assertEquals(0, test.getWeeks()); 313 assertEquals(0, test.getDays()); 314 assertEquals((4 * 24) + 5, test.getHours()); 315 assertEquals(6, test.getMinutes()); 316 assertEquals(7, test.getSeconds()); 317 assertEquals(8, test.getMillis()); 318 } 319 320 //----------------------------------------------------------------------- 321 public void testConstructor_long_PeriodType_Chronology1() throws Throwable { 322 long length = 4 * DateTimeConstants.MILLIS_PER_DAY + 323 5 * DateTimeConstants.MILLIS_PER_HOUR + 324 6 * DateTimeConstants.MILLIS_PER_MINUTE + 325 7 * DateTimeConstants.MILLIS_PER_SECOND + 8; 326 Period test = new Period(length, PeriodType.time().withMillisRemoved(), ISOChronology.getInstance()); 327 assertEquals(PeriodType.time().withMillisRemoved(), test.getPeriodType()); 328 assertEquals(0, test.getYears()); 329 assertEquals(0, test.getMonths()); 330 assertEquals(0, test.getWeeks()); 331 assertEquals(0, test.getDays()); 332 assertEquals((4 * 24) + 5, test.getHours()); 333 assertEquals(6, test.getMinutes()); 334 assertEquals(7, test.getSeconds()); 335 assertEquals(0, test.getMillis()); 336 } 337 338 public void testConstructor_long_PeriodType_Chronology2() throws Throwable { 339 long length = 4 * DateTimeConstants.MILLIS_PER_DAY + 340 5 * DateTimeConstants.MILLIS_PER_HOUR + 341 6 * DateTimeConstants.MILLIS_PER_MINUTE + 342 7 * DateTimeConstants.MILLIS_PER_SECOND + 8; 343 Period test = new Period(length, PeriodType.standard(), ISOChronology.getInstanceUTC()); 344 assertEquals(PeriodType.standard(), test.getPeriodType()); 345 assertEquals(0, test.getYears()); 346 assertEquals(0, test.getMonths()); 347 assertEquals(0, test.getWeeks()); 348 assertEquals(4, test.getDays()); 349 assertEquals(5, test.getHours()); 350 assertEquals(6, test.getMinutes()); 351 assertEquals(7, test.getSeconds()); 352 assertEquals(8, test.getMillis()); 353 } 354 355 public void testConstructor_long_PeriodType_Chronology3() throws Throwable { 356 long length = 4 * DateTimeConstants.MILLIS_PER_DAY + 357 5 * DateTimeConstants.MILLIS_PER_HOUR + 358 6 * DateTimeConstants.MILLIS_PER_MINUTE + 359 7 * DateTimeConstants.MILLIS_PER_SECOND + 8; 360 Period test = new Period(length, PeriodType.standard(), (Chronology) null); 361 assertEquals(PeriodType.standard(), test.getPeriodType()); 362 assertEquals(0, test.getYears()); 363 assertEquals(0, test.getMonths()); 364 assertEquals(0, test.getWeeks()); 365 assertEquals(0, test.getDays()); 366 assertEquals((4 * 24) + 5, test.getHours()); 367 assertEquals(6, test.getMinutes()); 368 assertEquals(7, test.getSeconds()); 369 assertEquals(8, test.getMillis()); 370 } 371 372 public void testConstructor_long_PeriodType_Chronology4() throws Throwable { 373 long length = 4 * DateTimeConstants.MILLIS_PER_DAY + 374 5 * DateTimeConstants.MILLIS_PER_HOUR + 375 6 * DateTimeConstants.MILLIS_PER_MINUTE + 376 7 * DateTimeConstants.MILLIS_PER_SECOND + 8; 377 Period test = new Period(length, (PeriodType) null, (Chronology) null); 378 assertEquals(PeriodType.standard(), test.getPeriodType()); 379 assertEquals(0, test.getYears()); 380 assertEquals(0, test.getMonths()); 381 assertEquals(0, test.getWeeks()); 382 assertEquals(0, test.getDays()); 383 assertEquals((4 * 24) + 5, test.getHours()); 384 assertEquals(6, test.getMinutes()); 385 assertEquals(7, test.getSeconds()); 386 assertEquals(8, test.getMillis()); 387 } 388 389 //----------------------------------------------------------------------- 390 /** 391 * Test constructor (4ints) 392 */ 393 public void testConstructor_4int1() throws Throwable { 394 Period test = new Period(5, 6, 7, 8); 395 assertEquals(PeriodType.standard(), test.getPeriodType()); 396 assertEquals(0, test.getYears()); 397 assertEquals(0, test.getMonths()); 398 assertEquals(0, test.getWeeks()); 399 assertEquals(0, test.getDays()); 400 assertEquals(5, test.getHours()); 401 assertEquals(6, test.getMinutes()); 402 assertEquals(7, test.getSeconds()); 403 assertEquals(8, test.getMillis()); 404 } 405 406 //----------------------------------------------------------------------- 407 /** 408 * Test constructor (8ints) 409 */ 410 public void testConstructor_8int1() throws Throwable { 411 Period test = new Period(1, 2, 3, 4, 5, 6, 7, 8); 412 assertEquals(PeriodType.standard(), test.getPeriodType()); 413 assertEquals(1, test.getYears()); 414 assertEquals(2, test.getMonths()); 415 assertEquals(3, test.getWeeks()); 416 assertEquals(4, test.getDays()); 417 assertEquals(5, test.getHours()); 418 assertEquals(6, test.getMinutes()); 419 assertEquals(7, test.getSeconds()); 420 assertEquals(8, test.getMillis()); 421 } 422 423 //----------------------------------------------------------------------- 424 /** 425 * Test constructor (8ints) 426 */ 427 public void testConstructor_8int__PeriodType1() throws Throwable { 428 Period test = new Period(1, 2, 3, 4, 5, 6, 7, 8, null); 429 assertEquals(PeriodType.standard(), test.getPeriodType()); 430 assertEquals(1, test.getYears()); 431 assertEquals(2, test.getMonths()); 432 assertEquals(3, test.getWeeks()); 433 assertEquals(4, test.getDays()); 434 assertEquals(5, test.getHours()); 435 assertEquals(6, test.getMinutes()); 436 assertEquals(7, test.getSeconds()); 437 assertEquals(8, test.getMillis()); 438 } 439 440 public void testConstructor_8int__PeriodType2() throws Throwable { 441 Period test = new Period(0, 0, 0, 0, 5, 6, 7, 8, PeriodType.dayTime()); 442 assertEquals(PeriodType.dayTime(), test.getPeriodType()); 443 assertEquals(0, test.getYears()); 444 assertEquals(0, test.getMonths()); 445 assertEquals(0, test.getWeeks()); 446 assertEquals(0, test.getDays()); 447 assertEquals(5, test.getHours()); 448 assertEquals(6, test.getMinutes()); 449 assertEquals(7, test.getSeconds()); 450 assertEquals(8, test.getMillis()); 451 } 452 453 public void testConstructor_8int__PeriodType3() throws Throwable { 454 try { 455 new Period(1, 2, 3, 4, 5, 6, 7, 8, PeriodType.dayTime()); 456 fail(); 457 } catch (IllegalArgumentException ex) {} 458 } 459 460 //----------------------------------------------------------------------- 461 public void testConstructor_long_long1() throws Throwable { 462 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); 463 DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1); 464 Period test = new Period(dt1.getMillis(), dt2.getMillis()); 465 assertEquals(PeriodType.standard(), test.getPeriodType()); 466 assertEquals(1, test.getYears()); 467 assertEquals(1, test.getMonths()); 468 assertEquals(0, test.getWeeks()); 469 assertEquals(1, test.getDays()); 470 assertEquals(1, test.getHours()); 471 assertEquals(1, test.getMinutes()); 472 assertEquals(1, test.getSeconds()); 473 assertEquals(1, test.getMillis()); 474 } 475 476 public void testConstructor_long_long2() throws Throwable { 477 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); 478 DateTime dt2 = new DateTime(2005, 7, 17, 1, 1, 1, 1); 479 Period test = new Period(dt1.getMillis(), dt2.getMillis()); 480 assertEquals(PeriodType.standard(), test.getPeriodType()); 481 assertEquals(1, test.getYears()); 482 assertEquals(1, test.getMonths()); 483 assertEquals(1, test.getWeeks()); 484 assertEquals(1, test.getDays()); 485 assertEquals(1, test.getHours()); 486 assertEquals(1, test.getMinutes()); 487 assertEquals(1, test.getSeconds()); 488 assertEquals(1, test.getMillis()); 489 } 490 491 //----------------------------------------------------------------------- 492 public void testConstructor_long_long_PeriodType1() throws Throwable { 493 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); 494 DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1); 495 Period test = new Period(dt1.getMillis(), dt2.getMillis(), (PeriodType) null); 496 assertEquals(PeriodType.standard(), test.getPeriodType()); 497 assertEquals(1, test.getYears()); 498 assertEquals(1, test.getMonths()); 499 assertEquals(0, test.getWeeks()); 500 assertEquals(1, test.getDays()); 501 assertEquals(1, test.getHours()); 502 assertEquals(1, test.getMinutes()); 503 assertEquals(1, test.getSeconds()); 504 assertEquals(1, test.getMillis()); 505 } 506 507 public void testConstructor_long_long_PeriodType2() throws Throwable { 508 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); 509 DateTime dt2 = new DateTime(2004, 7, 10, 1, 1, 1, 1); 510 Period test = new Period(dt1.getMillis(), dt2.getMillis(), PeriodType.dayTime()); 511 assertEquals(PeriodType.dayTime(), test.getPeriodType()); 512 assertEquals(0, test.getYears()); 513 assertEquals(0, test.getMonths()); 514 assertEquals(0, test.getWeeks()); 515 assertEquals(31, test.getDays()); 516 assertEquals(1, test.getHours()); 517 assertEquals(1, test.getMinutes()); 518 assertEquals(1, test.getSeconds()); 519 assertEquals(1, test.getMillis()); 520 } 521 522 public void testConstructor_long_long_PeriodType3() throws Throwable { 523 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); 524 DateTime dt2 = new DateTime(2004, 6, 9, 1, 1, 1, 1); 525 Period test = new Period(dt1.getMillis(), dt2.getMillis(), PeriodType.standard().withMillisRemoved()); 526 assertEquals(PeriodType.standard().withMillisRemoved(), test.getPeriodType()); 527 assertEquals(0, test.getYears()); 528 assertEquals(0, test.getMonths()); 529 assertEquals(0, test.getWeeks()); 530 assertEquals(0, test.getDays()); 531 assertEquals(1, test.getHours()); 532 assertEquals(1, test.getMinutes()); 533 assertEquals(1, test.getSeconds()); 534 assertEquals(0, test.getMillis()); 535 } 536 537 public void testToPeriod_PeriodType3() { 538 DateTime dt1 = new DateTime(2004, 6, 9, 7, 8, 9, 10); 539 DateTime dt2 = new DateTime(2005, 6, 9, 12, 14, 16, 18); 540 Period test = new Period(dt1.getMillis(), dt2.getMillis(), PeriodType.yearWeekDayTime()); 541 542 assertEquals(PeriodType.yearWeekDayTime(), test.getPeriodType()); 543 assertEquals(1, test.getYears()); // tests using years and not weekyears 544 assertEquals(0, test.getMonths()); 545 assertEquals(0, test.getWeeks()); 546 assertEquals(0, test.getDays()); 547 assertEquals(5, test.getHours()); 548 assertEquals(6, test.getMinutes()); 549 assertEquals(7, test.getSeconds()); 550 assertEquals(8, test.getMillis()); 551 } 552 553 //----------------------------------------------------------------------- 554 public void testConstructor_long_long_Chronology1() throws Throwable { 555 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0, CopticChronology.getInstance()); 556 DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1, CopticChronology.getInstance()); 557 Period test = new Period(dt1.getMillis(), dt2.getMillis(), CopticChronology.getInstance()); 558 assertEquals(PeriodType.standard(), test.getPeriodType()); 559 assertEquals(1, test.getYears()); 560 assertEquals(1, test.getMonths()); 561 assertEquals(0, test.getWeeks()); 562 assertEquals(1, test.getDays()); 563 assertEquals(1, test.getHours()); 564 assertEquals(1, test.getMinutes()); 565 assertEquals(1, test.getSeconds()); 566 assertEquals(1, test.getMillis()); 567 } 568 569 public void testConstructor_long_long_Chronology2() throws Throwable { 570 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); 571 DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1); 572 Period test = new Period(dt1.getMillis(), dt2.getMillis(), (Chronology) null); 573 assertEquals(PeriodType.standard(), test.getPeriodType()); 574 assertEquals(1, test.getYears()); 575 assertEquals(1, test.getMonths()); 576 assertEquals(0, test.getWeeks()); 577 assertEquals(1, test.getDays()); 578 assertEquals(1, test.getHours()); 579 assertEquals(1, test.getMinutes()); 580 assertEquals(1, test.getSeconds()); 581 assertEquals(1, test.getMillis()); 582 } 583 584 //----------------------------------------------------------------------- 585 public void testConstructor_long_long_PeriodType_Chronology1() throws Throwable { 586 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0, CopticChronology.getInstance()); 587 DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1, CopticChronology.getInstance()); 588 Period test = new Period(dt1.getMillis(), dt2.getMillis(), (PeriodType) null, CopticChronology.getInstance()); 589 assertEquals(PeriodType.standard(), test.getPeriodType()); 590 assertEquals(1, test.getYears()); 591 assertEquals(1, test.getMonths()); 592 assertEquals(0, test.getWeeks()); 593 assertEquals(1, test.getDays()); 594 assertEquals(1, test.getHours()); 595 assertEquals(1, test.getMinutes()); 596 assertEquals(1, test.getSeconds()); 597 assertEquals(1, test.getMillis()); 598 } 599 600 public void testConstructor_long_long_PeriodType_Chronology2() throws Throwable { 601 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); 602 DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1); 603 Period test = new Period(dt1.getMillis(), dt2.getMillis(), (PeriodType) null, null); 604 assertEquals(PeriodType.standard(), test.getPeriodType()); 605 assertEquals(1, test.getYears()); 606 assertEquals(1, test.getMonths()); 607 assertEquals(0, test.getWeeks()); 608 assertEquals(1, test.getDays()); 609 assertEquals(1, test.getHours()); 610 assertEquals(1, test.getMinutes()); 611 assertEquals(1, test.getSeconds()); 612 assertEquals(1, test.getMillis()); 613 } 614 615 //----------------------------------------------------------------------- 616 public void testConstructor_RI_RI1() throws Throwable { 617 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); 618 DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1); 619 Period test = new Period(dt1, dt2); 620 assertEquals(PeriodType.standard(), test.getPeriodType()); 621 assertEquals(1, test.getYears()); 622 assertEquals(1, test.getMonths()); 623 assertEquals(0, test.getWeeks()); 624 assertEquals(1, test.getDays()); 625 assertEquals(1, test.getHours()); 626 assertEquals(1, test.getMinutes()); 627 assertEquals(1, test.getSeconds()); 628 assertEquals(1, test.getMillis()); 629 } 630 631 public void testConstructor_RI_RI2() throws Throwable { 632 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); 633 DateTime dt2 = new DateTime(2005, 7, 17, 1, 1, 1, 1); 634 Period test = new Period(dt1, dt2); 635 assertEquals(PeriodType.standard(), test.getPeriodType()); 636 assertEquals(1, test.getYears()); 637 assertEquals(1, test.getMonths()); 638 assertEquals(1, test.getWeeks()); 639 assertEquals(1, test.getDays()); 640 assertEquals(1, test.getHours()); 641 assertEquals(1, test.getMinutes()); 642 assertEquals(1, test.getSeconds()); 643 assertEquals(1, test.getMillis()); 644 } 645 646 public void testConstructor_RI_RI3() throws Throwable { 647 DateTime dt1 = null; // 2002-06-09T01:00+01:00 648 DateTime dt2 = new DateTime(2005, 7, 17, 1, 1, 1, 1); 649 Period test = new Period(dt1, dt2); 650 assertEquals(PeriodType.standard(), test.getPeriodType()); 651 assertEquals(3, test.getYears()); 652 assertEquals(1, test.getMonths()); 653 assertEquals(1, test.getWeeks()); 654 assertEquals(1, test.getDays()); 655 assertEquals(0, test.getHours()); 656 assertEquals(1, test.getMinutes()); 657 assertEquals(1, test.getSeconds()); 658 assertEquals(1, test.getMillis()); 659 } 660 661 public void testConstructor_RI_RI4() throws Throwable { 662 DateTime dt1 = new DateTime(2005, 7, 17, 1, 1, 1, 1); 663 DateTime dt2 = null; // 2002-06-09T01:00+01:00 664 Period test = new Period(dt1, dt2); 665 assertEquals(PeriodType.standard(), test.getPeriodType()); 666 assertEquals(-3, test.getYears()); 667 assertEquals(-1, test.getMonths()); 668 assertEquals(-1, test.getWeeks()); 669 assertEquals(-1, test.getDays()); 670 assertEquals(0, test.getHours()); 671 assertEquals(-1, test.getMinutes()); 672 assertEquals(-1, test.getSeconds()); 673 assertEquals(-1, test.getMillis()); 674 } 675 676 public void testConstructor_RI_RI5() throws Throwable { 677 DateTime dt1 = null; // 2002-06-09T01:00+01:00 678 DateTime dt2 = null; // 2002-06-09T01:00+01:00 679 Period test = new Period(dt1, dt2); 680 assertEquals(PeriodType.standard(), test.getPeriodType()); 681 assertEquals(0, test.getYears()); 682 assertEquals(0, test.getMonths()); 683 assertEquals(0, test.getWeeks()); 684 assertEquals(0, test.getDays()); 685 assertEquals(0, test.getHours()); 686 assertEquals(0, test.getMinutes()); 687 assertEquals(0, test.getSeconds()); 688 assertEquals(0, test.getMillis()); 689 } 690 691 //----------------------------------------------------------------------- 692 public void testConstructor_RI_RI_PeriodType1() throws Throwable { 693 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); 694 DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1); 695 Period test = new Period(dt1, dt2, null); 696 assertEquals(PeriodType.standard(), test.getPeriodType()); 697 assertEquals(1, test.getYears()); 698 assertEquals(1, test.getMonths()); 699 assertEquals(0, test.getWeeks()); 700 assertEquals(1, test.getDays()); 701 assertEquals(1, test.getHours()); 702 assertEquals(1, test.getMinutes()); 703 assertEquals(1, test.getSeconds()); 704 assertEquals(1, test.getMillis()); 705 } 706 707 public void testConstructor_RI_RI_PeriodType2() throws Throwable { 708 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); 709 DateTime dt2 = new DateTime(2004, 7, 10, 1, 1, 1, 1); 710 Period test = new Period(dt1, dt2, PeriodType.dayTime()); 711 assertEquals(PeriodType.dayTime(), test.getPeriodType()); 712 assertEquals(0, test.getYears()); 713 assertEquals(0, test.getMonths()); 714 assertEquals(0, test.getWeeks()); 715 assertEquals(31, test.getDays()); 716 assertEquals(1, test.getHours()); 717 assertEquals(1, test.getMinutes()); 718 assertEquals(1, test.getSeconds()); 719 assertEquals(1, test.getMillis()); 720 } 721 722 public void testConstructor_RI_RI_PeriodType3() throws Throwable { 723 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); 724 DateTime dt2 = new DateTime(2004, 6, 9, 1, 1, 1, 1); 725 Period test = new Period(dt1, dt2, PeriodType.standard().withMillisRemoved()); 726 assertEquals(PeriodType.standard().withMillisRemoved(), test.getPeriodType()); 727 assertEquals(0, test.getYears()); 728 assertEquals(0, test.getMonths()); 729 assertEquals(0, test.getWeeks()); 730 assertEquals(0, test.getDays()); 731 assertEquals(1, test.getHours()); 732 assertEquals(1, test.getMinutes()); 733 assertEquals(1, test.getSeconds()); 734 assertEquals(0, test.getMillis()); 735 } 736 737 public void testConstructor_RI_RI_PeriodType4() throws Throwable { 738 DateTime dt1 = null; // 2002-06-09T01:00+01:00 739 DateTime dt2 = new DateTime(2005, 7, 17, 1, 1, 1, 1); 740 Period test = new Period(dt1, dt2, PeriodType.standard()); 741 assertEquals(PeriodType.standard(), test.getPeriodType()); 742 assertEquals(3, test.getYears()); 743 assertEquals(1, test.getMonths()); 744 assertEquals(1, test.getWeeks()); 745 assertEquals(1, test.getDays()); 746 assertEquals(0, test.getHours()); 747 assertEquals(1, test.getMinutes()); 748 assertEquals(1, test.getSeconds()); 749 assertEquals(1, test.getMillis()); 750 } 751 752 public void testConstructor_RI_RI_PeriodType5() throws Throwable { 753 DateTime dt1 = null; // 2002-06-09T01:00+01:00 754 DateTime dt2 = null; // 2002-06-09T01:00+01:00 755 Period test = new Period(dt1, dt2, PeriodType.standard()); 756 assertEquals(PeriodType.standard(), test.getPeriodType()); 757 assertEquals(0, test.getYears()); 758 assertEquals(0, test.getMonths()); 759 assertEquals(0, test.getWeeks()); 760 assertEquals(0, test.getDays()); 761 assertEquals(0, test.getHours()); 762 assertEquals(0, test.getMinutes()); 763 assertEquals(0, test.getSeconds()); 764 assertEquals(0, test.getMillis()); 765 } 766 767 //----------------------------------------------------------------------- 768 public void testConstructor_RP_RP1() throws Throwable { 769 YearMonthDay dt1 = new YearMonthDay(2004, 6, 9); 770 YearMonthDay dt2 = new YearMonthDay(2005, 7, 10); 771 Period test = new Period(dt1, dt2); 772 assertEquals(PeriodType.standard(), test.getPeriodType()); 773 assertEquals(1, test.getYears()); 774 assertEquals(1, test.getMonths()); 775 assertEquals(0, test.getWeeks()); 776 assertEquals(1, test.getDays()); 777 assertEquals(0, test.getHours()); 778 assertEquals(0, test.getMinutes()); 779 assertEquals(0, test.getSeconds()); 780 assertEquals(0, test.getMillis()); 781 } 782 783 public void testConstructor_RP_RP2() throws Throwable { 784 YearMonthDay dt1 = new YearMonthDay(2004, 6, 9); 785 YearMonthDay dt2 = new YearMonthDay(2005, 5, 17); 786 Period test = new Period(dt1, dt2); 787 assertEquals(PeriodType.standard(), test.getPeriodType()); 788 assertEquals(0, test.getYears()); 789 assertEquals(11, test.getMonths()); 790 assertEquals(1, test.getWeeks()); 791 assertEquals(1, test.getDays()); 792 assertEquals(0, test.getHours()); 793 assertEquals(0, test.getMinutes()); 794 assertEquals(0, test.getSeconds()); 795 assertEquals(0, test.getMillis()); 796 } 797 798 public void testConstructor_RP_RP2Local() throws Throwable { 799 LocalDate dt1 = new LocalDate(2004, 6, 9); 800 LocalDate dt2 = new LocalDate(2005, 5, 17); 801 Period test = new Period(dt1, dt2); 802 assertEquals(PeriodType.standard(), test.getPeriodType()); 803 assertEquals(0, test.getYears()); 804 assertEquals(11, test.getMonths()); 805 assertEquals(1, test.getWeeks()); 806 assertEquals(1, test.getDays()); 807 assertEquals(0, test.getHours()); 808 assertEquals(0, test.getMinutes()); 809 assertEquals(0, test.getSeconds()); 810 assertEquals(0, test.getMillis()); 811 } 812 813 public void testConstructor_RP_RP3() throws Throwable { 814 YearMonthDay dt1 = null; 815 YearMonthDay dt2 = new YearMonthDay(2005, 7, 17); 816 try { 817 new Period(dt1, dt2); 818 fail(); 819 } catch (IllegalArgumentException ex) {} 820 } 821 822 public void testConstructor_RP_RP4() throws Throwable { 823 YearMonthDay dt1 = new YearMonthDay(2005, 7, 17); 824 YearMonthDay dt2 = null; 825 try { 826 new Period(dt1, dt2); 827 fail(); 828 } catch (IllegalArgumentException ex) {} 829 } 830 831 public void testConstructor_RP_RP5() throws Throwable { 832 YearMonthDay dt1 = null; 833 YearMonthDay dt2 = null; 834 try { 835 new Period(dt1, dt2); 836 fail(); 837 } catch (IllegalArgumentException ex) {} 838 } 839 840 public void testConstructor_RP_RP6() throws Throwable { 841 YearMonthDay dt1 = new YearMonthDay(2005, 7, 17); 842 TimeOfDay dt2 = new TimeOfDay(10, 20, 30, 40); 843 try { 844 new Period(dt1, dt2); 845 fail(); 846 } catch (IllegalArgumentException ex) {} 847 } 848 849 public void testConstructor_RP_RP7() throws Throwable { 850 Partial dt1 = new Partial().with(DateTimeFieldType.year(), 2005).with(DateTimeFieldType.monthOfYear(), 12); 851 Partial dt2 = new Partial().with(DateTimeFieldType.year(), 2005).with(DateTimeFieldType.hourOfDay(), 14); 852 try { 853 new Period(dt1, dt2); 854 fail(); 855 } catch (IllegalArgumentException ex) {} 856 } 857 858 public void testConstructor_RP_RP8() throws Throwable { 859 Partial dt1 = new Partial().with(DateTimeFieldType.year(), 2005).with(DateTimeFieldType.hourOfDay(), 12); 860 Partial dt2 = new Partial().with(DateTimeFieldType.year(), 2005).with(DateTimeFieldType.hourOfDay(), 14); 861 try { 862 new Period(dt1, dt2); 863 fail(); 864 } catch (IllegalArgumentException ex) {} 865 } 866 867 //----------------------------------------------------------------------- 868 public void testConstructor_RP_RP_PeriodType1() throws Throwable { 869 YearMonthDay dt1 = new YearMonthDay(2004, 6, 9); 870 YearMonthDay dt2 = new YearMonthDay(2005, 7, 10); 871 Period test = new Period(dt1, dt2, PeriodType.standard()); 872 assertEquals(PeriodType.standard(), test.getPeriodType()); 873 assertEquals(1, test.getYears()); 874 assertEquals(1, test.getMonths()); 875 assertEquals(0, test.getWeeks()); 876 assertEquals(1, test.getDays()); 877 assertEquals(0, test.getHours()); 878 assertEquals(0, test.getMinutes()); 879 assertEquals(0, test.getSeconds()); 880 assertEquals(0, test.getMillis()); 881 } 882 883 public void testConstructor_RP_RP_PeriodType2() throws Throwable { 884 YearMonthDay dt1 = new YearMonthDay(2004, 6, 9); 885 YearMonthDay dt2 = new YearMonthDay(2005, 5, 17); 886 Period test = new Period(dt1, dt2, PeriodType.yearMonthDay()); 887 assertEquals(PeriodType.yearMonthDay(), test.getPeriodType()); 888 assertEquals(0, test.getYears()); 889 assertEquals(11, test.getMonths()); 890 assertEquals(0, test.getWeeks()); 891 assertEquals(8, test.getDays()); 892 assertEquals(0, test.getHours()); 893 assertEquals(0, test.getMinutes()); 894 assertEquals(0, test.getSeconds()); 895 assertEquals(0, test.getMillis()); 896 } 897 898 public void testConstructor_RP_RP_PeriodType2Local() throws Throwable { 899 LocalDate dt1 = new LocalDate(2004, 6, 9); 900 LocalDate dt2 = new LocalDate(2005, 5, 17); 901 Period test = new Period(dt1, dt2, PeriodType.yearMonthDay()); 902 assertEquals(PeriodType.yearMonthDay(), test.getPeriodType()); 903 assertEquals(0, test.getYears()); 904 assertEquals(11, test.getMonths()); 905 assertEquals(0, test.getWeeks()); 906 assertEquals(8, test.getDays()); 907 assertEquals(0, test.getHours()); 908 assertEquals(0, test.getMinutes()); 909 assertEquals(0, test.getSeconds()); 910 assertEquals(0, test.getMillis()); 911 } 912 913 public void testConstructor_RP_RP_PeriodType3() throws Throwable { 914 YearMonthDay dt1 = null; 915 YearMonthDay dt2 = new YearMonthDay(2005, 7, 17); 916 try { 917 new Period(dt1, dt2, PeriodType.standard()); 918 fail(); 919 } catch (IllegalArgumentException ex) {} 920 } 921 922 public void testConstructor_RP_RP_PeriodType4() throws Throwable { 923 YearMonthDay dt1 = new YearMonthDay(2005, 7, 17); 924 YearMonthDay dt2 = null; 925 try { 926 new Period(dt1, dt2); 927 fail(); 928 } catch (IllegalArgumentException ex) {} 929 } 930 931 public void testConstructor_RP_RP_PeriodType5() throws Throwable { 932 YearMonthDay dt1 = null; 933 YearMonthDay dt2 = null; 934 try { 935 new Period(dt1, dt2, PeriodType.standard()); 936 fail(); 937 } catch (IllegalArgumentException ex) {} 938 } 939 940 public void testConstructor_RP_RP_PeriodType6() throws Throwable { 941 YearMonthDay dt1 = new YearMonthDay(2005, 7, 17); 942 TimeOfDay dt2 = new TimeOfDay(10, 20, 30, 40); 943 try { 944 new Period(dt1, dt2, PeriodType.standard()); 945 fail(); 946 } catch (IllegalArgumentException ex) {} 947 } 948 949 public void testConstructor_RP_RP_PeriodType7() throws Throwable { 950 Partial dt1 = new Partial().with(DateTimeFieldType.year(), 2005).with(DateTimeFieldType.monthOfYear(), 12); 951 Partial dt2 = new Partial().with(DateTimeFieldType.year(), 2005).with(DateTimeFieldType.hourOfDay(), 14); 952 try { 953 new Period(dt1, dt2, PeriodType.standard()); 954 fail(); 955 } catch (IllegalArgumentException ex) {} 956 } 957 958 public void testConstructor_RP_RP_PeriodType8() throws Throwable { 959 Partial dt1 = new Partial().with(DateTimeFieldType.year(), 2005).with(DateTimeFieldType.hourOfDay(), 12); 960 Partial dt2 = new Partial().with(DateTimeFieldType.year(), 2005).with(DateTimeFieldType.hourOfDay(), 14); 961 try { 962 new Period(dt1, dt2, PeriodType.standard()); 963 fail(); 964 } catch (IllegalArgumentException ex) {} 965 } 966 967 //----------------------------------------------------------------------- 968 public void testConstructor_RI_RD1() throws Throwable { 969 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); 970 DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1); 971 Duration dur = new Interval(dt1, dt2).toDuration(); 972 Period test = new Period(dt1, dur); 973 assertEquals(PeriodType.standard(), test.getPeriodType()); 974 assertEquals(1, test.getYears()); 975 assertEquals(1, test.getMonths()); 976 assertEquals(0, test.getWeeks()); 977 assertEquals(1, test.getDays()); 978 assertEquals(1, test.getHours()); 979 assertEquals(1, test.getMinutes()); 980 assertEquals(1, test.getSeconds()); 981 assertEquals(1, test.getMillis()); 982 } 983 984 public void testConstructor_RI_RD2() throws Throwable { 985 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); 986 Duration dur = null; 987 Period test = new Period(dt1, dur); 988 assertEquals(PeriodType.standard(), test.getPeriodType()); 989 assertEquals(0, test.getYears()); 990 assertEquals(0, test.getMonths()); 991 assertEquals(0, test.getWeeks()); 992 assertEquals(0, test.getDays()); 993 assertEquals(0, test.getHours()); 994 assertEquals(0, test.getMinutes()); 995 assertEquals(0, test.getSeconds()); 996 assertEquals(0, test.getMillis()); 997 } 998 999 //----------------------------------------------------------------------- 1000 public void testConstructor_RI_RD_PeriodType1() throws Throwable { 1001 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); 1002 DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1); 1003 Duration dur = new Interval(dt1, dt2).toDuration(); 1004 Period test = new Period(dt1, dur, PeriodType.yearDayTime()); 1005 assertEquals(PeriodType.yearDayTime(), test.getPeriodType()); 1006 assertEquals(1, test.getYears()); 1007 assertEquals(0, test.getMonths()); 1008 assertEquals(0, test.getWeeks()); 1009 assertEquals(31, test.getDays()); 1010 assertEquals(1, test.getHours()); 1011 assertEquals(1, test.getMinutes()); 1012 assertEquals(1, test.getSeconds()); 1013 assertEquals(1, test.getMillis()); 1014 } 1015 1016 public void testConstructor_RI_RD_PeriodType2() throws Throwable { 1017 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); 1018 Duration dur = null; 1019 Period test = new Period(dt1, dur, (PeriodType) null); 1020 assertEquals(PeriodType.standard(), test.getPeriodType()); 1021 assertEquals(0, test.getYears()); 1022 assertEquals(0, test.getMonths()); 1023 assertEquals(0, test.getWeeks()); 1024 assertEquals(0, test.getDays()); 1025 assertEquals(0, test.getHours()); 1026 assertEquals(0, test.getMinutes()); 1027 assertEquals(0, test.getSeconds()); 1028 assertEquals(0, test.getMillis()); 1029 } 1030 1031 //----------------------------------------------------------------------- 1032 public void testConstructor_RD_RI1() throws Throwable { 1033 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); 1034 DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1); 1035 Duration dur = new Interval(dt1, dt2).toDuration(); 1036 Period test = new Period(dur, dt2); 1037 assertEquals(PeriodType.standard(), test.getPeriodType()); 1038 assertEquals(1, test.getYears()); 1039 assertEquals(1, test.getMonths()); 1040 assertEquals(0, test.getWeeks()); 1041 assertEquals(1, test.getDays()); 1042 assertEquals(1, test.getHours()); 1043 assertEquals(1, test.getMinutes()); 1044 assertEquals(1, test.getSeconds()); 1045 assertEquals(1, test.getMillis()); 1046 } 1047 1048 public void testConstructor_RD_RI2() throws Throwable { 1049 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); 1050 Duration dur = null; 1051 Period test = new Period(dur, dt1); 1052 assertEquals(PeriodType.standard(), test.getPeriodType()); 1053 assertEquals(0, test.getYears()); 1054 assertEquals(0, test.getMonths()); 1055 assertEquals(0, test.getWeeks()); 1056 assertEquals(0, test.getDays()); 1057 assertEquals(0, test.getHours()); 1058 assertEquals(0, test.getMinutes()); 1059 assertEquals(0, test.getSeconds()); 1060 assertEquals(0, test.getMillis()); 1061 } 1062 1063 //----------------------------------------------------------------------- 1064 public void testConstructor_RD_RI_PeriodType1() throws Throwable { 1065 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); 1066 DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1); 1067 Duration dur = new Interval(dt1, dt2).toDuration(); 1068 Period test = new Period(dur, dt2, PeriodType.yearDayTime()); 1069 assertEquals(PeriodType.yearDayTime(), test.getPeriodType()); 1070 assertEquals(1, test.getYears()); 1071 assertEquals(0, test.getMonths()); 1072 assertEquals(0, test.getWeeks()); 1073 assertEquals(31, test.getDays()); 1074 assertEquals(1, test.getHours()); 1075 assertEquals(1, test.getMinutes()); 1076 assertEquals(1, test.getSeconds()); 1077 assertEquals(1, test.getMillis()); 1078 } 1079 1080 public void testConstructor_RD_RI_PeriodType2() throws Throwable { 1081 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); 1082 Duration dur = null; 1083 Period test = new Period(dur, dt1, (PeriodType) null); 1084 assertEquals(PeriodType.standard(), test.getPeriodType()); 1085 assertEquals(0, test.getYears()); 1086 assertEquals(0, test.getMonths()); 1087 assertEquals(0, test.getWeeks()); 1088 assertEquals(0, test.getDays()); 1089 assertEquals(0, test.getHours()); 1090 assertEquals(0, test.getMinutes()); 1091 assertEquals(0, test.getSeconds()); 1092 assertEquals(0, test.getMillis()); 1093 } 1094 1095 //----------------------------------------------------------------------- 1096 /** 1097 * Test constructor (Object) 1098 */ 1099 public void testConstructor_Object1() throws Throwable { 1100 Period test = new Period("P1Y2M3D"); 1101 assertEquals(PeriodType.standard(), test.getPeriodType()); 1102 assertEquals(1, test.getYears()); 1103 assertEquals(2, test.getMonths()); 1104 assertEquals(0, test.getWeeks()); 1105 assertEquals(3, test.getDays()); 1106 assertEquals(0, test.getHours()); 1107 assertEquals(0, test.getMinutes()); 1108 assertEquals(0, test.getSeconds()); 1109 assertEquals(0, test.getMillis()); 1110 } 1111 1112 public void testConstructor_Object2() throws Throwable { 1113 Period test = new Period((Object) null); 1114 assertEquals(PeriodType.standard(), test.getPeriodType()); 1115 assertEquals(0, test.getYears()); 1116 assertEquals(0, test.getMonths()); 1117 assertEquals(0, test.getWeeks()); 1118 assertEquals(0, test.getDays()); 1119 assertEquals(0, test.getHours()); 1120 assertEquals(0, test.getMinutes()); 1121 assertEquals(0, test.getSeconds()); 1122 assertEquals(0, test.getMillis()); 1123 } 1124 1125 public void testConstructor_Object3() throws Throwable { 1126 Period test = new Period(new Period(0, 0, 0, 0, 1, 2, 3, 4, PeriodType.dayTime())); 1127 assertEquals(PeriodType.dayTime(), test.getPeriodType()); 1128 assertEquals(0, test.getYears()); 1129 assertEquals(0, test.getMonths()); 1130 assertEquals(0, test.getWeeks()); 1131 assertEquals(0, test.getDays()); 1132 assertEquals(1, test.getHours()); 1133 assertEquals(2, test.getMinutes()); 1134 assertEquals(3, test.getSeconds()); 1135 assertEquals(4, test.getMillis()); 1136 } 1137 1138 public void testConstructor_Object4() throws Throwable { 1139 Period base = new Period(1, 1, 0, 1, 1, 1, 1, 1, PeriodType.standard()); 1140 Period test = new Period(base); 1141 assertEquals(PeriodType.standard(), test.getPeriodType()); 1142 assertEquals(1, test.getYears()); 1143 assertEquals(1, test.getMonths()); 1144 assertEquals(0, test.getWeeks()); 1145 assertEquals(1, test.getDays()); 1146 assertEquals(1, test.getHours()); 1147 assertEquals(1, test.getMinutes()); 1148 assertEquals(1, test.getSeconds()); 1149 assertEquals(1, test.getMillis()); 1150 } 1151 1152 //----------------------------------------------------------------------- 1153 /** 1154 * Test constructor (Object) 1155 */ 1156 public void testConstructor_Object_PeriodType1() throws Throwable { 1157 Period test = new Period("P1Y2M3D", PeriodType.yearMonthDayTime()); 1158 assertEquals(PeriodType.yearMonthDayTime(), test.getPeriodType()); 1159 assertEquals(1, test.getYears()); 1160 assertEquals(2, test.getMonths()); 1161 assertEquals(0, test.getWeeks()); 1162 assertEquals(3, test.getDays()); 1163 assertEquals(0, test.getHours()); 1164 assertEquals(0, test.getMinutes()); 1165 assertEquals(0, test.getSeconds()); 1166 assertEquals(0, test.getMillis()); 1167 } 1168 1169 public void testConstructor_Object_PeriodType2() throws Throwable { 1170 Period test = new Period((Object) null, PeriodType.yearMonthDayTime()); 1171 assertEquals(PeriodType.yearMonthDayTime(), test.getPeriodType()); 1172 assertEquals(0, test.getYears()); 1173 assertEquals(0, test.getMonths()); 1174 assertEquals(0, test.getWeeks()); 1175 assertEquals(0, test.getDays()); 1176 assertEquals(0, test.getHours()); 1177 assertEquals(0, test.getMinutes()); 1178 assertEquals(0, test.getSeconds()); 1179 assertEquals(0, test.getMillis()); 1180 } 1181 1182 public void testConstructor_Object_PeriodType3() throws Throwable { 1183 Period test = new Period(new Period(0, 0, 0, 0, 1, 2, 3, 4, PeriodType.dayTime()), PeriodType.yearMonthDayTime()); 1184 assertEquals(PeriodType.yearMonthDayTime(), test.getPeriodType()); 1185 assertEquals(0, test.getYears()); 1186 assertEquals(0, test.getMonths()); 1187 assertEquals(0, test.getWeeks()); 1188 assertEquals(0, test.getDays()); 1189 assertEquals(1, test.getHours()); 1190 assertEquals(2, test.getMinutes()); 1191 assertEquals(3, test.getSeconds()); 1192 assertEquals(4, test.getMillis()); 1193 } 1194 1195 public void testConstructor_Object_PeriodType4() throws Throwable { 1196 Period test = new Period(new Period(0, 0, 0, 0, 1, 2, 3, 4, PeriodType.dayTime()), (PeriodType) null); 1197 assertEquals(PeriodType.dayTime(), test.getPeriodType()); 1198 assertEquals(0, test.getYears()); 1199 assertEquals(0, test.getMonths()); 1200 assertEquals(0, test.getWeeks()); 1201 assertEquals(0, test.getDays()); 1202 assertEquals(1, test.getHours()); 1203 assertEquals(2, test.getMinutes()); 1204 assertEquals(3, test.getSeconds()); 1205 assertEquals(4, test.getMillis()); 1206 } 1207 1208 //----------------------------------------------------------------------- 1209 public void testFactoryYears() throws Throwable { 1210 Period test = Period.years(6); 1211 assertEquals(PeriodType.standard(), test.getPeriodType()); 1212 assertEquals(6, test.getYears()); 1213 assertEquals(0, test.getMonths()); 1214 assertEquals(0, test.getWeeks()); 1215 assertEquals(0, test.getDays()); 1216 assertEquals(0, test.getHours()); 1217 assertEquals(0, test.getMinutes()); 1218 assertEquals(0, test.getSeconds()); 1219 assertEquals(0, test.getMillis()); 1220 } 1221 1222 public void testFactoryMonths() throws Throwable { 1223 Period test = Period.months(6); 1224 assertEquals(PeriodType.standard(), test.getPeriodType()); 1225 assertEquals(0, test.getYears()); 1226 assertEquals(6, test.getMonths()); 1227 assertEquals(0, test.getWeeks()); 1228 assertEquals(0, test.getDays()); 1229 assertEquals(0, test.getHours()); 1230 assertEquals(0, test.getMinutes()); 1231 assertEquals(0, test.getSeconds()); 1232 assertEquals(0, test.getMillis()); 1233 } 1234 1235 public void testFactoryWeeks() throws Throwable { 1236 Period test = Period.weeks(6); 1237 assertEquals(PeriodType.standard(), test.getPeriodType()); 1238 assertEquals(0, test.getYears()); 1239 assertEquals(0, test.getMonths()); 1240 assertEquals(6, test.getWeeks()); 1241 assertEquals(0, test.getDays()); 1242 assertEquals(0, test.getHours()); 1243 assertEquals(0, test.getMinutes()); 1244 assertEquals(0, test.getSeconds()); 1245 assertEquals(0, test.getMillis()); 1246 } 1247 1248 public void testFactoryDays() throws Throwable { 1249 Period test = Period.days(6); 1250 assertEquals(PeriodType.standard(), test.getPeriodType()); 1251 assertEquals(0, test.getYears()); 1252 assertEquals(0, test.getMonths()); 1253 assertEquals(0, test.getWeeks()); 1254 assertEquals(6, test.getDays()); 1255 assertEquals(0, test.getHours()); 1256 assertEquals(0, test.getMinutes()); 1257 assertEquals(0, test.getSeconds()); 1258 assertEquals(0, test.getMillis()); 1259 } 1260 1261 public void testFactoryHours() throws Throwable { 1262 Period test = Period.hours(6); 1263 assertEquals(PeriodType.standard(), test.getPeriodType()); 1264 assertEquals(0, test.getYears()); 1265 assertEquals(0, test.getMonths()); 1266 assertEquals(0, test.getWeeks()); 1267 assertEquals(0, test.getDays()); 1268 assertEquals(6, test.getHours()); 1269 assertEquals(0, test.getMinutes()); 1270 assertEquals(0, test.getSeconds()); 1271 assertEquals(0, test.getMillis()); 1272 } 1273 1274 public void testFactoryMinutes() throws Throwable { 1275 Period test = Period.minutes(6); 1276 assertEquals(PeriodType.standard(), test.getPeriodType()); 1277 assertEquals(0, test.getYears()); 1278 assertEquals(0, test.getMonths()); 1279 assertEquals(0, test.getWeeks()); 1280 assertEquals(0, test.getDays()); 1281 assertEquals(0, test.getHours()); 1282 assertEquals(6, test.getMinutes()); 1283 assertEquals(0, test.getSeconds()); 1284 assertEquals(0, test.getMillis()); 1285 } 1286 1287 public void testFactorySeconds() throws Throwable { 1288 Period test = Period.seconds(6); 1289 assertEquals(PeriodType.standard(), test.getPeriodType()); 1290 assertEquals(0, test.getYears()); 1291 assertEquals(0, test.getMonths()); 1292 assertEquals(0, test.getWeeks()); 1293 assertEquals(0, test.getDays()); 1294 assertEquals(0, test.getHours()); 1295 assertEquals(0, test.getMinutes()); 1296 assertEquals(6, test.getSeconds()); 1297 assertEquals(0, test.getMillis()); 1298 } 1299 1300 public void testFactoryMillis() throws Throwable { 1301 Period test = Period.millis(6); 1302 assertEquals(PeriodType.standard(), test.getPeriodType()); 1303 assertEquals(0, test.getYears()); 1304 assertEquals(0, test.getMonths()); 1305 assertEquals(0, test.getWeeks()); 1306 assertEquals(0, test.getDays()); 1307 assertEquals(0, test.getHours()); 1308 assertEquals(0, test.getMinutes()); 1309 assertEquals(0, test.getSeconds()); 1310 assertEquals(6, test.getMillis()); 1311 } 1312 1313 //----------------------------------------------------------------------- 1314 public void testFactoryFieldDifference1() throws Throwable { 1315 YearMonthDay start = new YearMonthDay(2005, 4, 9); 1316 DateTimeFieldType[] types = new DateTimeFieldType[] { 1317 DateTimeFieldType.year(), 1318 DateTimeFieldType.monthOfYear(), 1319 DateTimeFieldType.dayOfMonth(), 1320 }; 1321 Partial end = new Partial(types, new int[] {2004, 6, 7}); 1322 Period test = Period.fieldDifference(start, end); 1323 assertEquals(PeriodType.yearMonthDay(), test.getPeriodType()); 1324 assertEquals(-1, test.getYears()); 1325 assertEquals(2, test.getMonths()); 1326 assertEquals(0, test.getWeeks()); 1327 assertEquals(-2, test.getDays()); 1328 assertEquals(0, test.getHours()); 1329 assertEquals(0, test.getMinutes()); 1330 assertEquals(0, test.getSeconds()); 1331 assertEquals(0, test.getMillis()); 1332 } 1333 1334 public void testFactoryFieldDifference2() throws Throwable { 1335 YearMonthDay ymd = new YearMonthDay(2005, 4, 9); 1336 try { 1337 Period.fieldDifference(ymd, (ReadablePartial) null); 1338 fail(); 1339 } catch (IllegalArgumentException ex) {} 1340 try { 1341 Period.fieldDifference((ReadablePartial) null, ymd); 1342 fail(); 1343 } catch (IllegalArgumentException ex) {} 1344 } 1345 1346 public void testFactoryFieldDifference3() throws Throwable { 1347 YearMonthDay start = new YearMonthDay(2005, 4, 9); 1348 TimeOfDay endTime = new TimeOfDay(12, 30, 40, 0); 1349 try { 1350 Period.fieldDifference(start, endTime); 1351 fail(); 1352 } catch (IllegalArgumentException ex) {} 1353 } 1354 1355 public void testFactoryFieldDifference4() throws Throwable { 1356 DateTimeFieldType[] types = new DateTimeFieldType[] { 1357 DateTimeFieldType.year(), 1358 DateTimeFieldType.monthOfYear(), 1359 DateTimeFieldType.dayOfWeek(), 1360 }; 1361 YearMonthDay start = new YearMonthDay(2005, 4, 9); 1362 Partial end = new Partial(types, new int[] {1, 2, 3}); 1363 try { 1364 Period.fieldDifference(start, end); 1365 fail(); 1366 } catch (IllegalArgumentException ex) {} 1367 } 1368 1369 public void testFactoryFieldDifference5() throws Throwable { 1370 DateTimeFieldType[] types = new DateTimeFieldType[] { 1371 DateTimeFieldType.year(), 1372 DateTimeFieldType.dayOfMonth(), 1373 DateTimeFieldType.dayOfWeek(), 1374 }; 1375 Partial start = new Partial(types, new int[] {1, 2, 3}); 1376 Partial end = new Partial(types, new int[] {1, 2, 3}); 1377 try { 1378 Period.fieldDifference(start, end); 1379 fail(); 1380 } catch (IllegalArgumentException ex) {} 1381 } 1382 1383 }