001 /* 002 * Copyright 2001-2005 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.ISOChronology; 025 026 /** 027 * This class is a JUnit test for MutableDuration. 028 * 029 * @author Stephen Colebourne 030 */ 031 public class TestMutablePeriod_Updates extends TestCase { 032 // Test in 2002/03 as time zones are more well known 033 // (before the late 90's they were all over the place) 034 035 private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris"); 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 // 2002-04-05 052 private long TEST_TIME1 = 053 (y2002days + 31L + 28L + 31L + 5L -1L) * DateTimeConstants.MILLIS_PER_DAY 054 + 12L * DateTimeConstants.MILLIS_PER_HOUR 055 + 24L * DateTimeConstants.MILLIS_PER_MINUTE; 056 057 // 2003-05-06 058 private long TEST_TIME2 = 059 (y2003days + 31L + 28L + 31L + 30L + 6L -1L) * DateTimeConstants.MILLIS_PER_DAY 060 + 14L * DateTimeConstants.MILLIS_PER_HOUR 061 + 28L * DateTimeConstants.MILLIS_PER_MINUTE; 062 063 private DateTimeZone originalDateTimeZone = null; 064 private TimeZone originalTimeZone = null; 065 private Locale originalLocale = null; 066 067 public static void main(String[] args) { 068 junit.textui.TestRunner.run(suite()); 069 } 070 071 public static TestSuite suite() { 072 return new TestSuite(TestMutablePeriod_Updates.class); 073 } 074 075 public TestMutablePeriod_Updates(String name) { 076 super(name); 077 } 078 079 protected void setUp() throws Exception { 080 DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW); 081 originalDateTimeZone = DateTimeZone.getDefault(); 082 originalTimeZone = TimeZone.getDefault(); 083 originalLocale = Locale.getDefault(); 084 DateTimeZone.setDefault(LONDON); 085 TimeZone.setDefault(TimeZone.getTimeZone("Europe/London")); 086 Locale.setDefault(Locale.UK); 087 } 088 089 protected void tearDown() throws Exception { 090 DateTimeUtils.setCurrentMillisSystem(); 091 DateTimeZone.setDefault(originalDateTimeZone); 092 TimeZone.setDefault(originalTimeZone); 093 Locale.setDefault(originalLocale); 094 originalDateTimeZone = null; 095 originalTimeZone = null; 096 originalLocale = null; 097 } 098 099 //----------------------------------------------------------------------- 100 public void testTest() { 101 assertEquals("2002-06-09T00:00:00.000Z", new Instant(TEST_TIME_NOW).toString()); 102 assertEquals("2002-04-05T12:24:00.000Z", new Instant(TEST_TIME1).toString()); 103 assertEquals("2003-05-06T14:28:00.000Z", new Instant(TEST_TIME2).toString()); 104 } 105 106 //----------------------------------------------------------------------- 107 public void testClear() { 108 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 109 test.clear(); 110 assertEquals(new MutablePeriod(), test); 111 112 test = new MutablePeriod(1, 2, 0, 4, 5, 6, 7, 8, PeriodType.yearMonthDayTime()); 113 test.clear(); 114 assertEquals(new MutablePeriod(PeriodType.yearMonthDayTime()), test); 115 } 116 117 //----------------------------------------------------------------------- 118 public void testAddYears() { 119 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 120 test.addYears(10); 121 assertEquals(11, test.getYears()); 122 123 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 124 test.addYears(-10); 125 assertEquals(-9, test.getYears()); 126 127 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 128 test.addYears(0); 129 assertEquals(1, test.getYears()); 130 } 131 132 //----------------------------------------------------------------------- 133 public void testAddMonths() { 134 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 135 test.addMonths(10); 136 assertEquals(12, test.getMonths()); 137 138 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 139 test.addMonths(-10); 140 assertEquals(-8, test.getMonths()); 141 142 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 143 test.addMonths(0); 144 assertEquals(2, test.getMonths()); 145 } 146 147 //----------------------------------------------------------------------- 148 public void testAddWeeks() { 149 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 150 test.addWeeks(10); 151 assertEquals(13, test.getWeeks()); 152 153 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 154 test.addWeeks(-10); 155 assertEquals(-7, test.getWeeks()); 156 157 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 158 test.addWeeks(0); 159 assertEquals(3, test.getWeeks()); 160 } 161 162 //----------------------------------------------------------------------- 163 public void testAddDays() { 164 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 165 test.addDays(10); 166 assertEquals(14, test.getDays()); 167 168 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 169 test.addDays(-10); 170 assertEquals(-6, test.getDays()); 171 172 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 173 test.addDays(0); 174 assertEquals(4, test.getDays()); 175 } 176 177 //----------------------------------------------------------------------- 178 public void testAddHours() { 179 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 180 test.addHours(10); 181 assertEquals(15, test.getHours()); 182 183 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 184 test.addHours(-10); 185 assertEquals(-5, test.getHours()); 186 187 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 188 test.addHours(0); 189 assertEquals(5, test.getHours()); 190 } 191 192 //----------------------------------------------------------------------- 193 public void testAddMinutes() { 194 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 195 test.addMinutes(10); 196 assertEquals(16, test.getMinutes()); 197 198 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 199 test.addMinutes(-10); 200 assertEquals(-4, test.getMinutes()); 201 202 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 203 test.addMinutes(0); 204 assertEquals(6, test.getMinutes()); 205 } 206 207 //----------------------------------------------------------------------- 208 public void testAddSeconds() { 209 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 210 test.addSeconds(10); 211 assertEquals(17, test.getSeconds()); 212 213 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 214 test.addSeconds(-10); 215 assertEquals(-3, test.getSeconds()); 216 217 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 218 test.addSeconds(0); 219 assertEquals(7, test.getSeconds()); 220 } 221 222 //----------------------------------------------------------------------- 223 public void testAddMillis() { 224 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 225 test.addMillis(10); 226 assertEquals(18, test.getMillis()); 227 228 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 229 test.addMillis(-10); 230 assertEquals(-2, test.getMillis()); 231 232 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 233 test.addMillis(0); 234 assertEquals(8, test.getMillis()); 235 } 236 237 //----------------------------------------------------------------------- 238 public void testSetYears() { 239 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 240 test.setYears(10); 241 assertEquals(10, test.getYears()); 242 243 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 244 test.setYears(-10); 245 assertEquals(-10, test.getYears()); 246 247 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 248 test.setYears(0); 249 assertEquals(0, test.getYears()); 250 251 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 252 test.setYears(1); 253 assertEquals(1, test.getYears()); 254 255 test = new MutablePeriod(0, 0, 0, 0, 0, 0, 0, 1, PeriodType.millis()); 256 try { 257 test.setYears(1); 258 fail(); 259 } catch (IllegalArgumentException ex) {} 260 } 261 262 //----------------------------------------------------------------------- 263 public void testSetMonths() { 264 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 265 test.setMonths(10); 266 assertEquals(10, test.getMonths()); 267 268 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 269 test.setMonths(-10); 270 assertEquals(-10, test.getMonths()); 271 272 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 273 test.setMonths(0); 274 assertEquals(0, test.getMonths()); 275 276 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 277 test.setMonths(2); 278 assertEquals(2, test.getMonths()); 279 } 280 281 //----------------------------------------------------------------------- 282 public void testSetWeeks() { 283 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 284 test.setWeeks(10); 285 assertEquals(10, test.getWeeks()); 286 287 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 288 test.setWeeks(-10); 289 assertEquals(-10, test.getWeeks()); 290 291 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 292 test.setWeeks(0); 293 assertEquals(0, test.getWeeks()); 294 295 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 296 test.setWeeks(3); 297 assertEquals(3, test.getWeeks()); 298 } 299 300 //----------------------------------------------------------------------- 301 public void testSetDays() { 302 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 303 test.setDays(10); 304 assertEquals(10, test.getDays()); 305 306 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 307 test.setDays(-10); 308 assertEquals(-10, test.getDays()); 309 310 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 311 test.setDays(0); 312 assertEquals(0, test.getDays()); 313 314 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 315 test.setDays(4); 316 assertEquals(4, test.getDays()); 317 } 318 319 //----------------------------------------------------------------------- 320 public void testSetHours() { 321 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 322 test.setHours(10); 323 assertEquals(10, test.getHours()); 324 325 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 326 test.setHours(-10); 327 assertEquals(-10, test.getHours()); 328 329 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 330 test.setHours(0); 331 assertEquals(0, test.getHours()); 332 333 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 334 test.setHours(5); 335 assertEquals(5, test.getHours()); 336 } 337 338 //----------------------------------------------------------------------- 339 public void testSetMinutes() { 340 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 341 test.setMinutes(10); 342 assertEquals(10, test.getMinutes()); 343 344 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 345 test.setMinutes(-10); 346 assertEquals(-10, test.getMinutes()); 347 348 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 349 test.setMinutes(0); 350 assertEquals(0, test.getMinutes()); 351 352 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 353 test.setMinutes(6); 354 assertEquals(6, test.getMinutes()); 355 } 356 357 //----------------------------------------------------------------------- 358 public void testSetSeconds() { 359 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 360 test.setSeconds(10); 361 assertEquals(10, test.getSeconds()); 362 363 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 364 test.setSeconds(-10); 365 assertEquals(-10, test.getSeconds()); 366 367 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 368 test.setSeconds(0); 369 assertEquals(0, test.getSeconds()); 370 371 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 372 test.setSeconds(7); 373 assertEquals(7, test.getSeconds()); 374 } 375 376 //----------------------------------------------------------------------- 377 public void testSetMillis() { 378 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 379 test.setMillis(10); 380 assertEquals(10, test.getMillis()); 381 382 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 383 test.setMillis(-10); 384 assertEquals(-10, test.getMillis()); 385 386 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 387 test.setMillis(0); 388 assertEquals(0, test.getMillis()); 389 390 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 391 test.setMillis(8); 392 assertEquals(8, test.getMillis()); 393 } 394 395 //----------------------------------------------------------------------- 396 public void testSet_Field() { 397 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 398 test.set(DurationFieldType.years(), 10); 399 assertEquals(10, test.getYears()); 400 401 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 402 try { 403 test.set(null, 10); 404 fail(); 405 } catch (IllegalArgumentException ex) {} 406 } 407 408 //----------------------------------------------------------------------- 409 public void testAdd_Field() { 410 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 411 test.add(DurationFieldType.years(), 10); 412 assertEquals(11, test.getYears()); 413 414 test = new MutablePeriod(0, 0, 0, 0, 0, 0, 0, 1, PeriodType.millis()); 415 test.add(DurationFieldType.years(), 0); 416 assertEquals(0, test.getYears()); 417 assertEquals(1, test.getMillis()); 418 419 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 420 try { 421 test.add(null, 0); 422 fail(); 423 } catch (IllegalArgumentException ex) {} 424 425 test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 426 try { 427 test.add(null, 10); 428 fail(); 429 } catch (IllegalArgumentException ex) {} 430 } 431 432 //----------------------------------------------------------------------- 433 public void testSetPeriod_8ints1() { 434 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 435 test.setPeriod(11, 12, 13, 14, 15, 16, 17, 18); 436 assertEquals(11, test.getYears()); 437 assertEquals(12, test.getMonths()); 438 assertEquals(13, test.getWeeks()); 439 assertEquals(14, test.getDays()); 440 assertEquals(15, test.getHours()); 441 assertEquals(16, test.getMinutes()); 442 assertEquals(17, test.getSeconds()); 443 assertEquals(18, test.getMillis()); 444 } 445 446 public void testSetPeriod_8ints2() { 447 MutablePeriod test = new MutablePeriod(100L, PeriodType.millis()); 448 try { 449 test.setPeriod(11, 12, 13, 14, 15, 16, 17, 18); 450 fail(); 451 } catch (IllegalArgumentException ex) {} 452 assertEquals(0, test.getYears()); 453 assertEquals(0, test.getMonths()); 454 assertEquals(0, test.getWeeks()); 455 assertEquals(0, test.getDays()); 456 assertEquals(0, test.getHours()); 457 assertEquals(0, test.getMinutes()); 458 assertEquals(0, test.getSeconds()); 459 assertEquals(100, test.getMillis()); 460 } 461 462 public void testSetPeriod_8ints3() { 463 MutablePeriod test = new MutablePeriod(100L, PeriodType.millis()); 464 test.setPeriod(0, 0, 0, 0, 0, 0, 0, 18); 465 assertEquals(0, test.getYears()); 466 assertEquals(0, test.getMonths()); 467 assertEquals(0, test.getWeeks()); 468 assertEquals(0, test.getDays()); 469 assertEquals(0, test.getHours()); 470 assertEquals(0, test.getMinutes()); 471 assertEquals(0, test.getSeconds()); 472 assertEquals(18, test.getMillis()); 473 } 474 475 public void testSetPeriod_8ints4() { 476 MutablePeriod test = new MutablePeriod(0, 0, 0, 0, 5, 6, 7, 8); 477 test.setPeriod(11, 12, 13, 14, 15, 16, 17, 18); 478 assertEquals(11, test.getYears()); 479 assertEquals(12, test.getMonths()); 480 assertEquals(13, test.getWeeks()); 481 assertEquals(14, test.getDays()); 482 assertEquals(15, test.getHours()); 483 assertEquals(16, test.getMinutes()); 484 assertEquals(17, test.getSeconds()); 485 assertEquals(18, test.getMillis()); 486 } 487 488 //----------------------------------------------------------------------- 489 public void testSetPeriod_RP1() { 490 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 491 test.setPeriod(new MutablePeriod(11, 12, 13, 14, 15, 16, 17, 18)); 492 assertEquals(11, test.getYears()); 493 assertEquals(12, test.getMonths()); 494 assertEquals(13, test.getWeeks()); 495 assertEquals(14, test.getDays()); 496 assertEquals(15, test.getHours()); 497 assertEquals(16, test.getMinutes()); 498 assertEquals(17, test.getSeconds()); 499 assertEquals(18, test.getMillis()); 500 } 501 502 public void testSetPeriod_RP2() { 503 MutablePeriod test = new MutablePeriod(100L, PeriodType.millis()); 504 try { 505 test.setPeriod(new MutablePeriod(11, 12, 13, 14, 15, 16, 17, 18)); 506 fail(); 507 } catch (IllegalArgumentException ex) {} 508 assertEquals(0, test.getYears()); 509 assertEquals(0, test.getMonths()); 510 assertEquals(0, test.getWeeks()); 511 assertEquals(0, test.getDays()); 512 assertEquals(0, test.getHours()); 513 assertEquals(0, test.getMinutes()); 514 assertEquals(0, test.getSeconds()); 515 assertEquals(100, test.getMillis()); 516 } 517 518 public void testSetPeriod_RP3() { 519 MutablePeriod test = new MutablePeriod(100L, PeriodType.millis()); 520 test.setPeriod(new MutablePeriod(0, 0, 0, 0, 0, 0, 0, 18)); 521 assertEquals(0, test.getYears()); 522 assertEquals(0, test.getMonths()); 523 assertEquals(0, test.getWeeks()); 524 assertEquals(0, test.getDays()); 525 assertEquals(0, test.getHours()); 526 assertEquals(0, test.getMinutes()); 527 assertEquals(0, test.getSeconds()); 528 assertEquals(18, test.getMillis()); 529 } 530 531 public void testSetPeriod_RP4() { 532 MutablePeriod test = new MutablePeriod(0, 0, 0, 0, 5, 6, 7, 8); 533 test.setPeriod(new MutablePeriod(11, 12, 13, 14, 15, 16, 17, 18)); 534 assertEquals(11, test.getYears()); 535 assertEquals(12, test.getMonths()); 536 assertEquals(13, test.getWeeks()); 537 assertEquals(14, test.getDays()); 538 assertEquals(15, test.getHours()); 539 assertEquals(16, test.getMinutes()); 540 assertEquals(17, test.getSeconds()); 541 assertEquals(18, test.getMillis()); 542 } 543 544 public void testSetPeriod_RP5() { 545 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 546 test.setPeriod((ReadablePeriod) null); 547 assertEquals(0, test.getYears()); 548 assertEquals(0, test.getMonths()); 549 assertEquals(0, test.getWeeks()); 550 assertEquals(0, test.getDays()); 551 assertEquals(0, test.getHours()); 552 assertEquals(0, test.getMinutes()); 553 assertEquals(0, test.getSeconds()); 554 assertEquals(0, test.getMillis()); 555 } 556 557 //----------------------------------------------------------------------- 558 public void testSetPeriod_long_long1() { 559 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 560 DateTime dt1 = new DateTime(2002, 6, 9, 13, 15, 17, 19); 561 DateTime dt2 = new DateTime(2003, 7, 17, 14, 16, 18, 20); 562 test.setPeriod(dt1.getMillis(), dt2.getMillis()); 563 assertEquals(1, test.getYears()); 564 assertEquals(1, test.getMonths()); 565 assertEquals(1, test.getWeeks()); 566 assertEquals(1, test.getDays()); 567 assertEquals(1, test.getHours()); 568 assertEquals(1, test.getMinutes()); 569 assertEquals(1, test.getSeconds()); 570 assertEquals(1, test.getMillis()); 571 } 572 573 public void testSetPeriod_long_long2() { 574 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 575 DateTime dt1 = new DateTime(2002, 6, 9, 13, 15, 17, 19); 576 DateTime dt2 = new DateTime(2003, 7, 17, 14, 16, 18, 20); 577 test.setPeriod(dt2.getMillis(), dt1.getMillis()); 578 assertEquals(-1, test.getYears()); 579 assertEquals(-1, test.getMonths()); 580 assertEquals(-1, test.getWeeks()); 581 assertEquals(-1, test.getDays()); 582 assertEquals(-1, test.getHours()); 583 assertEquals(-1, test.getMinutes()); 584 assertEquals(-1, test.getSeconds()); 585 assertEquals(-1, test.getMillis()); 586 } 587 588 public void testSetPeriod_long_long3() { 589 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 590 DateTime dt1 = new DateTime(2002, 6, 9, 13, 15, 17, 19); 591 test.setPeriod(dt1.getMillis(), dt1.getMillis()); 592 assertEquals(0, test.getYears()); 593 assertEquals(0, test.getMonths()); 594 assertEquals(0, test.getWeeks()); 595 assertEquals(0, test.getDays()); 596 assertEquals(0, test.getHours()); 597 assertEquals(0, test.getMinutes()); 598 assertEquals(0, test.getSeconds()); 599 assertEquals(0, test.getMillis()); 600 } 601 602 public void testSetPeriod_long_long_NoYears() { 603 MutablePeriod test = new MutablePeriod(PeriodType.standard().withYearsRemoved()); 604 DateTime dt1 = new DateTime(2002, 6, 9, 13, 15, 17, 19); 605 DateTime dt2 = new DateTime(2003, 7, 17, 14, 16, 18, 20); 606 test.setPeriod(dt1.getMillis(), dt2.getMillis()); 607 assertEquals(0, test.getYears()); 608 assertEquals(13, test.getMonths()); 609 assertEquals(1, test.getWeeks()); 610 assertEquals(1, test.getDays()); 611 assertEquals(1, test.getHours()); 612 assertEquals(1, test.getMinutes()); 613 assertEquals(1, test.getSeconds()); 614 assertEquals(1, test.getMillis()); 615 } 616 617 public void testSetPeriod_long_long_NoMonths() { 618 MutablePeriod test = new MutablePeriod(PeriodType.standard().withMonthsRemoved()); 619 DateTime dt1 = new DateTime(2002, 6, 9, 13, 15, 17, 19); 620 DateTime dt2 = new DateTime(2003, 7, 17, 14, 16, 18, 20); 621 test.setPeriod(dt1.getMillis(), dt2.getMillis()); 622 assertEquals(1, test.getYears()); 623 assertEquals(0, test.getMonths()); 624 assertEquals(5, test.getWeeks()); 625 assertEquals(3, test.getDays()); 626 assertEquals(1, test.getHours()); 627 assertEquals(1, test.getMinutes()); 628 assertEquals(1, test.getSeconds()); 629 assertEquals(1, test.getMillis()); 630 } 631 632 public void testSetPeriod_long_long_NoWeeks() { 633 MutablePeriod test = new MutablePeriod(PeriodType.standard().withWeeksRemoved()); 634 DateTime dt1 = new DateTime(2002, 6, 9, 13, 15, 17, 19); 635 DateTime dt2 = new DateTime(2003, 7, 17, 14, 16, 18, 20); 636 test.setPeriod(dt1.getMillis(), dt2.getMillis()); 637 assertEquals(1, test.getYears()); 638 assertEquals(1, test.getMonths()); 639 assertEquals(0, test.getWeeks()); 640 assertEquals(8, test.getDays()); 641 assertEquals(1, test.getHours()); 642 assertEquals(1, test.getMinutes()); 643 assertEquals(1, test.getSeconds()); 644 assertEquals(1, test.getMillis()); 645 } 646 647 public void testSetPeriod_long_long_NoDays() { 648 MutablePeriod test = new MutablePeriod(PeriodType.standard().withDaysRemoved()); 649 DateTime dt1 = new DateTime(2002, 6, 9, 13, 15, 17, 19); 650 DateTime dt2 = new DateTime(2003, 7, 17, 14, 16, 18, 20); 651 test.setPeriod(dt1.getMillis(), dt2.getMillis()); 652 assertEquals(1, test.getYears()); 653 assertEquals(1, test.getMonths()); 654 assertEquals(1, test.getWeeks()); 655 assertEquals(0, test.getDays()); 656 assertEquals(25, test.getHours()); 657 assertEquals(1, test.getMinutes()); 658 assertEquals(1, test.getSeconds()); 659 assertEquals(1, test.getMillis()); 660 } 661 662 public void testSetPeriod_long_long_NoHours() { 663 MutablePeriod test = new MutablePeriod(PeriodType.standard().withHoursRemoved()); 664 DateTime dt1 = new DateTime(2002, 6, 9, 13, 15, 17, 19); 665 DateTime dt2 = new DateTime(2003, 7, 17, 14, 16, 18, 20); 666 test.setPeriod(dt1.getMillis(), dt2.getMillis()); 667 assertEquals(1, test.getYears()); 668 assertEquals(1, test.getMonths()); 669 assertEquals(1, test.getWeeks()); 670 assertEquals(1, test.getDays()); 671 assertEquals(0, test.getHours()); 672 assertEquals(61, test.getMinutes()); 673 assertEquals(1, test.getSeconds()); 674 assertEquals(1, test.getMillis()); 675 } 676 677 public void testSetPeriod_long_long_NoMinutes() { 678 MutablePeriod test = new MutablePeriod(PeriodType.standard().withMinutesRemoved()); 679 DateTime dt1 = new DateTime(2002, 6, 9, 13, 15, 17, 19); 680 DateTime dt2 = new DateTime(2003, 7, 17, 14, 16, 18, 20); 681 test.setPeriod(dt1.getMillis(), dt2.getMillis()); 682 assertEquals(1, test.getYears()); 683 assertEquals(1, test.getMonths()); 684 assertEquals(1, test.getWeeks()); 685 assertEquals(1, test.getDays()); 686 assertEquals(1, test.getHours()); 687 assertEquals(0, test.getMinutes()); 688 assertEquals(61, test.getSeconds()); 689 assertEquals(1, test.getMillis()); 690 } 691 692 public void testSetPeriod_long_long_NoSeconds() { 693 MutablePeriod test = new MutablePeriod(PeriodType.standard().withSecondsRemoved()); 694 DateTime dt1 = new DateTime(2002, 6, 9, 13, 15, 17, 19); 695 DateTime dt2 = new DateTime(2003, 7, 17, 14, 16, 18, 20); 696 test.setPeriod(dt1.getMillis(), dt2.getMillis()); 697 assertEquals(1, test.getYears()); 698 assertEquals(1, test.getMonths()); 699 assertEquals(1, test.getWeeks()); 700 assertEquals(1, test.getDays()); 701 assertEquals(1, test.getHours()); 702 assertEquals(1, test.getMinutes()); 703 assertEquals(0, test.getSeconds()); 704 assertEquals(1001, test.getMillis()); 705 } 706 707 public void testSetPeriod_long_long_NoMillis() { 708 MutablePeriod test = new MutablePeriod(PeriodType.standard().withMillisRemoved()); 709 DateTime dt1 = new DateTime(2002, 6, 9, 13, 15, 17, 19); 710 DateTime dt2 = new DateTime(2003, 7, 17, 14, 16, 18, 20); 711 test.setPeriod(dt1.getMillis(), dt2.getMillis()); 712 assertEquals(1, test.getYears()); 713 assertEquals(1, test.getMonths()); 714 assertEquals(1, test.getWeeks()); 715 assertEquals(1, test.getDays()); 716 assertEquals(1, test.getHours()); 717 assertEquals(1, test.getMinutes()); 718 assertEquals(1, test.getSeconds()); 719 assertEquals(0, test.getMillis()); 720 } 721 722 //----------------------------------------------------------------------- 723 public void testSetPeriod_RI_RI1() { 724 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 725 DateTime dt1 = new DateTime(2002, 6, 9, 13, 15, 17, 19); 726 DateTime dt2 = new DateTime(2003, 7, 17, 14, 16, 18, 20); 727 test.setPeriod(dt1, dt2); 728 assertEquals(1, test.getYears()); 729 assertEquals(1, test.getMonths()); 730 assertEquals(1, test.getWeeks()); 731 assertEquals(1, test.getDays()); 732 assertEquals(1, test.getHours()); 733 assertEquals(1, test.getMinutes()); 734 assertEquals(1, test.getSeconds()); 735 assertEquals(1, test.getMillis()); 736 } 737 738 public void testSetPeriod_RI_RI2() { 739 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 740 DateTime dt1 = new DateTime(2002, 6, 9, 13, 15, 17, 19); 741 DateTime dt2 = new DateTime(2003, 7, 17, 14, 16, 18, 20); 742 test.setPeriod(dt2, dt1); 743 assertEquals(-1, test.getYears()); 744 assertEquals(-1, test.getMonths()); 745 assertEquals(-1, test.getWeeks()); 746 assertEquals(-1, test.getDays()); 747 assertEquals(-1, test.getHours()); 748 assertEquals(-1, test.getMinutes()); 749 assertEquals(-1, test.getSeconds()); 750 assertEquals(-1, test.getMillis()); 751 } 752 753 public void testSetPeriod_RI_RI3() { 754 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 755 DateTime dt1 = new DateTime(2002, 6, 9, 13, 15, 17, 19); 756 test.setPeriod(dt1, dt1); 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 testSetPeriod_RInterval1() { 769 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 770 DateTime dt1 = new DateTime(2002, 6, 9, 13, 15, 17, 19); 771 DateTime dt2 = new DateTime(2003, 7, 17, 14, 16, 18, 20); 772 test.setPeriod(new Interval(dt1, dt2)); 773 assertEquals(1, test.getYears()); 774 assertEquals(1, test.getMonths()); 775 assertEquals(1, test.getWeeks()); 776 assertEquals(1, test.getDays()); 777 assertEquals(1, test.getHours()); 778 assertEquals(1, test.getMinutes()); 779 assertEquals(1, test.getSeconds()); 780 assertEquals(1, test.getMillis()); 781 } 782 783 public void testSetPeriod_RInterval2() { 784 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 785 test.setPeriod((ReadableInterval) null); 786 assertEquals(0, test.getYears()); 787 assertEquals(0, test.getMonths()); 788 assertEquals(0, test.getWeeks()); 789 assertEquals(0, test.getDays()); 790 assertEquals(0, test.getHours()); 791 assertEquals(0, test.getMinutes()); 792 assertEquals(0, test.getSeconds()); 793 assertEquals(0, test.getMillis()); 794 } 795 796 //----------------------------------------------------------------------- 797 public void testSetPeriod_long1() { 798 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 799 test.setPeriod(100L); 800 assertEquals(0, test.getYears()); 801 assertEquals(0, test.getMonths()); 802 assertEquals(0, test.getWeeks()); 803 assertEquals(0, test.getDays()); 804 assertEquals(0, test.getHours()); 805 assertEquals(0, test.getMinutes()); 806 assertEquals(0, test.getSeconds()); 807 assertEquals(100, test.getMillis()); 808 } 809 810 public void testSetPeriod_long2() { 811 MutablePeriod test = new MutablePeriod(); 812 test.setPeriod( 813 (4L + (3L * 7L) + (2L * 30L) + 365L) * DateTimeConstants.MILLIS_PER_DAY + 814 5L * DateTimeConstants.MILLIS_PER_HOUR + 815 6L * DateTimeConstants.MILLIS_PER_MINUTE + 816 7L * DateTimeConstants.MILLIS_PER_SECOND + 8L); 817 // only time fields are precise 818 assertEquals(0, test.getYears()); // (4 + (3 * 7) + (2 * 30) + 365) == 450 819 assertEquals(0, test.getMonths()); 820 assertEquals(0, test.getWeeks()); 821 assertEquals(0, test.getDays()); 822 assertEquals((450 * 24) + 5, test.getHours()); 823 assertEquals(6, test.getMinutes()); 824 assertEquals(7, test.getSeconds()); 825 assertEquals(8, test.getMillis()); 826 } 827 828 // public void testSetPeriod_long3() { 829 // MutablePeriod test = new MutablePeriod(PeriodType.getPreciseYearMonthType()); 830 // test.setPeriod( 831 // (4L + (3L * 7L) + (2L * 30L) + 365L) * DateTimeConstants.MILLIS_PER_DAY + 832 // 5L * DateTimeConstants.MILLIS_PER_HOUR + 833 // 6L * DateTimeConstants.MILLIS_PER_MINUTE + 834 // 7L * DateTimeConstants.MILLIS_PER_SECOND + 8L); 835 // assertEquals(1, test.getYears()); 836 // assertEquals(2, test.getMonths()); 837 // assertEquals(0, test.getWeeks()); 838 // assertEquals(25, test.getDays()); 839 // assertEquals(5, test.getHours()); 840 // assertEquals(6, test.getMinutes()); 841 // assertEquals(7, test.getSeconds()); 842 // assertEquals(8, test.getMillis()); 843 // } 844 // 845 // public void testSetPeriod_long4() { 846 // MutablePeriod test = new MutablePeriod(PeriodType.getPreciseYearWeekType()); 847 // test.setPeriod( 848 // (4L + (3L * 7L) + (2L * 30L) + 365L) * DateTimeConstants.MILLIS_PER_DAY + 849 // 5L * DateTimeConstants.MILLIS_PER_HOUR + 850 // 6L * DateTimeConstants.MILLIS_PER_MINUTE + 851 // 7L * DateTimeConstants.MILLIS_PER_SECOND + 8L); 852 // assertEquals(1, test.getYears()); 853 // assertEquals(0, test.getMonths()); 854 // assertEquals(12, test.getWeeks()); 855 // assertEquals(1, test.getDays()); 856 // assertEquals(5, test.getHours()); 857 // assertEquals(6, test.getMinutes()); 858 // assertEquals(7, test.getSeconds()); 859 // assertEquals(8, test.getMillis()); 860 // } 861 // 862 // public void testSetPeriod_long_NoYears() { 863 // long ms = 864 // (4L + (3L * 7L) + (2L * 30L) + 365L) * DateTimeConstants.MILLIS_PER_DAY + 865 // 5L * DateTimeConstants.MILLIS_PER_HOUR + 866 // 6L * DateTimeConstants.MILLIS_PER_MINUTE + 867 // 7L * DateTimeConstants.MILLIS_PER_SECOND + 8L; 868 // MutablePeriod test = new MutablePeriod(PeriodType.getPreciseYearMonthType().withYearsRemoved()); 869 // test.setPeriod(ms); 870 // assertEquals(0, test.getYears()); 871 // assertEquals(15, test.getMonths()); // totalDays=365+85=450=15*30 872 // assertEquals(0, test.getWeeks()); 873 // assertEquals(0, test.getDays()); 874 // assertEquals(5, test.getHours()); 875 // assertEquals(6, test.getMinutes()); 876 // assertEquals(7, test.getSeconds()); 877 // assertEquals(8, test.getMillis()); 878 // assertEquals(ms, test.toDurationMillis()); 879 // } 880 // 881 // public void testSetPeriod_long_NoMonths() { 882 // long ms = 883 // (4L + (3L * 7L) + (2L * 30L) + 365L) * DateTimeConstants.MILLIS_PER_DAY + 884 // 5L * DateTimeConstants.MILLIS_PER_HOUR + 885 // 6L * DateTimeConstants.MILLIS_PER_MINUTE + 886 // 7L * DateTimeConstants.MILLIS_PER_SECOND + 8L; 887 // MutablePeriod test = new MutablePeriod(PeriodType.getPreciseYearMonthType().withMonthsRemoved()); 888 // test.setPeriod(ms); 889 // assertEquals(1, test.getYears()); 890 // assertEquals(0, test.getMonths()); 891 // assertEquals(0, test.getWeeks()); 892 // assertEquals(85, test.getDays()); 893 // assertEquals(5, test.getHours()); 894 // assertEquals(6, test.getMinutes()); 895 // assertEquals(7, test.getSeconds()); 896 // assertEquals(8, test.getMillis()); 897 // assertEquals(ms, test.toDurationMillis()); 898 // } 899 // 900 // public void testSetPeriod_long_NoWeeks() { 901 // long ms = 902 // (4L + (3L * 7L) + (2L * 30L) + 365L) * DateTimeConstants.MILLIS_PER_DAY + 903 // 5L * DateTimeConstants.MILLIS_PER_HOUR + 904 // 6L * DateTimeConstants.MILLIS_PER_MINUTE + 905 // 7L * DateTimeConstants.MILLIS_PER_SECOND + 8L; 906 // MutablePeriod test = new MutablePeriod(PeriodType.getPreciseYearWeekType().withWeeksRemoved()); 907 // test.setPeriod(ms); 908 // assertEquals(1, test.getYears()); 909 // assertEquals(0, test.getMonths()); 910 // assertEquals(0, test.getWeeks()); 911 // assertEquals(85, test.getDays()); 912 // assertEquals(5, test.getHours()); 913 // assertEquals(6, test.getMinutes()); 914 // assertEquals(7, test.getSeconds()); 915 // assertEquals(8, test.getMillis()); 916 // assertEquals(ms, test.toDurationMillis()); 917 // } 918 // 919 // public void testSetPeriod_long_NoDays() { 920 // long ms = 921 // (4L + (3L * 7L) + (2L * 30L) + 365L) * DateTimeConstants.MILLIS_PER_DAY + 922 // 5L * DateTimeConstants.MILLIS_PER_HOUR + 923 // 6L * DateTimeConstants.MILLIS_PER_MINUTE + 924 // 7L * DateTimeConstants.MILLIS_PER_SECOND + 8L; 925 // MutablePeriod test = new MutablePeriod(PeriodType.getPreciseYearMonthType().withDaysRemoved()); 926 // test.setPeriod(ms); 927 // assertEquals(1, test.getYears()); 928 // assertEquals(2, test.getMonths()); 929 // assertEquals(0, test.getWeeks()); 930 // assertEquals(0, test.getDays()); 931 // assertEquals(5 + 25 * 24, test.getHours()); 932 // assertEquals(6, test.getMinutes()); 933 // assertEquals(7, test.getSeconds()); 934 // assertEquals(8, test.getMillis()); 935 // assertEquals(ms, test.toDurationMillis()); 936 // } 937 // 938 // public void testSetPeriod_long_NoHours() { 939 // long ms = 940 // (4L + (3L * 7L) + (2L * 30L) + 365L) * DateTimeConstants.MILLIS_PER_DAY + 941 // 5L * DateTimeConstants.MILLIS_PER_HOUR + 942 // 6L * DateTimeConstants.MILLIS_PER_MINUTE + 943 // 7L * DateTimeConstants.MILLIS_PER_SECOND + 8L; 944 // MutablePeriod test = new MutablePeriod(PeriodType.getPreciseYearMonthType().withHoursRemoved()); 945 // test.setPeriod(ms); 946 // assertEquals(1, test.getYears()); 947 // assertEquals(2, test.getMonths()); 948 // assertEquals(0, test.getWeeks()); 949 // assertEquals(25, test.getDays()); 950 // assertEquals(0, test.getHours()); 951 // assertEquals(6 + 5 * 60, test.getMinutes()); 952 // assertEquals(7, test.getSeconds()); 953 // assertEquals(8, test.getMillis()); 954 // assertEquals(ms, test.toDurationMillis()); 955 // } 956 // 957 // public void testSetPeriod_long_NoMinutes() { 958 // long ms = 959 // (4L + (3L * 7L) + (2L * 30L) + 365L) * DateTimeConstants.MILLIS_PER_DAY + 960 // 5L * DateTimeConstants.MILLIS_PER_HOUR + 961 // 6L * DateTimeConstants.MILLIS_PER_MINUTE + 962 // 7L * DateTimeConstants.MILLIS_PER_SECOND + 8L; 963 // MutablePeriod test = new MutablePeriod(PeriodType.getPreciseYearMonthType().withMinutesRemoved()); 964 // test.setPeriod(ms); 965 // assertEquals(1, test.getYears()); 966 // assertEquals(2, test.getMonths()); 967 // assertEquals(0, test.getWeeks()); 968 // assertEquals(25, test.getDays()); 969 // assertEquals(5, test.getHours()); 970 // assertEquals(0, test.getMinutes()); 971 // assertEquals(7 + 6 * 60, test.getSeconds()); 972 // assertEquals(8, test.getMillis()); 973 // assertEquals(ms, test.toDurationMillis()); 974 // } 975 // 976 // public void testSetPeriod_long_NoSeconds() { 977 // long ms = 978 // (4L + (3L * 7L) + (2L * 30L) + 365L) * DateTimeConstants.MILLIS_PER_DAY + 979 // 5L * DateTimeConstants.MILLIS_PER_HOUR + 980 // 6L * DateTimeConstants.MILLIS_PER_MINUTE + 981 // 7L * DateTimeConstants.MILLIS_PER_SECOND + 8L; 982 // MutablePeriod test = new MutablePeriod(PeriodType.getPreciseYearMonthType().withSecondsRemoved()); 983 // test.setPeriod(ms); 984 // assertEquals(1, test.getYears()); 985 // assertEquals(2, test.getMonths()); 986 // assertEquals(0, test.getWeeks()); 987 // assertEquals(25, test.getDays()); 988 // assertEquals(5, test.getHours()); 989 // assertEquals(6, test.getMinutes()); 990 // assertEquals(0, test.getSeconds()); 991 // assertEquals(8 + 7 * 1000, test.getMillis()); 992 // assertEquals(ms, test.toDurationMillis()); 993 // } 994 // 995 // public void testSetPeriod_long_NoMillis() { 996 // long ms = 997 // (4L + (3L * 7L) + (2L * 30L) + 365L) * DateTimeConstants.MILLIS_PER_DAY + 998 // 5L * DateTimeConstants.MILLIS_PER_HOUR + 999 // 6L * DateTimeConstants.MILLIS_PER_MINUTE + 1000 // 7L * DateTimeConstants.MILLIS_PER_SECOND + 8L; 1001 // MutablePeriod test = new MutablePeriod(PeriodType.getPreciseYearMonthType().withMillisRemoved()); 1002 // test.setPeriod(ms); 1003 // assertEquals(1, test.getYears()); 1004 // assertEquals(2, test.getMonths()); 1005 // assertEquals(0, test.getWeeks()); 1006 // assertEquals(25, test.getDays()); 1007 // assertEquals(5, test.getHours()); 1008 // assertEquals(6, test.getMinutes()); 1009 // assertEquals(7, test.getSeconds()); 1010 // assertEquals(0, test.getMillis()); 1011 // assertEquals(ms - 8, test.toDurationMillis()); 1012 // } 1013 1014 //----------------------------------------------------------------------- 1015 public void testSetPeriod_RD1() { 1016 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 1017 test.setPeriod(new Duration(100L)); 1018 assertEquals(0, test.getYears()); 1019 assertEquals(0, test.getMonths()); 1020 assertEquals(0, test.getWeeks()); 1021 assertEquals(0, test.getDays()); 1022 assertEquals(0, test.getHours()); 1023 assertEquals(0, test.getMinutes()); 1024 assertEquals(0, test.getSeconds()); 1025 assertEquals(100, test.getMillis()); 1026 } 1027 1028 public void testSetPeriod_RD2() { 1029 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 1030 long length = 1031 (4L + (3L * 7L) + (2L * 30L) + 365L) * DateTimeConstants.MILLIS_PER_DAY + 1032 5L * DateTimeConstants.MILLIS_PER_HOUR + 1033 6L * DateTimeConstants.MILLIS_PER_MINUTE + 1034 7L * DateTimeConstants.MILLIS_PER_SECOND + 8L; 1035 test.setPeriod(new Duration(length)); 1036 // only time fields are precise 1037 assertEquals(0, test.getYears()); // (4 + (3 * 7) + (2 * 30) + 365) == 450 1038 assertEquals(0, test.getMonths()); 1039 assertEquals(0, test.getWeeks()); 1040 assertEquals(0, test.getDays()); 1041 assertEquals((450 * 24) + 5, test.getHours()); 1042 assertEquals(6, test.getMinutes()); 1043 assertEquals(7, test.getSeconds()); 1044 assertEquals(8, test.getMillis()); 1045 } 1046 1047 public void testSetPeriod_RD3() { 1048 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 1049 test.setPeriod((ReadableDuration) null); 1050 assertEquals(0, test.getYears()); 1051 assertEquals(0, test.getMonths()); 1052 assertEquals(0, test.getWeeks()); 1053 assertEquals(0, test.getDays()); 1054 assertEquals(0, test.getHours()); 1055 assertEquals(0, test.getMinutes()); 1056 assertEquals(0, test.getSeconds()); 1057 assertEquals(0, test.getMillis()); 1058 } 1059 1060 //----------------------------------------------------------------------- 1061 public void testAdd_8ints1() { 1062 MutablePeriod test = new MutablePeriod(100L); 1063 test.add(1, 2, 3, 4, 5, 6, 7, 8); 1064 assertEquals(1, test.getYears()); 1065 assertEquals(2, test.getMonths()); 1066 assertEquals(3, test.getWeeks()); 1067 assertEquals(4, test.getDays()); 1068 assertEquals(5, test.getHours()); 1069 assertEquals(6, test.getMinutes()); 1070 assertEquals(7, test.getSeconds()); 1071 assertEquals(108, test.getMillis()); 1072 } 1073 1074 public void testAdd_8ints2() { 1075 MutablePeriod test = new MutablePeriod(100L, PeriodType.yearMonthDayTime()); 1076 try { 1077 test.add(1, 2, 3, 4, 5, 6, 7, 8); 1078 fail(); 1079 } catch (IllegalArgumentException ex) {} 1080 assertEquals(0, test.getYears()); 1081 assertEquals(0, test.getMonths()); 1082 assertEquals(0, test.getWeeks()); 1083 assertEquals(0, test.getDays()); 1084 assertEquals(0, test.getHours()); 1085 assertEquals(0, test.getMinutes()); 1086 assertEquals(0, test.getSeconds()); 1087 assertEquals(100, test.getMillis()); 1088 } 1089 1090 //----------------------------------------------------------------------- 1091 public void testAdd_long1() { 1092 MutablePeriod test = new MutablePeriod(100L); 1093 test.add(100L); 1094 assertEquals(0, test.getYears()); 1095 assertEquals(0, test.getMonths()); 1096 assertEquals(0, test.getWeeks()); 1097 assertEquals(0, test.getDays()); 1098 assertEquals(0, test.getHours()); 1099 assertEquals(0, test.getMinutes()); 1100 assertEquals(0, test.getSeconds()); 1101 assertEquals(200, test.getMillis()); 1102 } 1103 1104 public void testAdd_long2() { 1105 MutablePeriod test = new MutablePeriod(100L, PeriodType.standard()); 1106 long ms = 1107 (4L + (3L * 7L) + (2L * 30L) + 365L) * DateTimeConstants.MILLIS_PER_DAY + 1108 5L * DateTimeConstants.MILLIS_PER_HOUR + 1109 6L * DateTimeConstants.MILLIS_PER_MINUTE + 1110 7L * DateTimeConstants.MILLIS_PER_SECOND + 8L; 1111 test.add(ms); 1112 // only time fields are precise 1113 assertEquals(0, test.getYears()); // (4 + (3 * 7) + (2 * 30) + 365) == 450 1114 assertEquals(0, test.getMonths()); 1115 assertEquals(0, test.getWeeks()); 1116 assertEquals(0, test.getDays()); 1117 assertEquals((450 * 24) + 5, test.getHours()); 1118 assertEquals(6, test.getMinutes()); 1119 assertEquals(7, test.getSeconds()); 1120 assertEquals(108, test.getMillis()); 1121 } 1122 1123 public void testAdd_long3() { 1124 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 1125 test.add(2100L); 1126 assertEquals(1, test.getYears()); 1127 assertEquals(2, test.getMonths()); 1128 assertEquals(3, test.getWeeks()); 1129 assertEquals(4, test.getDays()); 1130 assertEquals(5, test.getHours()); 1131 assertEquals(6, test.getMinutes()); 1132 assertEquals(9, test.getSeconds()); 1133 assertEquals(108, test.getMillis()); 1134 } 1135 1136 //----------------------------------------------------------------------- 1137 public void testAdd_long_Chronology1() { 1138 MutablePeriod test = new MutablePeriod(100L); 1139 test.add(100L, ISOChronology.getInstance()); 1140 assertEquals(0, test.getYears()); 1141 assertEquals(0, test.getMonths()); 1142 assertEquals(0, test.getWeeks()); 1143 assertEquals(0, test.getDays()); 1144 assertEquals(0, test.getHours()); 1145 assertEquals(0, test.getMinutes()); 1146 assertEquals(0, test.getSeconds()); 1147 assertEquals(200, test.getMillis()); 1148 } 1149 1150 public void testAdd_long_Chronology2() { 1151 MutablePeriod test = new MutablePeriod(100L, PeriodType.standard()); 1152 long ms = 1153 (4L + (3L * 7L) + (2L * 30L) + 365L) * DateTimeConstants.MILLIS_PER_DAY + 1154 5L * DateTimeConstants.MILLIS_PER_HOUR + 1155 6L * DateTimeConstants.MILLIS_PER_MINUTE + 1156 7L * DateTimeConstants.MILLIS_PER_SECOND + 8L; 1157 test.add(ms, ISOChronology.getInstance()); 1158 // only time fields are precise 1159 assertEquals(0, test.getYears()); // (4 + (3 * 7) + (2 * 30) + 365) == 450 days 1160 assertEquals(0, test.getMonths()); 1161 assertEquals(0, test.getWeeks()); 1162 assertEquals(0, test.getDays()); 1163 assertEquals((450 * 24) + 5, test.getHours()); 1164 assertEquals(6, test.getMinutes()); 1165 assertEquals(7, test.getSeconds()); 1166 assertEquals(108, test.getMillis()); 1167 } 1168 1169 public void testAdd_long_Chronology3() { 1170 MutablePeriod test = new MutablePeriod(100L, PeriodType.standard()); 1171 long ms = 1172 (4L + (3L * 7L) + (2L * 30L) + 365L) * DateTimeConstants.MILLIS_PER_DAY + 1173 5L * DateTimeConstants.MILLIS_PER_HOUR + 1174 6L * DateTimeConstants.MILLIS_PER_MINUTE + 1175 7L * DateTimeConstants.MILLIS_PER_SECOND + 8L; 1176 test.add(ms, ISOChronology.getInstanceUTC()); 1177 // UTC, so weeks and day also precise 1178 assertEquals(0, test.getYears()); // (4 + (3 * 7) + (2 * 30) + 365) == 450 days 1179 assertEquals(0, test.getMonths()); 1180 assertEquals(64, test.getWeeks()); 1181 assertEquals(2, test.getDays()); 1182 assertEquals(5, test.getHours()); 1183 assertEquals(6, test.getMinutes()); 1184 assertEquals(7, test.getSeconds()); 1185 assertEquals(108, test.getMillis()); 1186 } 1187 1188 //----------------------------------------------------------------------- 1189 public void testAdd_RD1() { 1190 MutablePeriod test = new MutablePeriod(100L); 1191 test.add(new Duration(100L)); 1192 assertEquals(0, test.getYears()); 1193 assertEquals(0, test.getMonths()); 1194 assertEquals(0, test.getWeeks()); 1195 assertEquals(0, test.getDays()); 1196 assertEquals(0, test.getHours()); 1197 assertEquals(0, test.getMinutes()); 1198 assertEquals(0, test.getSeconds()); 1199 assertEquals(200, test.getMillis()); 1200 } 1201 1202 public void testAdd_RD2() { 1203 MutablePeriod test = new MutablePeriod(100L, PeriodType.yearMonthDayTime()); 1204 long ms = 1205 (4L + (3L * 7L)) * DateTimeConstants.MILLIS_PER_DAY + 1206 5L * DateTimeConstants.MILLIS_PER_HOUR + 1207 6L * DateTimeConstants.MILLIS_PER_MINUTE + 1208 7L * DateTimeConstants.MILLIS_PER_SECOND + 8L; 1209 test.add(new Duration(ms)); 1210 assertEquals(0, test.getYears()); 1211 assertEquals(0, test.getMonths()); 1212 assertEquals(0, test.getWeeks()); 1213 assertEquals(0, test.getDays()); 1214 assertEquals((4 + (3 * 7)) * 24 + 5, test.getHours()); 1215 assertEquals(6, test.getMinutes()); 1216 assertEquals(7, test.getSeconds()); 1217 assertEquals(108, test.getMillis()); 1218 } 1219 1220 public void testAdd_RD3() { 1221 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 1222 test.add((ReadableDuration) null); 1223 assertEquals(1, test.getYears()); 1224 assertEquals(2, test.getMonths()); 1225 assertEquals(3, test.getWeeks()); 1226 assertEquals(4, test.getDays()); 1227 assertEquals(5, test.getHours()); 1228 assertEquals(6, test.getMinutes()); 1229 assertEquals(7, test.getSeconds()); 1230 assertEquals(8, test.getMillis()); 1231 } 1232 1233 //----------------------------------------------------------------------- 1234 public void testAdd_RP1() { 1235 MutablePeriod test = new MutablePeriod(100L); 1236 test.add(new Period(100L)); 1237 assertEquals(0, test.getYears()); 1238 assertEquals(0, test.getMonths()); 1239 assertEquals(0, test.getWeeks()); 1240 assertEquals(0, test.getDays()); 1241 assertEquals(0, test.getHours()); 1242 assertEquals(0, test.getMinutes()); 1243 assertEquals(0, test.getSeconds()); 1244 assertEquals(200, test.getMillis()); 1245 } 1246 1247 public void testAdd_RP2() { 1248 MutablePeriod test = new MutablePeriod(100L, PeriodType.standard()); // All type 1249 test.add(new Period(1, 2, 3, 4, 5, 6, 7, 0, PeriodType.standard().withMillisRemoved())); 1250 // add field value, ignore different types 1251 assertEquals(1, test.getYears()); 1252 assertEquals(2, test.getMonths()); 1253 assertEquals(3, test.getWeeks()); 1254 assertEquals(4, test.getDays()); 1255 assertEquals(5, test.getHours()); 1256 assertEquals(6, test.getMinutes()); 1257 assertEquals(7, test.getSeconds()); 1258 assertEquals(100, test.getMillis()); 1259 } 1260 1261 public void testAdd_RP3() { 1262 MutablePeriod test = new MutablePeriod(100L, PeriodType.standard()); 1263 test.add(new Period(0L)); 1264 assertEquals(0, test.getYears()); 1265 assertEquals(0, test.getMonths()); 1266 assertEquals(0, test.getWeeks()); 1267 assertEquals(0, test.getDays()); 1268 assertEquals(0, test.getHours()); 1269 assertEquals(0, test.getMinutes()); 1270 assertEquals(0, test.getSeconds()); 1271 assertEquals(100, test.getMillis()); 1272 } 1273 1274 public void testAdd_RP4() { 1275 MutablePeriod test = new MutablePeriod(1, 2, 0, 4, 5, 6, 7, 8, PeriodType.yearMonthDayTime()); 1276 try { 1277 test.add(new Period(1, 2, 3, 4, 5, 6, 7, 8)); // cannot set weeks 1278 fail(); 1279 } catch (IllegalArgumentException ex) {} 1280 assertEquals(1, test.getYears()); 1281 assertEquals(2, test.getMonths()); 1282 assertEquals(0, test.getWeeks()); 1283 assertEquals(4, test.getDays()); 1284 assertEquals(5, test.getHours()); 1285 assertEquals(6, test.getMinutes()); 1286 assertEquals(7, test.getSeconds()); 1287 assertEquals(8, test.getMillis()); 1288 } 1289 1290 public void testAdd_RP5() { 1291 MutablePeriod test = new MutablePeriod(1, 2, 0, 4, 5, 6, 7, 8, PeriodType.yearMonthDayTime()); 1292 test.add(new Period(1, 2, 0, 4, 5, 6, 7, 8)); // can set weeks as zero 1293 assertEquals(2, test.getYears()); 1294 assertEquals(4, test.getMonths()); 1295 assertEquals(0, test.getWeeks()); 1296 assertEquals(8, test.getDays()); 1297 assertEquals(10, test.getHours()); 1298 assertEquals(12, test.getMinutes()); 1299 assertEquals(14, test.getSeconds()); 1300 assertEquals(16, test.getMillis()); 1301 } 1302 1303 public void testAdd_RP6() { 1304 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 1305 test.add((ReadablePeriod) null); 1306 assertEquals(1, test.getYears()); 1307 assertEquals(2, test.getMonths()); 1308 assertEquals(3, test.getWeeks()); 1309 assertEquals(4, test.getDays()); 1310 assertEquals(5, test.getHours()); 1311 assertEquals(6, test.getMinutes()); 1312 assertEquals(7, test.getSeconds()); 1313 assertEquals(8, test.getMillis()); 1314 } 1315 1316 //----------------------------------------------------------------------- 1317 public void testAdd_RInterval1() { 1318 MutablePeriod test = new MutablePeriod(100L); 1319 test.add(new Interval(100L, 200L)); 1320 assertEquals(0, test.getYears()); 1321 assertEquals(0, test.getMonths()); 1322 assertEquals(0, test.getWeeks()); 1323 assertEquals(0, test.getDays()); 1324 assertEquals(0, test.getHours()); 1325 assertEquals(0, test.getMinutes()); 1326 assertEquals(0, test.getSeconds()); 1327 assertEquals(200, test.getMillis()); 1328 } 1329 1330 public void testAdd_RInterval2() { 1331 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); 1332 DateTime dt2 = new DateTime(2005, 12, 18, 0, 0, 0, 8); 1333 MutablePeriod test = new MutablePeriod(100L); // All type 1334 test.add(new Interval(dt1, dt2)); 1335 assertEquals(1, test.getYears()); // add field value from interval 1336 assertEquals(6, test.getMonths()); // add field value from interval 1337 assertEquals(1, test.getWeeks()); // add field value from interval 1338 assertEquals(2, test.getDays()); // add field value from interval 1339 assertEquals(0, test.getHours()); // time zone OK 1340 assertEquals(0, test.getMinutes()); 1341 assertEquals(0, test.getSeconds()); 1342 assertEquals(108, test.getMillis()); 1343 } 1344 1345 public void testAdd_RInterval3() { 1346 MutablePeriod test = new MutablePeriod(100L, PeriodType.yearMonthDayTime()); 1347 test.add(new Interval(0L, 0L)); 1348 assertEquals(0, test.getYears()); 1349 assertEquals(0, test.getMonths()); 1350 assertEquals(0, test.getWeeks()); 1351 assertEquals(0, test.getDays()); 1352 assertEquals(0, test.getHours()); 1353 assertEquals(0, test.getMinutes()); 1354 assertEquals(0, test.getSeconds()); 1355 assertEquals(100, test.getMillis()); 1356 } 1357 1358 public void testAdd_RInterval4() { 1359 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0); 1360 DateTime dt2 = new DateTime(2005, 7, 17, 0, 0, 0, 8); 1361 MutablePeriod test = new MutablePeriod(100L, PeriodType.yearMonthDayTime()); 1362 test.add(new Interval(dt1, dt2)); 1363 assertEquals(1, test.getYears()); 1364 assertEquals(1, test.getMonths()); 1365 assertEquals(0, test.getWeeks()); // no weeks 1366 assertEquals(8, test.getDays()); // week added to days 1367 assertEquals(0, test.getHours()); 1368 assertEquals(0, test.getMinutes()); 1369 assertEquals(0, test.getSeconds()); 1370 assertEquals(108, test.getMillis()); 1371 } 1372 1373 public void testAdd_RInterval5() { 1374 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 1375 test.add((ReadableInterval) null); 1376 assertEquals(1, test.getYears()); 1377 assertEquals(2, test.getMonths()); 1378 assertEquals(3, test.getWeeks()); 1379 assertEquals(4, test.getDays()); 1380 assertEquals(5, test.getHours()); 1381 assertEquals(6, test.getMinutes()); 1382 assertEquals(7, test.getSeconds()); 1383 assertEquals(8, test.getMillis()); 1384 } 1385 1386 //----------------------------------------------------------------------- 1387 public void testMergePeriod_RP1() { 1388 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 1389 test.mergePeriod(new MutablePeriod(0, 0, 0, 14, 15, 16, 17, 18, PeriodType.dayTime())); 1390 assertEquals(1, test.getYears()); 1391 assertEquals(2, test.getMonths()); 1392 assertEquals(3, test.getWeeks()); 1393 assertEquals(14, test.getDays()); 1394 assertEquals(15, test.getHours()); 1395 assertEquals(16, test.getMinutes()); 1396 assertEquals(17, test.getSeconds()); 1397 assertEquals(18, test.getMillis()); 1398 } 1399 1400 public void testMergePeriod_RP2() { 1401 MutablePeriod test = new MutablePeriod(100L, PeriodType.millis()); 1402 try { 1403 test.mergePeriod(new MutablePeriod(11, 12, 13, 14, 15, 16, 17, 18)); 1404 fail(); 1405 } catch (IllegalArgumentException ex) {} 1406 assertEquals(0, test.getYears()); 1407 assertEquals(0, test.getMonths()); 1408 assertEquals(0, test.getWeeks()); 1409 assertEquals(0, test.getDays()); 1410 assertEquals(0, test.getHours()); 1411 assertEquals(0, test.getMinutes()); 1412 assertEquals(0, test.getSeconds()); 1413 assertEquals(100, test.getMillis()); 1414 } 1415 1416 public void testMergePeriod_RP3() { 1417 MutablePeriod test = new MutablePeriod(100L, PeriodType.millis()); 1418 test.mergePeriod(new MutablePeriod(0, 0, 0, 0, 0, 0, 0, 18)); 1419 assertEquals(0, test.getYears()); 1420 assertEquals(0, test.getMonths()); 1421 assertEquals(0, test.getWeeks()); 1422 assertEquals(0, test.getDays()); 1423 assertEquals(0, test.getHours()); 1424 assertEquals(0, test.getMinutes()); 1425 assertEquals(0, test.getSeconds()); 1426 assertEquals(18, test.getMillis()); 1427 } 1428 1429 public void testMergePeriod_RP4() { 1430 MutablePeriod test = new MutablePeriod(0, 0, 0, 0, 5, 6, 7, 8); 1431 test.mergePeriod(new MutablePeriod(11, 12, 13, 14, 15, 16, 17, 18)); 1432 assertEquals(11, test.getYears()); 1433 assertEquals(12, test.getMonths()); 1434 assertEquals(13, test.getWeeks()); 1435 assertEquals(14, test.getDays()); 1436 assertEquals(15, test.getHours()); 1437 assertEquals(16, test.getMinutes()); 1438 assertEquals(17, test.getSeconds()); 1439 assertEquals(18, test.getMillis()); 1440 } 1441 1442 public void testMergePeriod_RP5() { 1443 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8); 1444 test.mergePeriod((ReadablePeriod) null); 1445 assertEquals(1, test.getYears()); 1446 assertEquals(2, test.getMonths()); 1447 assertEquals(3, test.getWeeks()); 1448 assertEquals(4, test.getDays()); 1449 assertEquals(5, test.getHours()); 1450 assertEquals(6, test.getMinutes()); 1451 assertEquals(7, test.getSeconds()); 1452 assertEquals(8, test.getMillis()); 1453 } 1454 1455 }