View Javadoc

1   /*
2    *  Copyright 2001-2006 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.Calendar;
19  import java.util.Date;
20  import java.util.GregorianCalendar;
21  
22  import junit.framework.TestCase;
23  import junit.framework.TestSuite;
24  
25  import org.joda.time.chrono.BuddhistChronology;
26  import org.joda.time.chrono.CopticChronology;
27  import org.joda.time.chrono.GregorianChronology;
28  import org.joda.time.chrono.ISOChronology;
29  
30  /**
31   * This class is a Junit unit test for YearMonthDay.
32   *
33   * @author Stephen Colebourne
34   */
35  public class TestYearMonthDay_Constructors extends TestCase {
36  
37      private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris");
38      private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London");
39      private static final Chronology COPTIC_UTC = CopticChronology.getInstanceUTC();
40      private static final Chronology ISO_UTC = ISOChronology.getInstanceUTC();
41      private static final Chronology BUDDHIST_UTC = BuddhistChronology.getInstanceUTC();
42      private static final Chronology GREGORIAN_UTC = GregorianChronology.getInstanceUTC();
43      private static final Chronology GREGORIAN_PARIS = GregorianChronology.getInstance(PARIS);
44      
45      private long TEST_TIME_NOW =
46              (31L + 28L + 31L + 30L + 31L + 9L -1L) * DateTimeConstants.MILLIS_PER_DAY;
47              
48      private long TEST_TIME1 =
49          (31L + 28L + 31L + 6L -1L) * DateTimeConstants.MILLIS_PER_DAY
50          + 12L * DateTimeConstants.MILLIS_PER_HOUR
51          + 24L * DateTimeConstants.MILLIS_PER_MINUTE;
52          
53      private long TEST_TIME2 =
54          (365L + 31L + 28L + 31L + 30L + 7L -1L) * DateTimeConstants.MILLIS_PER_DAY
55          + 14L * DateTimeConstants.MILLIS_PER_HOUR
56          + 28L * DateTimeConstants.MILLIS_PER_MINUTE;
57          
58      private DateTimeZone zone = null;
59  
60      public static void main(String[] args) {
61          junit.textui.TestRunner.run(suite());
62      }
63  
64      public static TestSuite suite() {
65          return new TestSuite(TestYearMonthDay_Constructors.class);
66      }
67  
68      public TestYearMonthDay_Constructors(String name) {
69          super(name);
70      }
71  
72      protected void setUp() throws Exception {
73          DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW);
74          zone = DateTimeZone.getDefault();
75          DateTimeZone.setDefault(LONDON);
76      }
77  
78      protected void tearDown() throws Exception {
79          DateTimeUtils.setCurrentMillisSystem();
80          DateTimeZone.setDefault(zone);
81          zone = null;
82      }
83  
84      //-----------------------------------------------------------------------
85      public void testFactory_FromCalendarFields() throws Exception {
86          GregorianCalendar cal = new GregorianCalendar(1970, 1, 3, 4, 5, 6);
87          cal.set(Calendar.MILLISECOND, 7);
88          YearMonthDay expected = new YearMonthDay(1970, 2, 3);
89          assertEquals(expected, YearMonthDay.fromCalendarFields(cal));
90          try {
91              YearMonthDay.fromCalendarFields(null);
92              fail();
93          } catch (IllegalArgumentException ex) {}
94      }
95  
96      //-----------------------------------------------------------------------
97      public void testFactory_FromDateFields() throws Exception {
98          GregorianCalendar cal = new GregorianCalendar(1970, 1, 3, 4, 5, 6);
99          cal.set(Calendar.MILLISECOND, 7);
100         YearMonthDay expected = new YearMonthDay(1970, 2, 3);
101         assertEquals(expected, YearMonthDay.fromDateFields(cal.getTime()));
102         try {
103             YearMonthDay.fromDateFields(null);
104             fail();
105         } catch (IllegalArgumentException ex) {}
106     }
107 
108     //-----------------------------------------------------------------------
109     /**
110      * Test constructor ()
111      */
112     public void testConstructor() throws Throwable {
113         YearMonthDay test = new YearMonthDay();
114         assertEquals(ISO_UTC, test.getChronology());
115         assertEquals(1970, test.getYear());
116         assertEquals(6, test.getMonthOfYear());
117         assertEquals(9, test.getDayOfMonth());
118     }
119 
120     /**
121      * Test constructor (DateTimeZone)
122      */
123     public void testConstructor_DateTimeZone() throws Throwable {
124         DateTime dt = new DateTime(2005, 6, 8, 23, 59, 0, 0, LONDON);
125         DateTimeUtils.setCurrentMillisFixed(dt.getMillis());
126         // 23:59 in London is 00:59 the following day in Paris
127         
128         YearMonthDay test = new YearMonthDay(LONDON);
129         assertEquals(ISO_UTC, test.getChronology());
130         assertEquals(2005, test.getYear());
131         assertEquals(6, test.getMonthOfYear());
132         assertEquals(8, test.getDayOfMonth());
133         
134         test = new YearMonthDay(PARIS);
135         assertEquals(ISO_UTC, test.getChronology());
136         assertEquals(2005, test.getYear());
137         assertEquals(6, test.getMonthOfYear());
138         assertEquals(9, test.getDayOfMonth());
139     }
140 
141     /**
142      * Test constructor (DateTimeZone=null)
143      */
144     public void testConstructor_nullDateTimeZone() throws Throwable {
145         DateTime dt = new DateTime(2005, 6, 8, 23, 59, 0, 0, LONDON);
146         DateTimeUtils.setCurrentMillisFixed(dt.getMillis());
147         // 23:59 in London is 00:59 the following day in Paris
148         
149         YearMonthDay test = new YearMonthDay((DateTimeZone) null);
150         assertEquals(ISO_UTC, test.getChronology());
151         assertEquals(2005, test.getYear());
152         assertEquals(6, test.getMonthOfYear());
153         assertEquals(8, test.getDayOfMonth());
154     }
155 
156     /**
157      * Test constructor (Chronology)
158      */
159     public void testConstructor_Chronology() throws Throwable {
160         YearMonthDay test = new YearMonthDay(GREGORIAN_PARIS);
161         assertEquals(GREGORIAN_UTC, test.getChronology());
162         assertEquals(1970, test.getYear());
163         assertEquals(6, test.getMonthOfYear());
164         assertEquals(9, test.getDayOfMonth());
165     }
166 
167     /**
168      * Test constructor (Chronology=null)
169      */
170     public void testConstructor_nullChronology() throws Throwable {
171         YearMonthDay test = new YearMonthDay((Chronology) null);
172         assertEquals(ISO_UTC, test.getChronology());
173         assertEquals(1970, test.getYear());
174         assertEquals(6, test.getMonthOfYear());
175         assertEquals(9, test.getDayOfMonth());
176     }
177 
178     //-----------------------------------------------------------------------
179     /**
180      * Test constructor (long)
181      */
182     public void testConstructor_long1() throws Throwable {
183         YearMonthDay test = new YearMonthDay(TEST_TIME1);
184         assertEquals(ISO_UTC, test.getChronology());
185         assertEquals(1970, test.getYear());
186         assertEquals(4, test.getMonthOfYear());
187         assertEquals(6, test.getDayOfMonth());
188     }
189 
190     /**
191      * Test constructor (long)
192      */
193     public void testConstructor_long2() throws Throwable {
194         YearMonthDay test = new YearMonthDay(TEST_TIME2);
195         assertEquals(ISO_UTC, test.getChronology());
196         assertEquals(1971, test.getYear());
197         assertEquals(5, test.getMonthOfYear());
198         assertEquals(7, test.getDayOfMonth());
199     }
200 
201     /**
202      * Test constructor (long, Chronology)
203      */
204     public void testConstructor_long1_Chronology() throws Throwable {
205         YearMonthDay test = new YearMonthDay(TEST_TIME1, GREGORIAN_PARIS);
206         assertEquals(GREGORIAN_UTC, test.getChronology());
207         assertEquals(1970, test.getYear());
208         assertEquals(4, test.getMonthOfYear());
209         assertEquals(6, test.getDayOfMonth());
210     }
211 
212     /**
213      * Test constructor (long, Chronology)
214      */
215     public void testConstructor_long2_Chronology() throws Throwable {
216         YearMonthDay test = new YearMonthDay(TEST_TIME2, GREGORIAN_PARIS);
217         assertEquals(GREGORIAN_UTC, test.getChronology());
218         assertEquals(1971, test.getYear());
219         assertEquals(5, test.getMonthOfYear());
220         assertEquals(7, test.getDayOfMonth());
221     }
222 
223     /**
224      * Test constructor (long, Chronology=null)
225      */
226     public void testConstructor_long_nullChronology() throws Throwable {
227         YearMonthDay test = new YearMonthDay(TEST_TIME1, null);
228         assertEquals(ISO_UTC, test.getChronology());
229         assertEquals(1970, test.getYear());
230         assertEquals(4, test.getMonthOfYear());
231         assertEquals(6, test.getDayOfMonth());
232     }
233 
234     //-----------------------------------------------------------------------
235     public void testConstructor_Object() throws Throwable {
236         Date date = new Date(TEST_TIME1);
237         YearMonthDay test = new YearMonthDay(date);
238         assertEquals(ISO_UTC, test.getChronology());
239         assertEquals(1970, test.getYear());
240         assertEquals(4, test.getMonthOfYear());
241         assertEquals(6, test.getDayOfMonth());
242     }
243 
244     public void testConstructor_nullObject() throws Throwable {
245         YearMonthDay test = new YearMonthDay((Object) null);
246         assertEquals(ISO_UTC, test.getChronology());
247         assertEquals(1970, test.getYear());
248         assertEquals(6, test.getMonthOfYear());
249         assertEquals(9, test.getDayOfMonth());
250     }
251 
252     public void testConstructor_ObjectString1() throws Throwable {
253         YearMonthDay test = new YearMonthDay("1972-12-03");
254         assertEquals(ISO_UTC, test.getChronology());
255         assertEquals(1972, test.getYear());
256         assertEquals(12, test.getMonthOfYear());
257         assertEquals(3, test.getDayOfMonth());
258     }
259 
260     public void testConstructor_ObjectString2() throws Throwable {
261         YearMonthDay test = new YearMonthDay("1972-12-03T+14:00");
262         assertEquals(ISO_UTC, test.getChronology());
263         assertEquals(1972, test.getYear());
264         assertEquals(12, test.getMonthOfYear());
265         assertEquals(2, test.getDayOfMonth());  // timezone
266     }
267 
268     public void testConstructor_ObjectString3() throws Throwable {
269         YearMonthDay test = new YearMonthDay("1972-12-03T10:20:30.040");
270         assertEquals(ISO_UTC, test.getChronology());
271         assertEquals(1972, test.getYear());
272         assertEquals(12, test.getMonthOfYear());
273         assertEquals(3, test.getDayOfMonth());
274     }
275 
276     public void testConstructor_ObjectString4() throws Throwable {
277         YearMonthDay test = new YearMonthDay("1972-12-03T10:20:30.040+14:00");
278         assertEquals(ISO_UTC, test.getChronology());
279         assertEquals(1972, test.getYear());
280         assertEquals(12, test.getMonthOfYear());
281         assertEquals(2, test.getDayOfMonth());  // timezone
282     }
283 
284     public void testConstructor_ObjectString5() throws Throwable {
285         YearMonthDay test = new YearMonthDay("10");
286         assertEquals(ISO_UTC, test.getChronology());
287         assertEquals(10, test.getYear());
288         assertEquals(1, test.getMonthOfYear());
289         assertEquals(1, test.getDayOfMonth());
290     }
291 
292     public void testConstructor_ObjectStringEx1() throws Throwable {
293         try {
294             new YearMonthDay("T10:20:30.040");
295             fail();
296         } catch (IllegalArgumentException ex) {
297             // expected
298         }
299     }
300 
301     public void testConstructor_ObjectStringEx2() throws Throwable {
302         try {
303             new YearMonthDay("T10:20:30.040+14:00");
304             fail();
305         } catch (IllegalArgumentException ex) {
306             // expected
307         }
308     }
309 
310     public void testConstructor_ObjectStringEx3() throws Throwable {
311         try {
312             new YearMonthDay("10:20:30.040");
313             fail();
314         } catch (IllegalArgumentException ex) {
315             // expected
316         }
317     }
318 
319     public void testConstructor_ObjectStringEx4() throws Throwable {
320         try {
321             new YearMonthDay("10:20:30.040+14:00");
322             fail();
323         } catch (IllegalArgumentException ex) {
324             // expected
325         }
326     }
327 
328     //-----------------------------------------------------------------------
329     /**
330      * Test constructor (Object, Chronology)
331      */
332     public void testConstructor_Object_Chronology() throws Throwable {
333         Date date = new Date(TEST_TIME1);
334         YearMonthDay test = new YearMonthDay(date, GREGORIAN_PARIS);
335         assertEquals(GREGORIAN_UTC, test.getChronology());
336         assertEquals(1970, test.getYear());
337         assertEquals(4, test.getMonthOfYear());
338         assertEquals(6, test.getDayOfMonth());
339     }
340 
341     /**
342      * Test constructor (Object=null, Chronology)
343      */
344     public void testConstructor_nullObject_Chronology() throws Throwable {
345         YearMonthDay test = new YearMonthDay((Object) null, GREGORIAN_PARIS);
346         assertEquals(GREGORIAN_UTC, test.getChronology());
347         assertEquals(1970, test.getYear());
348         assertEquals(6, test.getMonthOfYear());
349         assertEquals(9, test.getDayOfMonth());
350     }
351 
352     /**
353      * Test constructor (Object, Chronology=null)
354      */
355     public void testConstructor_Object_nullChronology() throws Throwable {
356         Date date = new Date(TEST_TIME1);
357         YearMonthDay test = new YearMonthDay(date, null);
358         assertEquals(ISO_UTC, test.getChronology());
359         assertEquals(1970, test.getYear());
360         assertEquals(4, test.getMonthOfYear());
361         assertEquals(6, test.getDayOfMonth());
362     }
363 
364     /**
365      * Test constructor (Object=null, Chronology=null)
366      */
367     public void testConstructor_nullObject_nullChronology() throws Throwable {
368         YearMonthDay test = new YearMonthDay((Object) null, null);
369         assertEquals(ISO_UTC, test.getChronology());
370         assertEquals(1970, test.getYear());
371         assertEquals(6, test.getMonthOfYear());
372         assertEquals(9, test.getDayOfMonth());
373     }
374 
375     //-----------------------------------------------------------------------
376     /**
377      * Test constructor (int, int, int)
378      */
379     public void testConstructor_int_int_int() throws Throwable {
380         YearMonthDay test = new YearMonthDay(1970, 6, 9);
381         assertEquals(ISO_UTC, test.getChronology());
382         assertEquals(1970, test.getYear());
383         assertEquals(6, test.getMonthOfYear());
384         assertEquals(9, test.getDayOfMonth());
385         try {
386             new YearMonthDay(Integer.MIN_VALUE, 6, 9);
387             fail();
388         } catch (IllegalArgumentException ex) {}
389         try {
390             new YearMonthDay(Integer.MAX_VALUE, 6, 9);
391             fail();
392         } catch (IllegalArgumentException ex) {}
393         try {
394             new YearMonthDay(1970, 0, 9);
395             fail();
396         } catch (IllegalArgumentException ex) {}
397         try {
398             new YearMonthDay(1970, 13, 9);
399             fail();
400         } catch (IllegalArgumentException ex) {}
401         try {
402             new YearMonthDay(1970, 6, 0);
403             fail();
404         } catch (IllegalArgumentException ex) {}
405         try {
406             new YearMonthDay(1970, 6, 31);
407             fail();
408         } catch (IllegalArgumentException ex) {}
409         new YearMonthDay(1970, 7, 31);
410         try {
411             new YearMonthDay(1970, 7, 32);
412             fail();
413         } catch (IllegalArgumentException ex) {}
414     }
415 
416     /**
417      * Test constructor (int, int, int, Chronology)
418      */
419     public void testConstructor_int_int_int_Chronology() throws Throwable {
420         YearMonthDay test = new YearMonthDay(1970, 6, 9, GREGORIAN_PARIS);
421         assertEquals(GREGORIAN_UTC, test.getChronology());
422         assertEquals(1970, test.getYear());
423         assertEquals(6, test.getMonthOfYear());
424         assertEquals(9, test.getDayOfMonth());
425         try {
426             new YearMonthDay(Integer.MIN_VALUE, 6, 9, GREGORIAN_PARIS);
427             fail();
428         } catch (IllegalArgumentException ex) {}
429         try {
430             new YearMonthDay(Integer.MAX_VALUE, 6, 9, GREGORIAN_PARIS);
431             fail();
432         } catch (IllegalArgumentException ex) {}
433         try {
434             new YearMonthDay(1970, 0, 9, GREGORIAN_PARIS);
435             fail();
436         } catch (IllegalArgumentException ex) {}
437         try {
438             new YearMonthDay(1970, 13, 9, GREGORIAN_PARIS);
439             fail();
440         } catch (IllegalArgumentException ex) {}
441         try {
442             new YearMonthDay(1970, 6, 0, GREGORIAN_PARIS);
443             fail();
444         } catch (IllegalArgumentException ex) {}
445         try {
446             new YearMonthDay(1970, 6, 31, GREGORIAN_PARIS);
447             fail();
448         } catch (IllegalArgumentException ex) {}
449         new YearMonthDay(1970, 7, 31, GREGORIAN_PARIS);
450         try {
451             new YearMonthDay(1970, 7, 32, GREGORIAN_PARIS);
452             fail();
453         } catch (IllegalArgumentException ex) {}
454     }
455 
456     /**
457      * Test constructor (int, int, int, Chronology=null)
458      */
459     public void testConstructor_int_int_int_nullChronology() throws Throwable {
460         YearMonthDay test = new YearMonthDay(1970, 6, 9, null);
461         assertEquals(ISO_UTC, test.getChronology());
462         assertEquals(1970, test.getYear());
463         assertEquals(6, test.getMonthOfYear());
464         assertEquals(9, test.getDayOfMonth());
465     }
466 
467 }