001    /*
002     *  Copyright 2001-2005 Stephen Colebourne
003     *
004     *  Licensed under the Apache License, Version 2.0 (the "License");
005     *  you may not use this file except in compliance with the License.
006     *  You may obtain a copy of the License at
007     *
008     *      http://www.apache.org/licenses/LICENSE-2.0
009     *
010     *  Unless required by applicable law or agreed to in writing, software
011     *  distributed under the License is distributed on an "AS IS" BASIS,
012     *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013     *  See the License for the specific language governing permissions and
014     *  limitations under the License.
015     */
016    package org.joda.time;
017    
018    import java.util.Locale;
019    
020    import junit.framework.TestCase;
021    import junit.framework.TestSuite;
022    
023    /**
024     * This class is a Junit unit test for TimeOfDay.
025     *
026     * @author Stephen Colebourne
027     */
028    public class TestTimeOfDay_Properties extends TestCase {
029    
030        private static final DateTimeZone LONDON = DateTimeZone.forID("Europe/London");
031        private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris");
032        
033        private long TEST_TIME_NOW =
034                10L * DateTimeConstants.MILLIS_PER_HOUR
035                + 20L * DateTimeConstants.MILLIS_PER_MINUTE
036                + 30L * DateTimeConstants.MILLIS_PER_SECOND
037                + 40L;
038                
039        private long TEST_TIME1 =
040            1L * DateTimeConstants.MILLIS_PER_HOUR
041            + 2L * DateTimeConstants.MILLIS_PER_MINUTE
042            + 3L * DateTimeConstants.MILLIS_PER_SECOND
043            + 4L;
044            
045        private long TEST_TIME2 =
046            1L * DateTimeConstants.MILLIS_PER_DAY
047            + 5L * DateTimeConstants.MILLIS_PER_HOUR
048            + 6L * DateTimeConstants.MILLIS_PER_MINUTE
049            + 7L * DateTimeConstants.MILLIS_PER_SECOND
050            + 8L;
051            
052        private DateTimeZone zone = null;
053    
054        public static void main(String[] args) {
055            junit.textui.TestRunner.run(suite());
056        }
057    
058        public static TestSuite suite() {
059            return new TestSuite(TestTimeOfDay_Properties.class);
060        }
061    
062        public TestTimeOfDay_Properties(String name) {
063            super(name);
064        }
065    
066        protected void setUp() throws Exception {
067            DateTimeUtils.setCurrentMillisFixed(TEST_TIME_NOW);
068            zone = DateTimeZone.getDefault();
069            DateTimeZone.setDefault(LONDON);
070        }
071    
072        protected void tearDown() throws Exception {
073            DateTimeUtils.setCurrentMillisSystem();
074            DateTimeZone.setDefault(zone);
075            zone = null;
076        }
077    
078        //-----------------------------------------------------------------------
079        public void testPropertyGetHour() {
080            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
081            assertSame(test.getChronology().hourOfDay(), test.hourOfDay().getField());
082            assertEquals("hourOfDay", test.hourOfDay().getName());
083            assertEquals("Property[hourOfDay]", test.hourOfDay().toString());
084            assertSame(test, test.hourOfDay().getReadablePartial());
085            assertSame(test, test.hourOfDay().getTimeOfDay());
086            assertEquals(10, test.hourOfDay().get());
087            assertEquals("10", test.hourOfDay().getAsString());
088            assertEquals("10", test.hourOfDay().getAsText());
089            assertEquals("10", test.hourOfDay().getAsText(Locale.FRENCH));
090            assertEquals("10", test.hourOfDay().getAsShortText());
091            assertEquals("10", test.hourOfDay().getAsShortText(Locale.FRENCH));
092            assertEquals(test.getChronology().hours(), test.hourOfDay().getDurationField());
093            assertEquals(test.getChronology().days(), test.hourOfDay().getRangeDurationField());
094            assertEquals(2, test.hourOfDay().getMaximumTextLength(null));
095            assertEquals(2, test.hourOfDay().getMaximumShortTextLength(null));
096        }
097    
098        public void testPropertyGetMaxMinValuesHour() {
099            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
100            assertEquals(0, test.hourOfDay().getMinimumValue());
101            assertEquals(0, test.hourOfDay().getMinimumValueOverall());
102            assertEquals(23, test.hourOfDay().getMaximumValue());
103            assertEquals(23, test.hourOfDay().getMaximumValueOverall());
104        }
105    
106        public void testPropertyAddHour() {
107            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
108            TimeOfDay copy = test.hourOfDay().addToCopy(9);
109            check(test, 10, 20, 30, 40);
110            check(copy, 19, 20, 30, 40);
111            
112            copy = test.hourOfDay().addToCopy(0);
113            check(copy, 10, 20, 30, 40);
114            
115            copy = test.hourOfDay().addToCopy(13);
116            check(copy, 23, 20, 30, 40);
117            
118            copy = test.hourOfDay().addToCopy(14);
119            check(copy, 0, 20, 30, 40);
120            
121            copy = test.hourOfDay().addToCopy(-10);
122            check(copy, 0, 20, 30, 40);
123            
124            copy = test.hourOfDay().addToCopy(-11);
125            check(copy, 23, 20, 30, 40);
126        }
127    
128        public void testPropertyAddNoWrapHour() {
129            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
130            TimeOfDay copy = test.hourOfDay().addNoWrapToCopy(9);
131            check(test, 10, 20, 30, 40);
132            check(copy, 19, 20, 30, 40);
133            
134            copy = test.hourOfDay().addNoWrapToCopy(0);
135            check(copy, 10, 20, 30, 40);
136            
137            copy = test.hourOfDay().addNoWrapToCopy(13);
138            check(copy, 23, 20, 30, 40);
139            
140            try {
141                test.hourOfDay().addNoWrapToCopy(14);
142                fail();
143            } catch (IllegalArgumentException ex) {}
144            check(test, 10, 20, 30, 40);
145            
146            copy = test.hourOfDay().addNoWrapToCopy(-10);
147            check(copy, 0, 20, 30, 40);
148            
149            try {
150                test.hourOfDay().addNoWrapToCopy(-11);
151                fail();
152            } catch (IllegalArgumentException ex) {}
153            check(test, 10, 20, 30, 40);
154        }
155    
156        public void testPropertyAddWrapFieldHour() {
157            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
158            TimeOfDay copy = test.hourOfDay().addWrapFieldToCopy(9);
159            check(test, 10, 20, 30, 40);
160            check(copy, 19, 20, 30, 40);
161            
162            copy = test.hourOfDay().addWrapFieldToCopy(0);
163            check(copy, 10, 20, 30, 40);
164            
165            copy = test.hourOfDay().addWrapFieldToCopy(18);
166            check(copy, 4, 20, 30, 40);
167            
168            copy = test.hourOfDay().addWrapFieldToCopy(-15);
169            check(copy, 19, 20, 30, 40);
170        }
171    
172        public void testPropertySetHour() {
173            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
174            TimeOfDay copy = test.hourOfDay().setCopy(12);
175            check(test, 10, 20, 30, 40);
176            check(copy, 12, 20, 30, 40);
177            
178            try {
179                test.hourOfDay().setCopy(24);
180                fail();
181            } catch (IllegalArgumentException ex) {}
182            try {
183                test.hourOfDay().setCopy(-1);
184                fail();
185            } catch (IllegalArgumentException ex) {}
186        }
187    
188        public void testPropertySetTextHour() {
189            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
190            TimeOfDay copy = test.hourOfDay().setCopy("12");
191            check(test, 10, 20, 30, 40);
192            check(copy, 12, 20, 30, 40);
193        }
194    
195        public void testPropertyWithMaximumValueHour() {
196            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
197            TimeOfDay copy = test.hourOfDay().withMaximumValue();
198            check(test, 10, 20, 30, 40);
199            check(copy, 23, 20, 30, 40);
200        }
201    
202        public void testPropertyWithMinimumValueHour() {
203            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
204            TimeOfDay copy = test.hourOfDay().withMinimumValue();
205            check(test, 10, 20, 30, 40);
206            check(copy, 0, 20, 30, 40);
207        }
208    
209        public void testPropertyCompareToHour() {
210            TimeOfDay test1 = new TimeOfDay(TEST_TIME1);
211            TimeOfDay test2 = new TimeOfDay(TEST_TIME2);
212            assertEquals(true, test1.hourOfDay().compareTo(test2) < 0);
213            assertEquals(true, test2.hourOfDay().compareTo(test1) > 0);
214            assertEquals(true, test1.hourOfDay().compareTo(test1) == 0);
215            try {
216                test1.hourOfDay().compareTo((ReadablePartial) null);
217                fail();
218            } catch (IllegalArgumentException ex) {}
219            
220            DateTime dt1 = new DateTime(TEST_TIME1);
221            DateTime dt2 = new DateTime(TEST_TIME2);
222            assertEquals(true, test1.hourOfDay().compareTo(dt2) < 0);
223            assertEquals(true, test2.hourOfDay().compareTo(dt1) > 0);
224            assertEquals(true, test1.hourOfDay().compareTo(dt1) == 0);
225            try {
226                test1.hourOfDay().compareTo((ReadableInstant) null);
227                fail();
228            } catch (IllegalArgumentException ex) {}
229        }
230    
231        //-----------------------------------------------------------------------
232        public void testPropertyGetMinute() {
233            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
234            assertSame(test.getChronology().minuteOfHour(), test.minuteOfHour().getField());
235            assertEquals("minuteOfHour", test.minuteOfHour().getName());
236            assertEquals("Property[minuteOfHour]", test.minuteOfHour().toString());
237            assertSame(test, test.minuteOfHour().getReadablePartial());
238            assertSame(test, test.minuteOfHour().getTimeOfDay());
239            assertEquals(20, test.minuteOfHour().get());
240            assertEquals("20", test.minuteOfHour().getAsString());
241            assertEquals("20", test.minuteOfHour().getAsText());
242            assertEquals("20", test.minuteOfHour().getAsText(Locale.FRENCH));
243            assertEquals("20", test.minuteOfHour().getAsShortText());
244            assertEquals("20", test.minuteOfHour().getAsShortText(Locale.FRENCH));
245            assertEquals(test.getChronology().minutes(), test.minuteOfHour().getDurationField());
246            assertEquals(test.getChronology().hours(), test.minuteOfHour().getRangeDurationField());
247            assertEquals(2, test.minuteOfHour().getMaximumTextLength(null));
248            assertEquals(2, test.minuteOfHour().getMaximumShortTextLength(null));
249        }
250    
251        public void testPropertyGetMaxMinValuesMinute() {
252            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
253            assertEquals(0, test.minuteOfHour().getMinimumValue());
254            assertEquals(0, test.minuteOfHour().getMinimumValueOverall());
255            assertEquals(59, test.minuteOfHour().getMaximumValue());
256            assertEquals(59, test.minuteOfHour().getMaximumValueOverall());
257        }
258    
259        public void testPropertyAddMinute() {
260            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
261            TimeOfDay copy = test.minuteOfHour().addToCopy(9);
262            check(test, 10, 20, 30, 40);
263            check(copy, 10, 29, 30, 40);
264            
265            copy = test.minuteOfHour().addToCopy(39);
266            check(copy, 10, 59, 30, 40);
267            
268            copy = test.minuteOfHour().addToCopy(40);
269            check(copy, 11, 0, 30, 40);
270            
271            copy = test.minuteOfHour().addToCopy(1 * 60 + 45);
272            check(copy, 12, 5, 30, 40);
273            
274            copy = test.minuteOfHour().addToCopy(13 * 60 + 39);
275            check(copy, 23, 59, 30, 40);
276            
277            copy = test.minuteOfHour().addToCopy(13 * 60 + 40);
278            check(copy, 0, 0, 30, 40);
279            
280            copy = test.minuteOfHour().addToCopy(-9);
281            check(copy, 10, 11, 30, 40);
282            
283            copy = test.minuteOfHour().addToCopy(-19);
284            check(copy, 10, 1, 30, 40);
285            
286            copy = test.minuteOfHour().addToCopy(-20);
287            check(copy, 10, 0, 30, 40);
288            
289            copy = test.minuteOfHour().addToCopy(-21);
290            check(copy, 9, 59, 30, 40);
291            
292            copy = test.minuteOfHour().addToCopy(-(10 * 60 + 20));
293            check(copy, 0, 0, 30, 40);
294            
295            copy = test.minuteOfHour().addToCopy(-(10 * 60 + 21));
296            check(copy, 23, 59, 30, 40);
297        }
298    
299        public void testPropertyAddNoWrapMinute() {
300            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
301            TimeOfDay copy = test.minuteOfHour().addNoWrapToCopy(9);
302            check(test, 10, 20, 30, 40);
303            check(copy, 10, 29, 30, 40);
304            
305            copy = test.minuteOfHour().addNoWrapToCopy(39);
306            check(copy, 10, 59, 30, 40);
307            
308            copy = test.minuteOfHour().addNoWrapToCopy(40);
309            check(copy, 11, 0, 30, 40);
310            
311            copy = test.minuteOfHour().addNoWrapToCopy(1 * 60 + 45);
312            check(copy, 12, 5, 30, 40);
313            
314            copy = test.minuteOfHour().addNoWrapToCopy(13 * 60 + 39);
315            check(copy, 23, 59, 30, 40);
316            
317            try {
318                test.minuteOfHour().addNoWrapToCopy(13 * 60 + 40);
319                fail();
320            } catch (IllegalArgumentException ex) {}
321            check(test, 10, 20, 30, 40);
322            
323            copy = test.minuteOfHour().addNoWrapToCopy(-9);
324            check(copy, 10, 11, 30, 40);
325            
326            copy = test.minuteOfHour().addNoWrapToCopy(-19);
327            check(copy, 10, 1, 30, 40);
328            
329            copy = test.minuteOfHour().addNoWrapToCopy(-20);
330            check(copy, 10, 0, 30, 40);
331            
332            copy = test.minuteOfHour().addNoWrapToCopy(-21);
333            check(copy, 9, 59, 30, 40);
334            
335            copy = test.minuteOfHour().addNoWrapToCopy(-(10 * 60 + 20));
336            check(copy, 0, 0, 30, 40);
337            
338            try {
339                test.minuteOfHour().addNoWrapToCopy(-(10 * 60 + 21));
340                fail();
341            } catch (IllegalArgumentException ex) {}
342            check(test, 10, 20, 30, 40);
343        }
344    
345        public void testPropertyAddWrapFieldMinute() {
346            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
347            TimeOfDay copy = test.minuteOfHour().addWrapFieldToCopy(9);
348            check(test, 10, 20, 30, 40);
349            check(copy, 10, 29, 30, 40);
350            
351            copy = test.minuteOfHour().addWrapFieldToCopy(49);
352            check(copy, 10, 9, 30, 40);
353            
354            copy = test.minuteOfHour().addWrapFieldToCopy(-47);
355            check(copy, 10, 33, 30, 40);
356        }
357    
358        public void testPropertySetMinute() {
359            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
360            TimeOfDay copy = test.minuteOfHour().setCopy(12);
361            check(test, 10, 20, 30, 40);
362            check(copy, 10, 12, 30, 40);
363            
364            try {
365                test.minuteOfHour().setCopy(60);
366                fail();
367            } catch (IllegalArgumentException ex) {}
368            try {
369                test.minuteOfHour().setCopy(-1);
370                fail();
371            } catch (IllegalArgumentException ex) {}
372        }
373    
374        public void testPropertySetTextMinute() {
375            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
376            TimeOfDay copy = test.minuteOfHour().setCopy("12");
377            check(test, 10, 20, 30, 40);
378            check(copy, 10, 12, 30, 40);
379        }
380    
381        public void testPropertyCompareToMinute() {
382            TimeOfDay test1 = new TimeOfDay(TEST_TIME1);
383            TimeOfDay test2 = new TimeOfDay(TEST_TIME2);
384            assertEquals(true, test1.minuteOfHour().compareTo(test2) < 0);
385            assertEquals(true, test2.minuteOfHour().compareTo(test1) > 0);
386            assertEquals(true, test1.minuteOfHour().compareTo(test1) == 0);
387            try {
388                test1.minuteOfHour().compareTo((ReadablePartial) null);
389                fail();
390            } catch (IllegalArgumentException ex) {}
391            
392            DateTime dt1 = new DateTime(TEST_TIME1);
393            DateTime dt2 = new DateTime(TEST_TIME2);
394            assertEquals(true, test1.minuteOfHour().compareTo(dt2) < 0);
395            assertEquals(true, test2.minuteOfHour().compareTo(dt1) > 0);
396            assertEquals(true, test1.minuteOfHour().compareTo(dt1) == 0);
397            try {
398                test1.minuteOfHour().compareTo((ReadableInstant) null);
399                fail();
400            } catch (IllegalArgumentException ex) {}
401        }
402    
403        //-----------------------------------------------------------------------
404        public void testPropertyGetSecond() {
405            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
406            assertSame(test.getChronology().secondOfMinute(), test.secondOfMinute().getField());
407            assertEquals("secondOfMinute", test.secondOfMinute().getName());
408            assertEquals("Property[secondOfMinute]", test.secondOfMinute().toString());
409            assertSame(test, test.secondOfMinute().getReadablePartial());
410            assertSame(test, test.secondOfMinute().getTimeOfDay());
411            assertEquals(30, test.secondOfMinute().get());
412            assertEquals("30", test.secondOfMinute().getAsString());
413            assertEquals("30", test.secondOfMinute().getAsText());
414            assertEquals("30", test.secondOfMinute().getAsText(Locale.FRENCH));
415            assertEquals("30", test.secondOfMinute().getAsShortText());
416            assertEquals("30", test.secondOfMinute().getAsShortText(Locale.FRENCH));
417            assertEquals(test.getChronology().seconds(), test.secondOfMinute().getDurationField());
418            assertEquals(test.getChronology().minutes(), test.secondOfMinute().getRangeDurationField());
419            assertEquals(2, test.secondOfMinute().getMaximumTextLength(null));
420            assertEquals(2, test.secondOfMinute().getMaximumShortTextLength(null));
421        }
422    
423        public void testPropertyGetMaxMinValuesSecond() {
424            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
425            assertEquals(0, test.secondOfMinute().getMinimumValue());
426            assertEquals(0, test.secondOfMinute().getMinimumValueOverall());
427            assertEquals(59, test.secondOfMinute().getMaximumValue());
428            assertEquals(59, test.secondOfMinute().getMaximumValueOverall());
429        }
430    
431        public void testPropertyAddSecond() {
432            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
433            TimeOfDay copy = test.secondOfMinute().addToCopy(9);
434            check(test, 10, 20, 30, 40);
435            check(copy, 10, 20, 39, 40);
436            
437            copy = test.secondOfMinute().addToCopy(29);
438            check(copy, 10, 20, 59, 40);
439            
440            copy = test.secondOfMinute().addToCopy(30);
441            check(copy, 10, 21, 0, 40);
442            
443            copy = test.secondOfMinute().addToCopy(39 * 60 + 29);
444            check(copy, 10, 59, 59, 40);
445            
446            copy = test.secondOfMinute().addToCopy(39 * 60 + 30);
447            check(copy, 11, 0, 0, 40);
448            
449            copy = test.secondOfMinute().addToCopy(13 * 60 * 60 + 39 * 60 + 30);
450            check(copy, 0, 0, 0, 40);
451            
452            copy = test.secondOfMinute().addToCopy(-9);
453            check(copy, 10, 20, 21, 40);
454            
455            copy = test.secondOfMinute().addToCopy(-30);
456            check(copy, 10, 20, 0, 40);
457            
458            copy = test.secondOfMinute().addToCopy(-31);
459            check(copy, 10, 19, 59, 40);
460            
461            copy = test.secondOfMinute().addToCopy(-(10 * 60 * 60 + 20 * 60 + 30));
462            check(copy, 0, 0, 0, 40);
463            
464            copy = test.secondOfMinute().addToCopy(-(10 * 60 * 60 + 20 * 60 + 31));
465            check(copy, 23, 59, 59, 40);
466        }
467    
468        public void testPropertyAddNoWrapSecond() {
469            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
470            TimeOfDay copy = test.secondOfMinute().addNoWrapToCopy(9);
471            check(test, 10, 20, 30, 40);
472            check(copy, 10, 20, 39, 40);
473            
474            copy = test.secondOfMinute().addNoWrapToCopy(29);
475            check(copy, 10, 20, 59, 40);
476            
477            copy = test.secondOfMinute().addNoWrapToCopy(30);
478            check(copy, 10, 21, 0, 40);
479            
480            copy = test.secondOfMinute().addNoWrapToCopy(39 * 60 + 29);
481            check(copy, 10, 59, 59, 40);
482            
483            copy = test.secondOfMinute().addNoWrapToCopy(39 * 60 + 30);
484            check(copy, 11, 0, 0, 40);
485            
486            try {
487                test.secondOfMinute().addNoWrapToCopy(13 * 60 * 60 + 39 * 60 + 30);
488                fail();
489            } catch (IllegalArgumentException ex) {}
490            check(test, 10, 20, 30, 40);
491            
492            copy = test.secondOfMinute().addNoWrapToCopy(-9);
493            check(copy, 10, 20, 21, 40);
494            
495            copy = test.secondOfMinute().addNoWrapToCopy(-30);
496            check(copy, 10, 20, 0, 40);
497            
498            copy = test.secondOfMinute().addNoWrapToCopy(-31);
499            check(copy, 10, 19, 59, 40);
500            
501            copy = test.secondOfMinute().addNoWrapToCopy(-(10 * 60 * 60 + 20 * 60 + 30));
502            check(copy, 0, 0, 0, 40);
503            
504            try {
505                test.secondOfMinute().addNoWrapToCopy(-(10 * 60 * 60 + 20 * 60 + 31));
506                fail();
507            } catch (IllegalArgumentException ex) {}
508            check(test, 10, 20, 30, 40);
509        }
510    
511        public void testPropertyAddWrapFieldSecond() {
512            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
513            TimeOfDay copy = test.secondOfMinute().addWrapFieldToCopy(9);
514            check(test, 10, 20, 30, 40);
515            check(copy, 10, 20, 39, 40);
516            
517            copy = test.secondOfMinute().addWrapFieldToCopy(49);
518            check(copy, 10, 20, 19, 40);
519            
520            copy = test.secondOfMinute().addWrapFieldToCopy(-47);
521            check(copy, 10, 20, 43, 40);
522        }
523    
524        public void testPropertySetSecond() {
525            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
526            TimeOfDay copy = test.secondOfMinute().setCopy(12);
527            check(test, 10, 20, 30, 40);
528            check(copy, 10, 20, 12, 40);
529            
530            try {
531                test.secondOfMinute().setCopy(60);
532                fail();
533            } catch (IllegalArgumentException ex) {}
534            try {
535                test.secondOfMinute().setCopy(-1);
536                fail();
537            } catch (IllegalArgumentException ex) {}
538        }
539    
540        public void testPropertySetTextSecond() {
541            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
542            TimeOfDay copy = test.secondOfMinute().setCopy("12");
543            check(test, 10, 20, 30, 40);
544            check(copy, 10, 20, 12, 40);
545        }
546    
547        public void testPropertyCompareToSecond() {
548            TimeOfDay test1 = new TimeOfDay(TEST_TIME1);
549            TimeOfDay test2 = new TimeOfDay(TEST_TIME2);
550            assertEquals(true, test1.secondOfMinute().compareTo(test2) < 0);
551            assertEquals(true, test2.secondOfMinute().compareTo(test1) > 0);
552            assertEquals(true, test1.secondOfMinute().compareTo(test1) == 0);
553            try {
554                test1.secondOfMinute().compareTo((ReadablePartial) null);
555                fail();
556            } catch (IllegalArgumentException ex) {}
557            
558            DateTime dt1 = new DateTime(TEST_TIME1);
559            DateTime dt2 = new DateTime(TEST_TIME2);
560            assertEquals(true, test1.secondOfMinute().compareTo(dt2) < 0);
561            assertEquals(true, test2.secondOfMinute().compareTo(dt1) > 0);
562            assertEquals(true, test1.secondOfMinute().compareTo(dt1) == 0);
563            try {
564                test1.secondOfMinute().compareTo((ReadableInstant) null);
565                fail();
566            } catch (IllegalArgumentException ex) {}
567        }
568    
569        //-----------------------------------------------------------------------
570        public void testPropertyGetMilli() {
571            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
572            assertSame(test.getChronology().millisOfSecond(), test.millisOfSecond().getField());
573            assertEquals("millisOfSecond", test.millisOfSecond().getName());
574            assertEquals("Property[millisOfSecond]", test.millisOfSecond().toString());
575            assertSame(test, test.millisOfSecond().getReadablePartial());
576            assertSame(test, test.millisOfSecond().getTimeOfDay());
577            assertEquals(40, test.millisOfSecond().get());
578            assertEquals("40", test.millisOfSecond().getAsString());
579            assertEquals("40", test.millisOfSecond().getAsText());
580            assertEquals("40", test.millisOfSecond().getAsText(Locale.FRENCH));
581            assertEquals("40", test.millisOfSecond().getAsShortText());
582            assertEquals("40", test.millisOfSecond().getAsShortText(Locale.FRENCH));
583            assertEquals(test.getChronology().millis(), test.millisOfSecond().getDurationField());
584            assertEquals(test.getChronology().seconds(), test.millisOfSecond().getRangeDurationField());
585            assertEquals(3, test.millisOfSecond().getMaximumTextLength(null));
586            assertEquals(3, test.millisOfSecond().getMaximumShortTextLength(null));
587        }
588    
589        public void testPropertyGetMaxMinValuesMilli() {
590            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
591            assertEquals(0, test.millisOfSecond().getMinimumValue());
592            assertEquals(0, test.millisOfSecond().getMinimumValueOverall());
593            assertEquals(999, test.millisOfSecond().getMaximumValue());
594            assertEquals(999, test.millisOfSecond().getMaximumValueOverall());
595        }
596    
597        public void testPropertyAddMilli() {
598            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
599            TimeOfDay copy = test.millisOfSecond().addToCopy(9);
600            check(test, 10, 20, 30, 40);
601            check(copy, 10, 20, 30, 49);
602            
603            copy = test.millisOfSecond().addToCopy(959);
604            check(copy, 10, 20, 30, 999);
605            
606            copy = test.millisOfSecond().addToCopy(960);
607            check(copy, 10, 20, 31, 0);
608            
609            copy = test.millisOfSecond().addToCopy(13 * 60 * 60 * 1000 + 39 * 60 * 1000 + 29 * 1000 + 959);
610            check(copy, 23, 59, 59, 999);
611            
612            copy = test.millisOfSecond().addToCopy(13 * 60 * 60 * 1000 + 39 * 60 * 1000 + 29 * 1000 + 960);
613            check(copy, 0, 0, 0, 0);
614            
615            copy = test.millisOfSecond().addToCopy(-9);
616            check(copy, 10, 20, 30, 31);
617            
618            copy = test.millisOfSecond().addToCopy(-40);
619            check(copy, 10, 20, 30, 0);
620            
621            copy = test.millisOfSecond().addToCopy(-41);
622            check(copy, 10, 20, 29, 999);
623            
624            copy = test.millisOfSecond().addToCopy(-(10 * 60 * 60 * 1000 + 20 * 60 * 1000 + 30 * 1000 + 40));
625            check(copy, 0, 0, 0, 0);
626            
627            copy = test.millisOfSecond().addToCopy(-(10 * 60 * 60 * 1000 + 20 * 60 * 1000 + 30 * 1000 + 41));
628            check(copy, 23, 59, 59, 999);
629        }
630    
631        public void testPropertyAddNoWrapMilli() {
632            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
633            TimeOfDay copy = test.millisOfSecond().addNoWrapToCopy(9);
634            check(test, 10, 20, 30, 40);
635            check(copy, 10, 20, 30, 49);
636            
637            copy = test.millisOfSecond().addNoWrapToCopy(959);
638            check(copy, 10, 20, 30, 999);
639            
640            copy = test.millisOfSecond().addNoWrapToCopy(960);
641            check(copy, 10, 20, 31, 0);
642            
643            copy = test.millisOfSecond().addNoWrapToCopy(13 * 60 * 60 * 1000 + 39 * 60 * 1000 + 29 * 1000 + 959);
644            check(copy, 23, 59, 59, 999);
645            
646            try {
647                test.millisOfSecond().addNoWrapToCopy(13 * 60 * 60 * 1000 + 39 * 60 * 1000 + 29 * 1000 + 960);
648                fail();
649            } catch (IllegalArgumentException ex) {}
650            check(test, 10, 20, 30, 40);
651            
652            copy = test.millisOfSecond().addNoWrapToCopy(-9);
653            check(copy, 10, 20, 30, 31);
654            
655            copy = test.millisOfSecond().addNoWrapToCopy(-40);
656            check(copy, 10, 20, 30, 0);
657            
658            copy = test.millisOfSecond().addNoWrapToCopy(-41);
659            check(copy, 10, 20, 29, 999);
660            
661            copy = test.millisOfSecond().addNoWrapToCopy(-(10 * 60 * 60 * 1000 + 20 * 60 * 1000 + 30 * 1000 + 40));
662            check(copy, 0, 0, 0, 0);
663            
664            try {
665                test.millisOfSecond().addNoWrapToCopy(-(10 * 60 * 60 * 1000 + 20 * 60 * 1000 + 30 * 1000 + 41));
666                fail();
667            } catch (IllegalArgumentException ex) {}
668            check(test, 10, 20, 30, 40);
669        }
670    
671        public void testPropertyAddWrapFieldMilli() {
672            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
673            TimeOfDay copy = test.millisOfSecond().addWrapFieldToCopy(9);
674            check(test, 10, 20, 30, 40);
675            check(copy, 10, 20, 30, 49);
676            
677            copy = test.millisOfSecond().addWrapFieldToCopy(995);
678            check(copy, 10, 20, 30, 35);
679            
680            copy = test.millisOfSecond().addWrapFieldToCopy(-47);
681            check(copy, 10, 20, 30, 993);
682        }
683    
684        public void testPropertySetMilli() {
685            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
686            TimeOfDay copy = test.millisOfSecond().setCopy(12);
687            check(test, 10, 20, 30, 40);
688            check(copy, 10, 20, 30, 12);
689            
690            try {
691                test.millisOfSecond().setCopy(1000);
692                fail();
693            } catch (IllegalArgumentException ex) {}
694            try {
695                test.millisOfSecond().setCopy(-1);
696                fail();
697            } catch (IllegalArgumentException ex) {}
698        }
699    
700        public void testPropertySetTextMilli() {
701            TimeOfDay test = new TimeOfDay(10, 20, 30, 40);
702            TimeOfDay copy = test.millisOfSecond().setCopy("12");
703            check(test, 10, 20, 30, 40);
704            check(copy, 10, 20, 30, 12);
705        }
706    
707        public void testPropertyCompareToMilli() {
708            TimeOfDay test1 = new TimeOfDay(TEST_TIME1);
709            TimeOfDay test2 = new TimeOfDay(TEST_TIME2);
710            assertEquals(true, test1.millisOfSecond().compareTo(test2) < 0);
711            assertEquals(true, test2.millisOfSecond().compareTo(test1) > 0);
712            assertEquals(true, test1.millisOfSecond().compareTo(test1) == 0);
713            try {
714                test1.millisOfSecond().compareTo((ReadablePartial) null);
715                fail();
716            } catch (IllegalArgumentException ex) {}
717            
718            DateTime dt1 = new DateTime(TEST_TIME1);
719            DateTime dt2 = new DateTime(TEST_TIME2);
720            assertEquals(true, test1.millisOfSecond().compareTo(dt2) < 0);
721            assertEquals(true, test2.millisOfSecond().compareTo(dt1) > 0);
722            assertEquals(true, test1.millisOfSecond().compareTo(dt1) == 0);
723            try {
724                test1.millisOfSecond().compareTo((ReadableInstant) null);
725                fail();
726            } catch (IllegalArgumentException ex) {}
727        }
728    
729        //-----------------------------------------------------------------------
730        private void check(TimeOfDay test, int hour, int min, int sec, int milli) {
731            assertEquals(hour, test.getHourOfDay());
732            assertEquals(min, test.getMinuteOfHour());
733            assertEquals(sec, test.getSecondOfMinute());
734            assertEquals(milli, test.getMillisOfSecond());
735        }
736    }