Java > Open Source Codes > org > joda > time > TestPeriod_Constructors


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

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags