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