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


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.CopticChronology;
26 import org.joda.time.chrono.GJChronology;
27 import org.joda.time.chrono.ISOChronology;
28 import org.joda.time.chrono.JulianChronology;
29
30 /**
31  * This class is a Junit unit test for TimeOfDay.
32  *
33  * @author Stephen Colebourne
34  */
35 public class TestTimeOfDay_Constructors extends TestCase {
36
37     private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London");
38     private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris");
39     private static final ISOChronology ISO_UTC = ISOChronology.getInstanceUTC();
40     private static final int OFFSET = 1;
41     
42     private long TEST_TIME_NOW =
43             10L * DateTimeConstants.MILLIS_PER_HOUR
44             + 20L * DateTimeConstants.MILLIS_PER_MINUTE
45             + 30L * DateTimeConstants.MILLIS_PER_SECOND
46             + 40L;
47             
48     private long TEST_TIME1 =
49         1L * DateTimeConstants.MILLIS_PER_HOUR
50         + 2L * DateTimeConstants.MILLIS_PER_MINUTE
51         + 3L * DateTimeConstants.MILLIS_PER_SECOND
52         + 4L;
53         
54     private long TEST_TIME2 =
55         1L * DateTimeConstants.MILLIS_PER_DAY
56         + 5L * DateTimeConstants.MILLIS_PER_HOUR
57         + 6L * DateTimeConstants.MILLIS_PER_MINUTE
58         + 7L * DateTimeConstants.MILLIS_PER_SECOND
59         + 8L;
60         
61     private DateTimeZone zone = null;
62
63     public static void main(String [] args) {
64         junit.textui.TestRunner.run(suite());
65     }
66
67     public static TestSuite suite() {
68         return new TestSuite(TestTimeOfDay_Constructors.class);
69     }
70
71     public TestTimeOfDay_Constructors(String name) {
72         super(name);
73     }
74
75     protected void setUp() throws Exception {
76         DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW);
77         zone = DateTimeZone.getDefault();
78         DateTimeZone.setDefault(LONDON);
79         java.util.TimeZone.setDefault(LONDON.toTimeZone());
80     }
81
82     protected void tearDown() throws Exception {
83         DateTimeUtils.setCurrentMillisSystem();
84         DateTimeZone.setDefault(zone);
85         java.util.TimeZone.setDefault(zone.toTimeZone());
86         zone = null;
87     }
88
89     //-----------------------------------------------------------------------
90 /**
91      * Test constructor ()
92      */
93     public void testConstantMidnight() throws Throwable {
94         TimeOfDay test = TimeOfDay.MIDNIGHT;
95         assertEquals(ISO_UTC, test.getChronology());
96         assertEquals(0, test.getHourOfDay());
97         assertEquals(0, test.getMinuteOfHour());
98         assertEquals(0, test.getSecondOfMinute());
99         assertEquals(0, test.getMillisOfSecond());
100     }
101
102     //-----------------------------------------------------------------------
103 public void testFactory_FromCalendarFields() throws Exception {
104         GregorianCalendar cal = new GregorianCalendar (1970, 1, 3, 4, 5, 6);
105         cal.set(Calendar.MILLISECOND, 7);
106         TimeOfDay expected = new TimeOfDay(4, 5, 6, 7);
107         assertEquals(expected, TimeOfDay.fromCalendarFields(cal));
108         try {
109             TimeOfDay.fromCalendarFields(null);
110             fail();
111         } catch (IllegalArgumentException ex) {}
112     }
113
114     //-----------------------------------------------------------------------
115 public void testFactory_FromDateFields() throws Exception {
116         GregorianCalendar cal = new GregorianCalendar (1970, 1, 3, 4, 5, 6);
117         cal.set(Calendar.MILLISECOND, 7);
118         TimeOfDay expected = new TimeOfDay(4, 5, 6, 7);
119         assertEquals(expected, TimeOfDay.fromDateFields(cal.getTime()));
120         try {
121             TimeOfDay.fromDateFields(null);
122             fail();
123         } catch (IllegalArgumentException ex) {}
124     }
125
126     //-----------------------------------------------------------------------
127 /**
128      * Test factory (long)
129      */
130     public void testFactoryMillisOfDay_long1() throws Throwable {
131         TimeOfDay test = TimeOfDay.fromMillisOfDay(TEST_TIME1);
132         assertEquals(ISO_UTC, test.getChronology());
133         assertEquals(1, test.getHourOfDay());
134         assertEquals(2, test.getMinuteOfHour());
135         assertEquals(3, test.getSecondOfMinute());
136         assertEquals(4, test.getMillisOfSecond());
137     }
138
139     /**
140      * Test factory (long, Chronology)
141      */
142     public void testFactoryMillisOfDay_long1_Chronology() throws Throwable {
143         TimeOfDay test = TimeOfDay.fromMillisOfDay(TEST_TIME1, JulianChronology.getInstance());
144         assertEquals(JulianChronology.getInstanceUTC(), test.getChronology());
145         assertEquals(1, test.getHourOfDay());
146         assertEquals(2, test.getMinuteOfHour());
147         assertEquals(3, test.getSecondOfMinute());
148         assertEquals(4, test.getMillisOfSecond());
149     }
150
151     /**
152      * Test factory (long, Chronology=null)
153      */
154     public void testFactoryMillisOfDay_long_nullChronology() throws Throwable {
155         TimeOfDay test = TimeOfDay.fromMillisOfDay(TEST_TIME1, null);
156         assertEquals(ISO_UTC, test.getChronology());
157         assertEquals(1, test.getHourOfDay());
158         assertEquals(2, test.getMinuteOfHour());
159         assertEquals(3, test.getSecondOfMinute());
160         assertEquals(4, test.getMillisOfSecond());
161     }
162
163     //-----------------------------------------------------------------------
164 /**
165      * Test constructor ()
166      */
167     public void testConstructor() throws Throwable {
168         TimeOfDay test = new TimeOfDay();
169         assertEquals(ISO_UTC, test.getChronology());
170         assertEquals(10 + OFFSET, test.getHourOfDay());
171         assertEquals(20, test.getMinuteOfHour());
172         assertEquals(30, test.getSecondOfMinute());
173         assertEquals(40, test.getMillisOfSecond());
174     }
175
176     /**
177      * Test constructor (DateTimeZone)
178      */
179     public void testConstructor_DateTimeZone() throws Throwable {
180         DateTime dt = new DateTime(2005, 6, 8, 23, 59, 30, 40, LONDON);
181         DateTimeUtils.setCurrentMillisFixed(dt.getMillis());
182         // 23:59 in London is 00:59 the following day in Paris
183
184         TimeOfDay test = new TimeOfDay(LONDON);
185         assertEquals(ISO_UTC, test.getChronology());
186         assertEquals(23, test.getHourOfDay());
187         assertEquals(59, test.getMinuteOfHour());
188         assertEquals(30, test.getSecondOfMinute());
189         assertEquals(40, test.getMillisOfSecond());
190         
191         test = new TimeOfDay(PARIS);
192         assertEquals(ISO_UTC, test.getChronology());
193         assertEquals(0, test.getHourOfDay());
194         assertEquals(59, test.getMinuteOfHour());
195         assertEquals(30, test.getSecondOfMinute());
196         assertEquals(40, test.getMillisOfSecond());
197     }
198
199     /**
200      * Test constructor (DateTimeZone=null)
201      */
202     public void testConstructor_nullDateTimeZone() throws Throwable {
203         DateTime dt = new DateTime(2005, 6, 8, 23, 59, 30, 40, LONDON);
204         DateTimeUtils.setCurrentMillisFixed(dt.getMillis());
205         // 23:59 in London is 00:59 the following day in Paris
206
207         TimeOfDay test = new TimeOfDay((DateTimeZone) null);
208         assertEquals(ISO_UTC, test.getChronology());
209         assertEquals(23, test.getHourOfDay());
210         assertEquals(59, test.getMinuteOfHour());
211         assertEquals(30, test.getSecondOfMinute());
212         assertEquals(40, test.getMillisOfSecond());
213     }
214
215     /**
216      * Test constructor (Chronology)
217      */
218     public void testConstructor_Chronology() throws Throwable {
219         TimeOfDay test = new TimeOfDay(JulianChronology.getInstance());
220         assertEquals(JulianChronology.getInstanceUTC(), test.getChronology());
221         assertEquals(10 + OFFSET, test.getHourOfDay());
222         assertEquals(20, test.getMinuteOfHour());
223         assertEquals(30, test.getSecondOfMinute());
224         assertEquals(40, test.getMillisOfSecond());
225     }
226
227     /**
228      * Test constructor (Chronology=null)
229      */
230     public void testConstructor_nullChronology() throws Throwable {
231         TimeOfDay test = new TimeOfDay((Chronology) null);
232         assertEquals(ISO_UTC, test.getChronology());
233         assertEquals(10 + OFFSET, test.getHourOfDay());
234         assertEquals(20, test.getMinuteOfHour());
235         assertEquals(30, test.getSecondOfMinute());
236         assertEquals(40, test.getMillisOfSecond());
237     }
238
239     //-----------------------------------------------------------------------
240 /**
241      * Test constructor (long)
242      */
243     public void testConstructor_long1() throws Throwable {
244         TimeOfDay test = new TimeOfDay(TEST_TIME1);
245         assertEquals(ISO_UTC, test.getChronology());
246         assertEquals(1 + OFFSET, test.getHourOfDay());
247         assertEquals(2, test.getMinuteOfHour());
248         assertEquals(3, test.getSecondOfMinute());
249         assertEquals(4, test.getMillisOfSecond());
250     }
251
252     /**
253      * Test constructor (long)
254      */
255     public void testConstructor_long2() throws Throwable {
256         TimeOfDay test = new TimeOfDay(TEST_TIME2);
257         assertEquals(ISO_UTC, test.getChronology());
258         assertEquals(5 + OFFSET, test.getHourOfDay());
259         assertEquals(6, test.getMinuteOfHour());
260         assertEquals(7, test.getSecondOfMinute());
261         assertEquals(8, test.getMillisOfSecond());
262     }
263
264     /**
265      * Test constructor (long, Chronology)
266      */
267     public void testConstructor_long1_Chronology() throws Throwable {
268         TimeOfDay test = new TimeOfDay(TEST_TIME1, JulianChronology.getInstance());
269         assertEquals(JulianChronology.getInstanceUTC(), test.getChronology());
270         assertEquals(1 + OFFSET, test.getHourOfDay());
271         assertEquals(2, test.getMinuteOfHour());
272         assertEquals(3, test.getSecondOfMinute());
273         assertEquals(4, test.getMillisOfSecond());
274     }
275
276     /**
277      * Test constructor (long, Chronology)
278      */
279     public void testConstructor_long2_Chronology() throws Throwable {
280         TimeOfDay test = new TimeOfDay(TEST_TIME2, JulianChronology.getInstance());
281         assertEquals(JulianChronology.getInstanceUTC(), test.getChronology());
282         assertEquals(5 + OFFSET, test.getHourOfDay());
283         assertEquals(6, test.getMinuteOfHour());
284         assertEquals(7, test.getSecondOfMinute());
285         assertEquals(8, test.getMillisOfSecond());
286     }
287
288     /**
289      * Test constructor (long, Chronology=null)
290      */
291     public void testConstructor_long_nullChronology() throws Throwable {
292         TimeOfDay test = new TimeOfDay(TEST_TIME1, null);
293         assertEquals(ISO_UTC, test.getChronology());
294         assertEquals(1 + OFFSET, test.getHourOfDay());
295         assertEquals(2, test.getMinuteOfHour());
296         assertEquals(3, test.getSecondOfMinute());
297         assertEquals(4, test.getMillisOfSecond());
298     }
299
300     //-----------------------------------------------------------------------
301 /**
302      * Test constructor (Object)
303      */
304     public void testConstructor_Object1() throws Throwable {
305         Date date = new Date (TEST_TIME1);
306         TimeOfDay test = new TimeOfDay(date);
307         assertEquals(ISO_UTC, test.getChronology());
308         assertEquals(1 + OFFSET, test.getHourOfDay());
309         assertEquals(2, test.getMinuteOfHour());
310         assertEquals(3, test.getSecondOfMinute());
311         assertEquals(4, test.getMillisOfSecond());
312     }
313
314     /**
315      * Test constructor (Object)
316      */
317     public void testConstructor_Object2() throws Throwable {
318         Calendar cal = new GregorianCalendar ();
319         cal.setTime(new Date (TEST_TIME1));
320         TimeOfDay test = new TimeOfDay(cal);
321         assertEquals(GJChronology.getInstanceUTC(), test.getChronology());
322         assertEquals(1 + OFFSET, test.getHourOfDay());
323         assertEquals(2, test.getMinuteOfHour());
324         assertEquals(3, test.getSecondOfMinute());
325         assertEquals(4, test.getMillisOfSecond());
326     }
327
328     /**
329      * Test constructor (Object=null)
330      */
331     public void testConstructor_nullObject() throws Throwable {
332         TimeOfDay test = new TimeOfDay((Object ) null);
333         assertEquals(ISO_UTC, test.getChronology());
334         assertEquals(10 + OFFSET, test.getHourOfDay());
335         assertEquals(20, test.getMinuteOfHour());
336         assertEquals(30, test.getSecondOfMinute());
337         assertEquals(40, test.getMillisOfSecond());
338     }
339
340     /**
341      * Test constructor (Object)
342      */
343     public void testConstructor_todObject() throws Throwable {
344         TimeOfDay base = new TimeOfDay(10, 20, 30, 40, CopticChronology.getInstance(PARIS));
345         TimeOfDay test = new TimeOfDay(base);
346         assertEquals(CopticChronology.getInstanceUTC(), test.getChronology());
347         assertEquals(10, test.getHourOfDay());
348         assertEquals(20, test.getMinuteOfHour());
349         assertEquals(30, test.getSecondOfMinute());
350         assertEquals(40, test.getMillisOfSecond());
351     }
352
353     public void testConstructor_ObjectString1() throws Throwable {
354         TimeOfDay test = new TimeOfDay("10:20:30.040");
355         assertEquals(ISO_UTC, test.getChronology());
356         assertEquals(10, test.getHourOfDay());
357         assertEquals(20, test.getMinuteOfHour());
358         assertEquals(30, test.getSecondOfMinute());
359         assertEquals(40, test.getMillisOfSecond());
360     }
361
362     public void testConstructor_ObjectString2() throws Throwable {
363         TimeOfDay test = new TimeOfDay("10:20:30.040+04:00");
364         assertEquals(ISO_UTC, test.getChronology());
365         assertEquals(10 + OFFSET - 4, test.getHourOfDay());
366         assertEquals(20, test.getMinuteOfHour());
367         assertEquals(30, test.getSecondOfMinute());
368         assertEquals(40, test.getMillisOfSecond());
369     }
370
371     public void testConstructor_ObjectString3() throws Throwable {
372         TimeOfDay test = new TimeOfDay("T10:20:30.040");
373         assertEquals(ISO_UTC, test.getChronology());
374         assertEquals(10, test.getHourOfDay());
375         assertEquals(20, test.getMinuteOfHour());
376         assertEquals(30, test.getSecondOfMinute());
377         assertEquals(40, test.getMillisOfSecond());
378     }
379
380     public void testConstructor_ObjectString4() throws Throwable {
381         TimeOfDay test = new TimeOfDay("T10:20:30.040+04:00");
382         assertEquals(ISO_UTC, test.getChronology());
383         assertEquals(10 + OFFSET - 4, test.getHourOfDay());
384         assertEquals(20, test.getMinuteOfHour());
385         assertEquals(30, test.getSecondOfMinute());
386         assertEquals(40, test.getMillisOfSecond());
387     }
388
389     public void testConstructor_ObjectString5() throws Throwable {
390         TimeOfDay test = new TimeOfDay("10:20");
391         assertEquals(ISO_UTC, test.getChronology());
392         assertEquals(10, test.getHourOfDay());
393         assertEquals(20, test.getMinuteOfHour());
394         assertEquals(0, test.getSecondOfMinute());
395         assertEquals(0, test.getMillisOfSecond());
396     }
397
398     public void testConstructor_ObjectString6() throws Throwable {
399         TimeOfDay test = new TimeOfDay("10");
400         assertEquals(ISO_UTC, test.getChronology());
401         assertEquals(10, test.getHourOfDay());
402         assertEquals(0, test.getMinuteOfHour());
403         assertEquals(0, test.getSecondOfMinute());
404         assertEquals(0, test.getMillisOfSecond());
405     }
406
407     public void testConstructor_ObjectStringEx1() throws Throwable {
408         try {
409             new TimeOfDay("1970-04-06");
410             fail();
411         } catch (IllegalArgumentException ex) {}
412     }
413
414     public void testConstructor_ObjectStringEx2() throws Throwable {
415         try {
416             new TimeOfDay("1970-04-06T+14:00");
417             fail();
418         } catch (IllegalArgumentException ex) {}
419     }
420
421     public void testConstructor_ObjectStringEx3() throws Throwable {
422         try {
423             new TimeOfDay("1970-04-06T10:20:30.040");
424             fail();
425         } catch (IllegalArgumentException ex) {}
426     }
427
428     public void testConstructor_ObjectStringEx4() throws Throwable {
429         try {
430             new TimeOfDay("1970-04-06T10:20:30.040+14:00");
431             fail();
432         } catch (IllegalArgumentException ex) {}
433     }
434
435     //-----------------------------------------------------------------------
436 /**
437      * Test constructor (Object, Chronology)
438      */
439     public void testConstructor_Object_Chronology() throws Throwable {
440         Date date = new Date (TEST_TIME1);
441         TimeOfDay test = new TimeOfDay(date, JulianChronology.getInstance());
442         assertEquals(JulianChronology.getInstanceUTC(), test.getChronology());
443         assertEquals(1 + OFFSET, test.getHourOfDay());
444         assertEquals(2, test.getMinuteOfHour());
445         assertEquals(3, test.getSecondOfMinute());
446         assertEquals(4, test.getMillisOfSecond());
447     }
448
449     /**
450      * Test constructor (Object, Chronology)
451      */
452     public void testConstructor2_Object_Chronology() throws Throwable {
453         TimeOfDay test = new TimeOfDay("T10:20");
454         assertEquals(10, test.getHourOfDay());
455         assertEquals(20, test.getMinuteOfHour());
456         assertEquals(0, test.getSecondOfMinute());
457         assertEquals(0, test.getMillisOfSecond());
458         
459         try {
460             new TimeOfDay("T1020");
461             fail();
462         } catch (IllegalArgumentException ex) {}
463     }
464
465     /**
466      * Test constructor (Object=null, Chronology)
467      */
468     public void testConstructor_nullObject_Chronology() throws Throwable {
469         TimeOfDay test = new TimeOfDay((Object ) null, JulianChronology.getInstance());
470         assertEquals(JulianChronology.getInstanceUTC(), test.getChronology());
471         assertEquals(10 + OFFSET, test.getHourOfDay());
472         assertEquals(20, test.getMinuteOfHour());
473         assertEquals(30, test.getSecondOfMinute());
474         assertEquals(40, test.getMillisOfSecond());
475     }
476
477     /**
478      * Test constructor (Object, Chronology=null)
479      */
480     public void testConstructor_Object_nullChronology() throws Throwable {
481         Date date = new Date (TEST_TIME1);
482         TimeOfDay test = new TimeOfDay(date, null);
483         assertEquals(ISO_UTC, test.getChronology());
484         assertEquals(1 + OFFSET, test.getHourOfDay());
485         assertEquals(2, test.getMinuteOfHour());
486         assertEquals(3, test.getSecondOfMinute());
487         assertEquals(4, test.getMillisOfSecond());
488     }
489
490     /**
491      * Test constructor (Object=null, Chronology=null)
492      */
493     public void testConstructor_nullObject_nullChronology() throws Throwable {
494         TimeOfDay test = new TimeOfDay((Object ) null, null);
495         assertEquals(ISO_UTC, test.getChronology());
496         assertEquals(10 + OFFSET, test.getHourOfDay());
497         assertEquals(20, test.getMinuteOfHour());
498         assertEquals(30, test.getSecondOfMinute());
499         assertEquals(40, test.getMillisOfSecond());
500     }
501
502     //-----------------------------------------------------------------------
503 /**
504      * Test constructor (int, int)
505      */
506     public void testConstructor_int_int() throws Throwable {
507         TimeOfDay test = new TimeOfDay(10, 20);
508         assertEquals(ISO_UTC, test.getChronology());
509         assertEquals(10, test.getHourOfDay());
510         assertEquals(20, test.getMinuteOfHour());
511         assertEquals(0, test.getSecondOfMinute());
512         assertEquals(0, test.getMillisOfSecond());
513         try {
514             new TimeOfDay(-1, 20);
515             fail();
516         } catch (IllegalArgumentException ex) {}
517         try {
518             new TimeOfDay(24, 20);
519             fail();
520         } catch (IllegalArgumentException ex) {}
521         try {
522             new TimeOfDay(10, -1);
523             fail();
524         } catch (IllegalArgumentException ex) {}
525         try {
526             new TimeOfDay(10, 60);
527             fail();
528         } catch (IllegalArgumentException ex) {}
529     }
530
531     /**
532      * Test constructor (int, int, int, Chronology)
533      */
534     public void testConstructor_int_int_Chronology() throws Throwable {
535         TimeOfDay test = new TimeOfDay(10, 20, JulianChronology.getInstance());
536         assertEquals(JulianChronology.getInstanceUTC(), test.getChronology());
537         assertEquals(10, test.getHourOfDay());
538         assertEquals(20, test.getMinuteOfHour());
539         assertEquals(0, test.getSecondOfMinute());
540         assertEquals(0, test.getMillisOfSecond());
541         try {
542             new TimeOfDay(-1, 20, JulianChronology.getInstance());
543             fail();
544         } catch (IllegalArgumentException ex) {}
545         try {
546             new TimeOfDay(24, 20, JulianChronology.getInstance());
547             fail();
548         } catch (IllegalArgumentException ex) {}
549         try {
550             new TimeOfDay(10, -1, JulianChronology.getInstance());
551             fail();
552         } catch (IllegalArgumentException ex) {}
553         try {
554             new TimeOfDay(10, 60, JulianChronology.getInstance());
555             fail();
556         } catch (IllegalArgumentException ex) {}
557     }
558
559     /**
560      * Test constructor (int, int, int, Chronology=null)
561      */
562     public void testConstructor_int_int_nullChronology() throws Throwable {
563         TimeOfDay test = new TimeOfDay(10, 20, null);
564         assertEquals(ISO_UTC, test.getChronology());
565         assertEquals(10, test.getHourOfDay());
566         assertEquals(20, test.getMinuteOfHour());
567         assertEquals(0, test.getSecondOfMinute());
568         assertEquals(0, test.getMillisOfSecond());
569     }
570
571     /**
572      * Test constructor (int, int, int)
573      */
574     public void testConstructor_int_int_int() throws Throwable {
575         TimeOfDay test = new TimeOfDay(10, 20, 30);
576         assertEquals(ISO_UTC, test.getChronology());
577         assertEquals(10, test.getHourOfDay());
578         assertEquals(20, test.getMinuteOfHour());
579         assertEquals(30, test.getSecondOfMinute());
580         assertEquals(0, test.getMillisOfSecond());
581         try {
582             new TimeOfDay(-1, 20, 30);
583             fail();
584         } catch (IllegalArgumentException ex) {}
585         try {
586             new TimeOfDay(24, 20, 30);
587             fail();
588         } catch (IllegalArgumentException ex) {}
589         try {
590             new TimeOfDay(10, -1, 30);
591             fail();
592         } catch (IllegalArgumentException ex) {}
593         try {
594             new TimeOfDay(10, 60, 30);
595             fail();
596         } catch (IllegalArgumentException ex) {}
597         try {
598             new TimeOfDay(10, 20, -1);
599             fail();
600         } catch (IllegalArgumentException ex) {}
601         try {
602             new TimeOfDay(10, 20, 60);
603             fail();
604         } catch (IllegalArgumentException ex) {}
605     }
606
607     /**
608      * Test constructor (int, int, int, Chronology)
609      */
610     public void testConstructor_int_int_int_Chronology() throws Throwable {
611         TimeOfDay test = new TimeOfDay(10, 20, 30, JulianChronology.getInstance());
612         assertEquals(JulianChronology.getInstanceUTC(), test.getChronology());
613         assertEquals(10, test.getHourOfDay());
614         assertEquals(20, test.getMinuteOfHour());
615         assertEquals(30, test.getSecondOfMinute());
616         assertEquals(0, test.getMillisOfSecond());
617         try {
618             new TimeOfDay(-1, 20, 30, JulianChronology.getInstance());
619             fail();
620         } catch (IllegalArgumentException ex) {}
621         try {
622             new TimeOfDay(24, 20, 30, JulianChronology.getInstance());
623             fail();
624         } catch (IllegalArgumentException ex) {}
625         try {
626             new TimeOfDay(10, -1, 30, JulianChronology.getInstance());
627             fail();
628         } catch (IllegalArgumentException ex) {}
629         try {
630             new TimeOfDay(10, 60, 30, JulianChronology.getInstance());
631             fail();
632         } catch (IllegalArgumentException ex) {}
633         try {
634             new TimeOfDay(10, 20, -1, JulianChronology.getInstance());
635             fail();
636         } catch (IllegalArgumentException ex) {}
637         try {
638             new TimeOfDay(10, 20, 60, JulianChronology.getInstance());
639             fail();
640         } catch (IllegalArgumentException ex) {}
641     }
642
643     /**
644      * Test constructor (int, int, int, Chronology=null)
645      */
646     public void testConstructor_int_int_int_nullChronology() throws Throwable {
647         TimeOfDay test = new TimeOfDay(10, 20, 30, null);
648         assertEquals(ISO_UTC, test.getChronology());
649         assertEquals(10, test.getHourOfDay());
650         assertEquals(20, test.getMinuteOfHour());
651         assertEquals(30, test.getSecondOfMinute());
652         assertEquals(0, test.getMillisOfSecond());
653     }
654
655     /**
656      * Test constructor (int, int, int, int)
657      */
658     public void testConstructor_int_int_int_int() throws Throwable {
659         TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
660         assertEquals(ISO_UTC, test.getChronology());
661         assertEquals(10, test.getHourOfDay());
662         assertEquals(20, test.getMinuteOfHour());
663         assertEquals(30, test.getSecondOfMinute());
664         assertEquals(40, test.getMillisOfSecond());
665         try {
666             new TimeOfDay(-1, 20, 30, 40);
667             fail();
668         } catch (IllegalArgumentException ex) {}
669         try {
670             new TimeOfDay(24, 20, 30, 40);
671             fail();
672         } catch (IllegalArgumentException ex) {}
673         try {
674             new TimeOfDay(10, -1, 30, 40);
675             fail();
676         } catch (IllegalArgumentException ex) {}
677         try {
678             new TimeOfDay(10, 60, 30, 40);
679             fail();
680         } catch (IllegalArgumentException ex) {}
681         try {
682             new TimeOfDay(10, 20, -1, 40);
683             fail();
684         } catch (IllegalArgumentException ex) {}
685         try {
686             new TimeOfDay(10, 20, 60, 40);
687             fail();
688         } catch (IllegalArgumentException ex) {}
689         try {
690             new TimeOfDay(10, 20, 30, -1);
691             fail();
692         } catch (IllegalArgumentException ex) {}
693         try {
694             new TimeOfDay(10, 20, 30, 1000);
695             fail();
696         } catch (IllegalArgumentException ex) {}
697     }
698
699     /**
700      * Test constructor (int, int, int, int, Chronology)
701      */
702     public void testConstructor_int_int_int_int_Chronology() throws Throwable {
703         TimeOfDay test = new TimeOfDay(10, 20, 30, 40, JulianChronology.getInstance());
704         assertEquals(JulianChronology.getInstanceUTC(), test.getChronology());
705         assertEquals(10, test.getHourOfDay());
706         assertEquals(20, test.getMinuteOfHour());
707         assertEquals(30, test.getSecondOfMinute());
708         assertEquals(40, test.getMillisOfSecond());
709         try {
710             new TimeOfDay(-1, 20, 30, 40, JulianChronology.getInstance());
711             fail();
712         } catch (IllegalArgumentException ex) {}
713         try {
714             new TimeOfDay(24, 20, 30, 40, JulianChronology.getInstance());
715             fail();
716         } catch (IllegalArgumentException ex) {}
717         try {
718             new TimeOfDay(10, -1, 30, 40, JulianChronology.getInstance());
719             fail();
720         } catch (IllegalArgumentException ex) {}
721         try {
722             new TimeOfDay(10, 60, 30, 40, JulianChronology.getInstance());
723             fail();
724         } catch (IllegalArgumentException ex) {}
725         try {
726             new TimeOfDay(10, 20, -1, 40, JulianChronology.getInstance());
727             fail();
728         } catch (IllegalArgumentException ex) {}
729         try {
730             new TimeOfDay(10, 20, 60, 40, JulianChronology.getInstance());
731             fail();
732         } catch (IllegalArgumentException ex) {}
733         try {
734             new TimeOfDay(10, 20, 30, -1, JulianChronology.getInstance());
735             fail();
736         } catch (IllegalArgumentException ex) {}
737         try {
738             new TimeOfDay(10, 20, 30, 1000, JulianChronology.getInstance());
739             fail();
740         } catch (IllegalArgumentException ex) {}
741     }
742
743     /**
744      * Test constructor (int, int, int, int, Chronology=null)
745      */
746     public void testConstructor_int_int_int_int_nullChronology() throws Throwable {
747         TimeOfDay test = new TimeOfDay(10, 20, 30, 40, null);
748         assertEquals(ISO_UTC, test.getChronology());
749         assertEquals(10, test.getHourOfDay());
750         assertEquals(20, test.getMinuteOfHour());
751         assertEquals(30, test.getSecondOfMinute());
752         assertEquals(40, test.getMillisOfSecond());
753     }
754
755 }
756

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags