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.CopticChronology;
025 import org.joda.time.chrono.ISOChronology;
026
027 /**
028 * This class is a JUnit test for MutableDuration.
029 *
030 * @author Stephen Colebourne
031 */
032 public class TestMutablePeriod_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 PARIS = DateTimeZone.forID("Europe/Paris");
037 private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London");
038
039 long y2002days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
040 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 +
041 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
042 366 + 365;
043 long y2003days = 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
044 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 +
045 365 + 365 + 366 + 365 + 365 + 365 + 366 + 365 + 365 + 365 +
046 366 + 365 + 365;
047
048 // 2002-06-09
049 private long TEST_TIME_NOW =
050 (y2002days + 31L + 28L + 31L + 30L + 31L + 9L -1L) * DateTimeConstants.MILLIS_PER_DAY;
051
052 // 2002-04-05
053 private long TEST_TIME1 =
054 (y2002days + 31L + 28L + 31L + 5L -1L) * DateTimeConstants.MILLIS_PER_DAY
055 + 12L * DateTimeConstants.MILLIS_PER_HOUR
056 + 24L * DateTimeConstants.MILLIS_PER_MINUTE;
057
058 // 2003-05-06
059 private long TEST_TIME2 =
060 (y2003days + 31L + 28L + 31L + 30L + 6L -1L) * DateTimeConstants.MILLIS_PER_DAY
061 + 14L * DateTimeConstants.MILLIS_PER_HOUR
062 + 28L * DateTimeConstants.MILLIS_PER_MINUTE;
063
064 private DateTimeZone originalDateTimeZone = null;
065 private TimeZone originalTimeZone = null;
066 private Locale originalLocale = null;
067
068 public static void main(String[] args) {
069 junit.textui.TestRunner.run(suite());
070 }
071
072 public static TestSuite suite() {
073 return new TestSuite(TestMutablePeriod_Constructors.class);
074 }
075
076 public TestMutablePeriod_Constructors(String name) {
077 super(name);
078 }
079
080 protected void setUp() throws Exception {
081 DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW);
082 originalDateTimeZone = DateTimeZone.getDefault();
083 originalTimeZone = TimeZone.getDefault();
084 originalLocale = Locale.getDefault();
085 DateTimeZone.setDefault(LONDON);
086 TimeZone.setDefault(TimeZone.getTimeZone("Europe/London"));
087 Locale.setDefault(Locale.UK);
088 }
089
090 protected void tearDown() throws Exception {
091 DateTimeUtils.setCurrentMillisSystem();
092 DateTimeZone.setDefault(originalDateTimeZone);
093 TimeZone.setDefault(originalTimeZone);
094 Locale.setDefault(originalLocale);
095 originalDateTimeZone = null;
096 originalTimeZone = null;
097 originalLocale = null;
098 }
099
100 //-----------------------------------------------------------------------
101 public void testParse_noFormatter() throws Throwable {
102 assertEquals(new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 890), MutablePeriod.parse("P1Y2M3W4DT5H6M7.890S"));
103 }
104
105 //-----------------------------------------------------------------------
106 /**
107 * Test constructor ()
108 */
109 public void testConstructor1() throws Throwable {
110 MutablePeriod test = new MutablePeriod();
111 assertEquals(PeriodType.standard(), test.getPeriodType());
112 assertEquals(0, test.getYears());
113 assertEquals(0, test.getMonths());
114 assertEquals(0, test.getWeeks());
115 assertEquals(0, test.getDays());
116 assertEquals(0, test.getHours());
117 assertEquals(0, test.getMinutes());
118 assertEquals(0, test.getSeconds());
119 assertEquals(0, test.getMillis());
120 }
121
122 //-----------------------------------------------------------------------
123 /**
124 * Test constructor (PeriodType)
125 */
126 public void testConstructor_PeriodType1() throws Throwable {
127 MutablePeriod test = new MutablePeriod(PeriodType.yearMonthDayTime());
128 assertEquals(PeriodType.yearMonthDayTime(), test.getPeriodType());
129 assertEquals(0, test.getYears());
130 assertEquals(0, test.getMonths());
131 assertEquals(0, test.getWeeks());
132 assertEquals(0, test.getDays());
133 assertEquals(0, test.getHours());
134 assertEquals(0, test.getMinutes());
135 assertEquals(0, test.getSeconds());
136 assertEquals(0, test.getMillis());
137 }
138
139 public void testConstructor_PeriodType2() throws Throwable {
140 MutablePeriod test = new MutablePeriod((PeriodType) null);
141 assertEquals(PeriodType.standard(), test.getPeriodType());
142 assertEquals(0, test.getYears());
143 assertEquals(0, test.getMonths());
144 assertEquals(0, test.getWeeks());
145 assertEquals(0, test.getDays());
146 assertEquals(0, test.getHours());
147 assertEquals(0, test.getMinutes());
148 assertEquals(0, test.getSeconds());
149 assertEquals(0, test.getMillis());
150 }
151
152 //-----------------------------------------------------------------------
153 public void testConstructor_long1() throws Throwable {
154 long length = 4 * DateTimeConstants.MILLIS_PER_DAY +
155 5 * DateTimeConstants.MILLIS_PER_HOUR +
156 6 * DateTimeConstants.MILLIS_PER_MINUTE +
157 7 * DateTimeConstants.MILLIS_PER_SECOND + 8;
158 MutablePeriod test = new MutablePeriod(length);
159 assertEquals(PeriodType.standard(), test.getPeriodType());
160 assertEquals(0, test.getYears());
161 assertEquals(0, test.getMonths());
162 assertEquals(0, test.getWeeks());
163 assertEquals(0, test.getDays());
164 assertEquals((4 * 24) + 5, test.getHours());
165 assertEquals(6, test.getMinutes());
166 assertEquals(7, test.getSeconds());
167 assertEquals(8, test.getMillis());
168 }
169
170 public void testConstructor_long2() throws Throwable {
171 long length =
172 5 * DateTimeConstants.MILLIS_PER_HOUR +
173 6 * DateTimeConstants.MILLIS_PER_MINUTE +
174 7 * DateTimeConstants.MILLIS_PER_SECOND + 8;
175 MutablePeriod test = new MutablePeriod(length);
176 assertEquals(PeriodType.standard(), test.getPeriodType());
177 assertEquals(0, test.getYears());
178 assertEquals(0, test.getMonths());
179 assertEquals(0, test.getWeeks());
180 assertEquals(0, test.getDays());
181 assertEquals(5, test.getHours());
182 assertEquals(6, test.getMinutes());
183 assertEquals(7, test.getSeconds());
184 assertEquals(8, test.getMillis());
185 }
186
187 public void testConstructor_long3() throws Throwable {
188 long length =
189 (4L + (3L * 7L) + (2L * 30L) + 365L) * DateTimeConstants.MILLIS_PER_DAY +
190 5L * DateTimeConstants.MILLIS_PER_HOUR +
191 6L * DateTimeConstants.MILLIS_PER_MINUTE +
192 7L * DateTimeConstants.MILLIS_PER_SECOND + 8L;
193 MutablePeriod test = new MutablePeriod(length);
194 assertEquals(PeriodType.standard(), test.getPeriodType());
195 // only time fields are precise in AllType
196 assertEquals(0, test.getYears()); // (4 + (3 * 7) + (2 * 30) + 365) == 450
197 assertEquals(0, test.getMonths());
198 assertEquals(0, test.getWeeks());
199 assertEquals(0, test.getDays());
200 assertEquals((450 * 24) + 5, test.getHours());
201 assertEquals(6, test.getMinutes());
202 assertEquals(7, test.getSeconds());
203 assertEquals(8, test.getMillis());
204 }
205
206 //-----------------------------------------------------------------------
207 public void testConstructor_long_PeriodType1() throws Throwable {
208 long length = 4 * DateTimeConstants.MILLIS_PER_DAY +
209 5 * DateTimeConstants.MILLIS_PER_HOUR +
210 6 * DateTimeConstants.MILLIS_PER_MINUTE +
211 7 * DateTimeConstants.MILLIS_PER_SECOND + 8;
212 MutablePeriod test = new MutablePeriod(length, (PeriodType) null);
213 assertEquals(PeriodType.standard(), test.getPeriodType());
214 assertEquals(0, test.getYears());
215 assertEquals(0, test.getMonths());
216 assertEquals(0, test.getWeeks());
217 assertEquals(0, test.getDays());
218 assertEquals((4 * 24) + 5, test.getHours());
219 assertEquals(6, test.getMinutes());
220 assertEquals(7, test.getSeconds());
221 assertEquals(8, test.getMillis());
222 }
223
224 public void testConstructor_long_PeriodType2() throws Throwable {
225 long length = 4 * DateTimeConstants.MILLIS_PER_DAY +
226 5 * DateTimeConstants.MILLIS_PER_HOUR +
227 6 * DateTimeConstants.MILLIS_PER_MINUTE +
228 7 * DateTimeConstants.MILLIS_PER_SECOND + 8;
229 MutablePeriod test = new MutablePeriod(length, PeriodType.millis());
230 assertEquals(PeriodType.millis(), test.getPeriodType());
231 assertEquals(0, test.getYears());
232 assertEquals(0, test.getMonths());
233 assertEquals(0, test.getWeeks());
234 assertEquals(0, test.getDays());
235 assertEquals(0, test.getHours());
236 assertEquals(0, test.getMinutes());
237 assertEquals(0, test.getSeconds());
238 assertEquals(length, test.getMillis());
239 }
240
241 public void testConstructor_long_PeriodType3() throws Throwable {
242 long length = 4 * DateTimeConstants.MILLIS_PER_DAY +
243 5 * DateTimeConstants.MILLIS_PER_HOUR +
244 6 * DateTimeConstants.MILLIS_PER_MINUTE +
245 7 * DateTimeConstants.MILLIS_PER_SECOND + 8;
246 MutablePeriod test = new MutablePeriod(length, PeriodType.standard());
247 assertEquals(PeriodType.standard(), test.getPeriodType());
248 assertEquals(0, test.getYears());
249 assertEquals(0, test.getMonths());
250 assertEquals(0, test.getWeeks());
251 assertEquals(0, test.getDays());
252 assertEquals((4 * 24) + 5, test.getHours());
253 assertEquals(6, test.getMinutes());
254 assertEquals(7, test.getSeconds());
255 assertEquals(8, test.getMillis());
256 }
257
258 public void testConstructor_long_PeriodType4() throws Throwable {
259 long length =
260 5 * DateTimeConstants.MILLIS_PER_HOUR +
261 6 * DateTimeConstants.MILLIS_PER_MINUTE +
262 7 * DateTimeConstants.MILLIS_PER_SECOND + 8;
263 MutablePeriod test = new MutablePeriod(length, PeriodType.standard().withMillisRemoved());
264 assertEquals(PeriodType.standard().withMillisRemoved(), test.getPeriodType());
265 assertEquals(0, test.getYears());
266 assertEquals(0, test.getMonths());
267 assertEquals(0, test.getWeeks());
268 assertEquals(0, test.getDays());
269 assertEquals(5, test.getHours());
270 assertEquals(6, test.getMinutes());
271 assertEquals(7, test.getSeconds());
272 assertEquals(0, test.getMillis());
273 }
274
275 //-----------------------------------------------------------------------
276 public void testConstructor_long_Chronology1() throws Throwable {
277 long length = 4 * DateTimeConstants.MILLIS_PER_DAY +
278 5 * DateTimeConstants.MILLIS_PER_HOUR +
279 6 * DateTimeConstants.MILLIS_PER_MINUTE +
280 7 * DateTimeConstants.MILLIS_PER_SECOND + 8;
281 MutablePeriod test = new MutablePeriod(length, ISOChronology.getInstance());
282 assertEquals(PeriodType.standard(), test.getPeriodType());
283 assertEquals(0, test.getYears());
284 assertEquals(0, test.getMonths());
285 assertEquals(0, test.getWeeks());
286 assertEquals(0, test.getDays());
287 assertEquals((4 * 24) + 5, test.getHours());
288 assertEquals(6, test.getMinutes());
289 assertEquals(7, test.getSeconds());
290 assertEquals(8, test.getMillis());
291 }
292
293 public void testConstructor_long_Chronology2() throws Throwable {
294 long length = 4 * DateTimeConstants.MILLIS_PER_DAY +
295 5 * DateTimeConstants.MILLIS_PER_HOUR +
296 6 * DateTimeConstants.MILLIS_PER_MINUTE +
297 7 * DateTimeConstants.MILLIS_PER_SECOND + 8;
298 MutablePeriod test = new MutablePeriod(length, ISOChronology.getInstanceUTC());
299 assertEquals(PeriodType.standard(), test.getPeriodType());
300 assertEquals(0, test.getYears());
301 assertEquals(0, test.getMonths());
302 assertEquals(0, test.getWeeks());
303 assertEquals(4, test.getDays());
304 assertEquals(5, test.getHours());
305 assertEquals(6, test.getMinutes());
306 assertEquals(7, test.getSeconds());
307 assertEquals(8, test.getMillis());
308 }
309
310 public void testConstructor_long_Chronology3() throws Throwable {
311 long length = 4 * DateTimeConstants.MILLIS_PER_DAY +
312 5 * DateTimeConstants.MILLIS_PER_HOUR +
313 6 * DateTimeConstants.MILLIS_PER_MINUTE +
314 7 * DateTimeConstants.MILLIS_PER_SECOND + 8;
315 MutablePeriod test = new MutablePeriod(length, (Chronology) null);
316 assertEquals(PeriodType.standard(), test.getPeriodType());
317 assertEquals(0, test.getYears());
318 assertEquals(0, test.getMonths());
319 assertEquals(0, test.getWeeks());
320 assertEquals(0, test.getDays());
321 assertEquals((4 * 24) + 5, test.getHours());
322 assertEquals(6, test.getMinutes());
323 assertEquals(7, test.getSeconds());
324 assertEquals(8, test.getMillis());
325 }
326
327 //-----------------------------------------------------------------------
328 public void testConstructor_long_PeriodType_Chronology1() throws Throwable {
329 long length = 4 * DateTimeConstants.MILLIS_PER_DAY +
330 5 * DateTimeConstants.MILLIS_PER_HOUR +
331 6 * DateTimeConstants.MILLIS_PER_MINUTE +
332 7 * DateTimeConstants.MILLIS_PER_SECOND + 8;
333 MutablePeriod test = new MutablePeriod(length, PeriodType.time().withMillisRemoved(), ISOChronology.getInstance());
334 assertEquals(PeriodType.time().withMillisRemoved(), test.getPeriodType());
335 assertEquals(0, test.getYears());
336 assertEquals(0, test.getMonths());
337 assertEquals(0, test.getWeeks());
338 assertEquals(0, test.getDays());
339 assertEquals((4 * 24) + 5, test.getHours());
340 assertEquals(6, test.getMinutes());
341 assertEquals(7, test.getSeconds());
342 assertEquals(0, test.getMillis());
343 }
344
345 public void testConstructor_long_PeriodType_Chronology2() throws Throwable {
346 long length = 4 * DateTimeConstants.MILLIS_PER_DAY +
347 5 * DateTimeConstants.MILLIS_PER_HOUR +
348 6 * DateTimeConstants.MILLIS_PER_MINUTE +
349 7 * DateTimeConstants.MILLIS_PER_SECOND + 8;
350 MutablePeriod test = new MutablePeriod(length, PeriodType.standard(), ISOChronology.getInstanceUTC());
351 assertEquals(PeriodType.standard(), test.getPeriodType());
352 assertEquals(0, test.getYears());
353 assertEquals(0, test.getMonths());
354 assertEquals(0, test.getWeeks());
355 assertEquals(4, test.getDays());
356 assertEquals(5, test.getHours());
357 assertEquals(6, test.getMinutes());
358 assertEquals(7, test.getSeconds());
359 assertEquals(8, test.getMillis());
360 }
361
362 public void testConstructor_long_PeriodType_Chronology3() throws Throwable {
363 long length = 4 * DateTimeConstants.MILLIS_PER_DAY +
364 5 * DateTimeConstants.MILLIS_PER_HOUR +
365 6 * DateTimeConstants.MILLIS_PER_MINUTE +
366 7 * DateTimeConstants.MILLIS_PER_SECOND + 8;
367 MutablePeriod test = new MutablePeriod(length, PeriodType.standard(), (Chronology) null);
368 assertEquals(PeriodType.standard(), test.getPeriodType());
369 assertEquals(0, test.getYears());
370 assertEquals(0, test.getMonths());
371 assertEquals(0, test.getWeeks());
372 assertEquals(0, test.getDays());
373 assertEquals((4 * 24) + 5, test.getHours());
374 assertEquals(6, test.getMinutes());
375 assertEquals(7, test.getSeconds());
376 assertEquals(8, test.getMillis());
377 }
378
379 public void testConstructor_long_PeriodType_Chronology4() throws Throwable {
380 long length = 4 * DateTimeConstants.MILLIS_PER_DAY +
381 5 * DateTimeConstants.MILLIS_PER_HOUR +
382 6 * DateTimeConstants.MILLIS_PER_MINUTE +
383 7 * DateTimeConstants.MILLIS_PER_SECOND + 8;
384 MutablePeriod test = new MutablePeriod(length, (PeriodType) null, (Chronology) null);
385 assertEquals(PeriodType.standard(), test.getPeriodType());
386 assertEquals(0, test.getYears());
387 assertEquals(0, test.getMonths());
388 assertEquals(0, test.getWeeks());
389 assertEquals(0, test.getDays());
390 assertEquals((4 * 24) + 5, test.getHours());
391 assertEquals(6, test.getMinutes());
392 assertEquals(7, test.getSeconds());
393 assertEquals(8, test.getMillis());
394 }
395
396 //-----------------------------------------------------------------------
397 /**
398 * Test constructor (4ints)
399 */
400 public void testConstructor_4int1() throws Throwable {
401 MutablePeriod test = new MutablePeriod(5, 6, 7, 8);
402 assertEquals(PeriodType.standard(), test.getPeriodType());
403 assertEquals(0, test.getYears());
404 assertEquals(0, test.getMonths());
405 assertEquals(0, test.getWeeks());
406 assertEquals(0, test.getDays());
407 assertEquals(5, test.getHours());
408 assertEquals(6, test.getMinutes());
409 assertEquals(7, test.getSeconds());
410 assertEquals(8, test.getMillis());
411 }
412
413 //-----------------------------------------------------------------------
414 /**
415 * Test constructor (8ints)
416 */
417 public void testConstructor_8int1() throws Throwable {
418 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8);
419 assertEquals(PeriodType.standard(), test.getPeriodType());
420 assertEquals(1, test.getYears());
421 assertEquals(2, test.getMonths());
422 assertEquals(3, test.getWeeks());
423 assertEquals(4, test.getDays());
424 assertEquals(5, test.getHours());
425 assertEquals(6, test.getMinutes());
426 assertEquals(7, test.getSeconds());
427 assertEquals(8, test.getMillis());
428 }
429
430 //-----------------------------------------------------------------------
431 /**
432 * Test constructor (8ints)
433 */
434 public void testConstructor_8int__PeriodType1() throws Throwable {
435 MutablePeriod test = new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8, null);
436 assertEquals(PeriodType.standard(), test.getPeriodType());
437 assertEquals(1, test.getYears());
438 assertEquals(2, test.getMonths());
439 assertEquals(3, test.getWeeks());
440 assertEquals(4, test.getDays());
441 assertEquals(5, test.getHours());
442 assertEquals(6, test.getMinutes());
443 assertEquals(7, test.getSeconds());
444 assertEquals(8, test.getMillis());
445 }
446
447 public void testConstructor_8int__PeriodType2() throws Throwable {
448 MutablePeriod test = new MutablePeriod(0, 0, 0, 0, 5, 6, 7, 8, PeriodType.dayTime());
449 assertEquals(PeriodType.dayTime(), test.getPeriodType());
450 assertEquals(0, test.getYears());
451 assertEquals(0, test.getMonths());
452 assertEquals(0, test.getWeeks());
453 assertEquals(0, test.getDays());
454 assertEquals(5, test.getHours());
455 assertEquals(6, test.getMinutes());
456 assertEquals(7, test.getSeconds());
457 assertEquals(8, test.getMillis());
458 }
459
460 public void testConstructor_8int__PeriodType3() throws Throwable {
461 try {
462 new MutablePeriod(1, 2, 3, 4, 5, 6, 7, 8, PeriodType.dayTime());
463 fail();
464 } catch (IllegalArgumentException ex) {}
465 }
466
467 //-----------------------------------------------------------------------
468 public void testConstructor_long_long1() throws Throwable {
469 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0);
470 DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1);
471 MutablePeriod test = new MutablePeriod(dt1.getMillis(), dt2.getMillis());
472 assertEquals(PeriodType.standard(), test.getPeriodType());
473 assertEquals(1, test.getYears());
474 assertEquals(1, test.getMonths());
475 assertEquals(0, test.getWeeks());
476 assertEquals(1, test.getDays());
477 assertEquals(1, test.getHours());
478 assertEquals(1, test.getMinutes());
479 assertEquals(1, test.getSeconds());
480 assertEquals(1, test.getMillis());
481 }
482
483 public void testConstructor_long_long2() throws Throwable {
484 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0);
485 DateTime dt2 = new DateTime(2005, 7, 17, 1, 1, 1, 1);
486 MutablePeriod test = new MutablePeriod(dt1.getMillis(), dt2.getMillis());
487 assertEquals(PeriodType.standard(), test.getPeriodType());
488 assertEquals(1, test.getYears());
489 assertEquals(1, test.getMonths());
490 assertEquals(1, test.getWeeks());
491 assertEquals(1, test.getDays());
492 assertEquals(1, test.getHours());
493 assertEquals(1, test.getMinutes());
494 assertEquals(1, test.getSeconds());
495 assertEquals(1, test.getMillis());
496 }
497
498 //-----------------------------------------------------------------------
499 public void testConstructor_long_long_PeriodType1() throws Throwable {
500 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0);
501 DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1);
502 MutablePeriod test = new MutablePeriod(dt1.getMillis(), dt2.getMillis(), (PeriodType) null);
503 assertEquals(PeriodType.standard(), test.getPeriodType());
504 assertEquals(1, test.getYears());
505 assertEquals(1, test.getMonths());
506 assertEquals(0, test.getWeeks());
507 assertEquals(1, test.getDays());
508 assertEquals(1, test.getHours());
509 assertEquals(1, test.getMinutes());
510 assertEquals(1, test.getSeconds());
511 assertEquals(1, test.getMillis());
512 }
513
514 public void testConstructor_long_long_PeriodType2() throws Throwable {
515 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0);
516 DateTime dt2 = new DateTime(2004, 7, 10, 1, 1, 1, 1);
517 MutablePeriod test = new MutablePeriod(dt1.getMillis(), dt2.getMillis(), PeriodType.dayTime());
518 assertEquals(PeriodType.dayTime(), test.getPeriodType());
519 assertEquals(0, test.getYears());
520 assertEquals(0, test.getMonths());
521 assertEquals(0, test.getWeeks());
522 assertEquals(31, test.getDays());
523 assertEquals(1, test.getHours());
524 assertEquals(1, test.getMinutes());
525 assertEquals(1, test.getSeconds());
526 assertEquals(1, test.getMillis());
527 }
528
529 public void testConstructor_long_long_PeriodType3() throws Throwable {
530 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0);
531 DateTime dt2 = new DateTime(2004, 6, 9, 1, 1, 1, 1);
532 MutablePeriod test = new MutablePeriod(dt1.getMillis(), dt2.getMillis(), PeriodType.standard().withMillisRemoved());
533 assertEquals(PeriodType.standard().withMillisRemoved(), test.getPeriodType());
534 assertEquals(0, test.getYears());
535 assertEquals(0, test.getMonths());
536 assertEquals(0, test.getWeeks());
537 assertEquals(0, test.getDays());
538 assertEquals(1, test.getHours());
539 assertEquals(1, test.getMinutes());
540 assertEquals(1, test.getSeconds());
541 assertEquals(0, test.getMillis());
542 }
543
544 //-----------------------------------------------------------------------
545 public void testConstructor_long_long_Chronology1() throws Throwable {
546 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0, CopticChronology.getInstance());
547 DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1, CopticChronology.getInstance());
548 MutablePeriod test = new MutablePeriod(dt1.getMillis(), dt2.getMillis(), CopticChronology.getInstance());
549 assertEquals(PeriodType.standard(), test.getPeriodType());
550 assertEquals(1, test.getYears());
551 assertEquals(1, test.getMonths());
552 assertEquals(0, test.getWeeks());
553 assertEquals(1, test.getDays());
554 assertEquals(1, test.getHours());
555 assertEquals(1, test.getMinutes());
556 assertEquals(1, test.getSeconds());
557 assertEquals(1, test.getMillis());
558 }
559
560 public void testConstructor_long_long_Chronology2() throws Throwable {
561 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0);
562 DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1);
563 MutablePeriod test = new MutablePeriod(dt1.getMillis(), dt2.getMillis(), (Chronology) null);
564 assertEquals(PeriodType.standard(), test.getPeriodType());
565 assertEquals(1, test.getYears());
566 assertEquals(1, test.getMonths());
567 assertEquals(0, test.getWeeks());
568 assertEquals(1, test.getDays());
569 assertEquals(1, test.getHours());
570 assertEquals(1, test.getMinutes());
571 assertEquals(1, test.getSeconds());
572 assertEquals(1, test.getMillis());
573 }
574
575 //-----------------------------------------------------------------------
576 public void testConstructor_long_long_PeriodType_Chronology1() throws Throwable {
577 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0, CopticChronology.getInstance());
578 DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1, CopticChronology.getInstance());
579 MutablePeriod test = new MutablePeriod(dt1.getMillis(), dt2.getMillis(), (PeriodType) null, CopticChronology.getInstance());
580 assertEquals(PeriodType.standard(), test.getPeriodType());
581 assertEquals(1, test.getYears());
582 assertEquals(1, test.getMonths());
583 assertEquals(0, test.getWeeks());
584 assertEquals(1, test.getDays());
585 assertEquals(1, test.getHours());
586 assertEquals(1, test.getMinutes());
587 assertEquals(1, test.getSeconds());
588 assertEquals(1, test.getMillis());
589 }
590
591 public void testConstructor_long_long_PeriodType_Chronology2() throws Throwable {
592 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0);
593 DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1);
594 MutablePeriod test = new MutablePeriod(dt1.getMillis(), dt2.getMillis(), (PeriodType) null, null);
595 assertEquals(PeriodType.standard(), test.getPeriodType());
596 assertEquals(1, test.getYears());
597 assertEquals(1, test.getMonths());
598 assertEquals(0, test.getWeeks());
599 assertEquals(1, test.getDays());
600 assertEquals(1, test.getHours());
601 assertEquals(1, test.getMinutes());
602 assertEquals(1, test.getSeconds());
603 assertEquals(1, test.getMillis());
604 }
605
606 //-----------------------------------------------------------------------
607 public void testConstructor_RI_RI1() throws Throwable {
608 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0);
609 DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1);
610 MutablePeriod test = new MutablePeriod(dt1, dt2);
611 assertEquals(PeriodType.standard(), test.getPeriodType());
612 assertEquals(1, test.getYears());
613 assertEquals(1, test.getMonths());
614 assertEquals(0, test.getWeeks());
615 assertEquals(1, test.getDays());
616 assertEquals(1, test.getHours());
617 assertEquals(1, test.getMinutes());
618 assertEquals(1, test.getSeconds());
619 assertEquals(1, test.getMillis());
620 }
621
622 public void testConstructor_RI_RI2() throws Throwable {
623 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0);
624 DateTime dt2 = new DateTime(2005, 7, 17, 1, 1, 1, 1);
625 MutablePeriod test = new MutablePeriod(dt1, dt2);
626 assertEquals(PeriodType.standard(), test.getPeriodType());
627 assertEquals(1, test.getYears());
628 assertEquals(1, test.getMonths());
629 assertEquals(1, test.getWeeks());
630 assertEquals(1, test.getDays());
631 assertEquals(1, test.getHours());
632 assertEquals(1, test.getMinutes());
633 assertEquals(1, test.getSeconds());
634 assertEquals(1, test.getMillis());
635 }
636
637 public void testConstructor_RI_RI3() throws Throwable {
638 DateTime dt1 = null; // 2002-06-09T01:00+01:00
639 DateTime dt2 = new DateTime(2005, 7, 17, 1, 1, 1, 1);
640 MutablePeriod test = new MutablePeriod(dt1, dt2);
641 assertEquals(PeriodType.standard(), test.getPeriodType());
642 assertEquals(3, test.getYears());
643 assertEquals(1, test.getMonths());
644 assertEquals(1, test.getWeeks());
645 assertEquals(1, test.getDays());
646 assertEquals(0, test.getHours());
647 assertEquals(1, test.getMinutes());
648 assertEquals(1, test.getSeconds());
649 assertEquals(1, test.getMillis());
650 }
651
652 public void testConstructor_RI_RI4() throws Throwable {
653 DateTime dt1 = new DateTime(2005, 7, 17, 1, 1, 1, 1);
654 DateTime dt2 = null; // 2002-06-09T01:00+01:00
655 MutablePeriod test = new MutablePeriod(dt1, dt2);
656 assertEquals(PeriodType.standard(), test.getPeriodType());
657 assertEquals(-3, test.getYears());
658 assertEquals(-1, test.getMonths());
659 assertEquals(-1, test.getWeeks());
660 assertEquals(-1, test.getDays());
661 assertEquals(0, test.getHours());
662 assertEquals(-1, test.getMinutes());
663 assertEquals(-1, test.getSeconds());
664 assertEquals(-1, test.getMillis());
665 }
666
667 public void testConstructor_RI_RI5() throws Throwable {
668 DateTime dt1 = null; // 2002-06-09T01:00+01:00
669 DateTime dt2 = null; // 2002-06-09T01:00+01:00
670 MutablePeriod test = new MutablePeriod(dt1, dt2);
671 assertEquals(PeriodType.standard(), test.getPeriodType());
672 assertEquals(0, test.getYears());
673 assertEquals(0, test.getMonths());
674 assertEquals(0, test.getWeeks());
675 assertEquals(0, test.getDays());
676 assertEquals(0, test.getHours());
677 assertEquals(0, test.getMinutes());
678 assertEquals(0, test.getSeconds());
679 assertEquals(0, test.getMillis());
680 }
681
682 //-----------------------------------------------------------------------
683 public void testConstructor_RI_RI_PeriodType1() throws Throwable {
684 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0);
685 DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1);
686 MutablePeriod test = new MutablePeriod(dt1, dt2, null);
687 assertEquals(PeriodType.standard(), test.getPeriodType());
688 assertEquals(1, test.getYears());
689 assertEquals(1, test.getMonths());
690 assertEquals(0, test.getWeeks());
691 assertEquals(1, test.getDays());
692 assertEquals(1, test.getHours());
693 assertEquals(1, test.getMinutes());
694 assertEquals(1, test.getSeconds());
695 assertEquals(1, test.getMillis());
696 }
697
698 public void testConstructor_RI_RI_PeriodType2() throws Throwable {
699 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0);
700 DateTime dt2 = new DateTime(2004, 7, 10, 1, 1, 1, 1);
701 MutablePeriod test = new MutablePeriod(dt1, dt2, PeriodType.dayTime());
702 assertEquals(PeriodType.dayTime(), test.getPeriodType());
703 assertEquals(0, test.getYears());
704 assertEquals(0, test.getMonths());
705 assertEquals(0, test.getWeeks());
706 assertEquals(31, test.getDays());
707 assertEquals(1, test.getHours());
708 assertEquals(1, test.getMinutes());
709 assertEquals(1, test.getSeconds());
710 assertEquals(1, test.getMillis());
711 }
712
713 public void testConstructor_RI_RI_PeriodType3() throws Throwable {
714 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0);
715 DateTime dt2 = new DateTime(2004, 6, 9, 1, 1, 1, 1);
716 MutablePeriod test = new MutablePeriod(dt1, dt2, PeriodType.standard().withMillisRemoved());
717 assertEquals(PeriodType.standard().withMillisRemoved(), test.getPeriodType());
718 assertEquals(0, test.getYears());
719 assertEquals(0, test.getMonths());
720 assertEquals(0, test.getWeeks());
721 assertEquals(0, test.getDays());
722 assertEquals(1, test.getHours());
723 assertEquals(1, test.getMinutes());
724 assertEquals(1, test.getSeconds());
725 assertEquals(0, test.getMillis());
726 }
727
728 public void testConstructor_RI_RI_PeriodType4() throws Throwable {
729 DateTime dt1 = null; // 2002-06-09T01:00+01:00
730 DateTime dt2 = new DateTime(2005, 7, 17, 1, 1, 1, 1);
731 MutablePeriod test = new MutablePeriod(dt1, dt2, PeriodType.standard());
732 assertEquals(PeriodType.standard(), test.getPeriodType());
733 assertEquals(3, test.getYears());
734 assertEquals(1, test.getMonths());
735 assertEquals(1, test.getWeeks());
736 assertEquals(1, test.getDays());
737 assertEquals(0, test.getHours());
738 assertEquals(1, test.getMinutes());
739 assertEquals(1, test.getSeconds());
740 assertEquals(1, test.getMillis());
741 }
742
743 public void testConstructor_RI_RI_PeriodType5() throws Throwable {
744 DateTime dt1 = null; // 2002-06-09T01:00+01:00
745 DateTime dt2 = null; // 2002-06-09T01:00+01:00
746 MutablePeriod test = new MutablePeriod(dt1, dt2, PeriodType.standard());
747 assertEquals(PeriodType.standard(), test.getPeriodType());
748 assertEquals(0, test.getYears());
749 assertEquals(0, test.getMonths());
750 assertEquals(0, test.getWeeks());
751 assertEquals(0, test.getDays());
752 assertEquals(0, test.getHours());
753 assertEquals(0, test.getMinutes());
754 assertEquals(0, test.getSeconds());
755 assertEquals(0, test.getMillis());
756 }
757
758 //-----------------------------------------------------------------------
759 public void testConstructor_RI_RD1() throws Throwable {
760 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0);
761 DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1);
762 Duration dur = new Interval(dt1, dt2).toDuration();
763 MutablePeriod test = new MutablePeriod(dt1, dur);
764 assertEquals(PeriodType.standard(), test.getPeriodType());
765 assertEquals(1, test.getYears());
766 assertEquals(1, test.getMonths());
767 assertEquals(0, test.getWeeks());
768 assertEquals(1, test.getDays());
769 assertEquals(1, test.getHours());
770 assertEquals(1, test.getMinutes());
771 assertEquals(1, test.getSeconds());
772 assertEquals(1, test.getMillis());
773 }
774
775 public void testConstructor_RI_RD2() throws Throwable {
776 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0);
777 Duration dur = null;
778 MutablePeriod test = new MutablePeriod(dt1, dur);
779 assertEquals(PeriodType.standard(), test.getPeriodType());
780 assertEquals(0, test.getYears());
781 assertEquals(0, test.getMonths());
782 assertEquals(0, test.getWeeks());
783 assertEquals(0, test.getDays());
784 assertEquals(0, test.getHours());
785 assertEquals(0, test.getMinutes());
786 assertEquals(0, test.getSeconds());
787 assertEquals(0, test.getMillis());
788 }
789
790 //-----------------------------------------------------------------------
791 public void testConstructor_RI_RD_PeriodType1() throws Throwable {
792 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0);
793 DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1);
794 Duration dur = new Interval(dt1, dt2).toDuration();
795 MutablePeriod test = new MutablePeriod(dt1, dur, PeriodType.yearDayTime());
796 assertEquals(PeriodType.yearDayTime(), test.getPeriodType());
797 assertEquals(1, test.getYears());
798 assertEquals(0, test.getMonths());
799 assertEquals(0, test.getWeeks());
800 assertEquals(31, test.getDays());
801 assertEquals(1, test.getHours());
802 assertEquals(1, test.getMinutes());
803 assertEquals(1, test.getSeconds());
804 assertEquals(1, test.getMillis());
805 }
806
807 public void testConstructor_RI_RD_PeriodType2() throws Throwable {
808 DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0);
809 Duration dur = null;
810 MutablePeriod test = new MutablePeriod(dt1, dur, (PeriodType) null);
811 assertEquals(PeriodType.standard(), test.getPeriodType());
812 assertEquals(0, test.getYears());
813 assertEquals(0, test.getMonths());
814 assertEquals(0, test.getWeeks());
815 assertEquals(0, test.getDays());
816 assertEquals(0, test.getHours());
817 assertEquals(0, test.getMinutes());
818 assertEquals(0, test.getSeconds());
819 assertEquals(0, test.getMillis());
820 }
821
822 //-----------------------------------------------------------------------
823 /**
824 * Test constructor (Object)
825 */
826 public void testConstructor_Object1() throws Throwable {
827 MutablePeriod test = new MutablePeriod("P1Y2M3D");
828 assertEquals(PeriodType.standard(), test.getPeriodType());
829 assertEquals(1, test.getYears());
830 assertEquals(2, test.getMonths());
831 assertEquals(0, test.getWeeks());
832 assertEquals(3, test.getDays());
833 assertEquals(0, test.getHours());
834 assertEquals(0, test.getMinutes());
835 assertEquals(0, test.getSeconds());
836 assertEquals(0, test.getMillis());
837 }
838
839 public void testConstructor_Object2() throws Throwable {
840 MutablePeriod test = new MutablePeriod((Object) null);
841 assertEquals(PeriodType.standard(), test.getPeriodType());
842 assertEquals(0, test.getYears());
843 assertEquals(0, test.getMonths());
844 assertEquals(0, test.getWeeks());
845 assertEquals(0, test.getDays());
846 assertEquals(0, test.getHours());
847 assertEquals(0, test.getMinutes());
848 assertEquals(0, test.getSeconds());
849 assertEquals(0, test.getMillis());
850 }
851
852 public void testConstructor_Object3() throws Throwable {
853 MutablePeriod test = new MutablePeriod(new Period(0, 0, 0, 0, 1, 2, 3, 4, PeriodType.dayTime()));
854 assertEquals(PeriodType.dayTime(), test.getPeriodType());
855 assertEquals(0, test.getYears());
856 assertEquals(0, test.getMonths());
857 assertEquals(0, test.getWeeks());
858 assertEquals(0, test.getDays());
859 assertEquals(1, test.getHours());
860 assertEquals(2, test.getMinutes());
861 assertEquals(3, test.getSeconds());
862 assertEquals(4, test.getMillis());
863 }
864
865 public void testConstructor_Object4() throws Throwable {
866 Period base = new Period(1, 1, 0, 1, 1, 1, 1, 1, PeriodType.standard());
867 MutablePeriod test = new MutablePeriod(base);
868 assertEquals(PeriodType.standard(), test.getPeriodType());
869 assertEquals(1, test.getYears());
870 assertEquals(1, test.getMonths());
871 assertEquals(0, test.getWeeks());
872 assertEquals(1, test.getDays());
873 assertEquals(1, test.getHours());
874 assertEquals(1, test.getMinutes());
875 assertEquals(1, test.getSeconds());
876 assertEquals(1, test.getMillis());
877 }
878
879 //-----------------------------------------------------------------------
880 /**
881 * Test constructor (Object,PeriodType)
882 */
883 public void testConstructor_Object_PeriodType1() throws Throwable {
884 MutablePeriod test = new MutablePeriod("P1Y2M3D", PeriodType.yearMonthDayTime());
885 assertEquals(PeriodType.yearMonthDayTime(), test.getPeriodType());
886 assertEquals(1, test.getYears());
887 assertEquals(2, test.getMonths());
888 assertEquals(0, test.getWeeks());
889 assertEquals(3, test.getDays());
890 assertEquals(0, test.getHours());
891 assertEquals(0, test.getMinutes());
892 assertEquals(0, test.getSeconds());
893 assertEquals(0, test.getMillis());
894 }
895
896 public void testConstructor_Object_PeriodType2() throws Throwable {
897 MutablePeriod test = new MutablePeriod((Object) null, PeriodType.yearMonthDayTime());
898 assertEquals(PeriodType.yearMonthDayTime(), test.getPeriodType());
899 assertEquals(0, test.getYears());
900 assertEquals(0, test.getMonths());
901 assertEquals(0, test.getWeeks());
902 assertEquals(0, test.getDays());
903 assertEquals(0, test.getHours());
904 assertEquals(0, test.getMinutes());
905 assertEquals(0, test.getSeconds());
906 assertEquals(0, test.getMillis());
907 }
908
909 public void testConstructor_Object_PeriodType3() throws Throwable {
910 MutablePeriod test = new MutablePeriod(new Period(0, 0, 0, 0, 1, 2, 3, 4, PeriodType.dayTime()), PeriodType.yearMonthDayTime());
911 assertEquals(PeriodType.yearMonthDayTime(), test.getPeriodType());
912 assertEquals(0, test.getYears());
913 assertEquals(0, test.getMonths());
914 assertEquals(0, test.getWeeks());
915 assertEquals(0, test.getDays());
916 assertEquals(1, test.getHours());
917 assertEquals(2, test.getMinutes());
918 assertEquals(3, test.getSeconds());
919 assertEquals(4, test.getMillis());
920 }
921
922 public void testConstructor_Object_PeriodType4() throws Throwable {
923 MutablePeriod test = new MutablePeriod(new Period(0, 0, 0, 0, 1, 2, 3, 4, PeriodType.dayTime()), (PeriodType) null);
924 assertEquals(PeriodType.dayTime(), test.getPeriodType());
925 assertEquals(0, test.getYears());
926 assertEquals(0, test.getMonths());
927 assertEquals(0, test.getWeeks());
928 assertEquals(0, test.getDays());
929 assertEquals(1, test.getHours());
930 assertEquals(2, test.getMinutes());
931 assertEquals(3, test.getSeconds());
932 assertEquals(4, test.getMillis());
933 }
934
935 //-----------------------------------------------------------------------
936 public void testConstructor_Object_Chronology1() throws Throwable {
937 long length =
938 (4L + (3L * 7L) + (2L * 30L) + 365L) * DateTimeConstants.MILLIS_PER_DAY +
939 5L * DateTimeConstants.MILLIS_PER_HOUR +
940 6L * DateTimeConstants.MILLIS_PER_MINUTE +
941 7L * DateTimeConstants.MILLIS_PER_SECOND + 8L;
942 MutablePeriod test = new MutablePeriod(new Duration(length), ISOChronology.getInstance());
943 assertEquals(PeriodType.standard(), test.getPeriodType());
944 assertEquals(0, test.getYears()); // (4 + (3 * 7) + (2 * 30) + 365) == 450
945 assertEquals(0, test.getMonths());
946 assertEquals(0, test.getWeeks());
947 assertEquals(0, test.getDays());
948 assertEquals((450 * 24) + 5, test.getHours());
949 assertEquals(6, test.getMinutes());
950 assertEquals(7, test.getSeconds());
951 assertEquals(8, test.getMillis());
952 }
953
954 public void testConstructor_Object_Chronology2() throws Throwable {
955 long length =
956 (4L + (3L * 7L) + (2L * 30L) + 365L) * DateTimeConstants.MILLIS_PER_DAY +
957 5L * DateTimeConstants.MILLIS_PER_HOUR +
958 6L * DateTimeConstants.MILLIS_PER_MINUTE +
959 7L * DateTimeConstants.MILLIS_PER_SECOND + 8L;
960 MutablePeriod test = new MutablePeriod(new Duration(length), ISOChronology.getInstanceUTC());
961 assertEquals(PeriodType.standard(), test.getPeriodType());
962 assertEquals(0, test.getYears()); // (4 + (3 * 7) + (2 * 30) + 365) == 450
963 assertEquals(0, test.getMonths());
964 assertEquals(64, test.getWeeks());
965 assertEquals(2, test.getDays());
966 assertEquals(5, test.getHours());
967 assertEquals(6, test.getMinutes());
968 assertEquals(7, test.getSeconds());
969 assertEquals(8, test.getMillis());
970 }
971
972 }