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.field;
017    
018    import java.util.Arrays;
019    import java.util.Locale;
020    
021    import junit.framework.TestCase;
022    import junit.framework.TestSuite;
023    
024    import org.joda.time.Chronology;
025    import org.joda.time.DateTimeField;
026    import org.joda.time.DateTimeFieldType;
027    import org.joda.time.DurationField;
028    import org.joda.time.DurationFieldType;
029    import org.joda.time.TimeOfDay;
030    import org.joda.time.base.BasePartial;
031    import org.joda.time.chrono.ISOChronology;
032    
033    /**
034     * This class is a Junit unit test for BaseDateTimeField.
035     *
036     * @author Stephen Colebourne
037     */
038    public class TestBaseDateTimeField extends TestCase {
039    
040        public static void main(String[] args) {
041            junit.textui.TestRunner.run(suite());
042        }
043    
044        public static TestSuite suite() {
045            return new TestSuite(TestBaseDateTimeField.class);
046        }
047    
048        public TestBaseDateTimeField(String name) {
049            super(name);
050        }
051    
052        protected void setUp() throws Exception {
053        }
054    
055        protected void tearDown() throws Exception {
056        }
057    
058        //-----------------------------------------------------------------------
059        public void test_constructor() {
060            BaseDateTimeField field = new MockBaseDateTimeField();
061            assertEquals(DateTimeFieldType.secondOfMinute(), field.getType());
062            try {
063                field = new MockBaseDateTimeField(null);
064                fail();
065            } catch (IllegalArgumentException ex) {}
066        }
067    
068        public void test_getType() {
069            BaseDateTimeField field = new MockBaseDateTimeField(DateTimeFieldType.secondOfDay());
070            assertEquals(DateTimeFieldType.secondOfDay(), field.getType());
071        }
072    
073        public void test_getName() {
074            BaseDateTimeField field = new MockBaseDateTimeField(DateTimeFieldType.secondOfDay());
075            assertEquals("secondOfDay", field.getName());
076        }
077    
078        public void test_toString() {
079            BaseDateTimeField field = new MockBaseDateTimeField(DateTimeFieldType.secondOfDay());
080            assertEquals("DateTimeField[secondOfDay]", field.toString());
081        }
082    
083        public void test_isSupported() {
084            BaseDateTimeField field = new MockBaseDateTimeField();
085            assertEquals(true, field.isSupported());
086        }
087    
088        public void test_get() {
089            BaseDateTimeField field = new MockBaseDateTimeField();
090            assertEquals(0, field.get(0));
091            assertEquals(1, field.get(60));
092            assertEquals(2, field.get(123));
093        }
094    
095        //-----------------------------------------------------------------------
096        public void test_getAsText_long_Locale() {
097            BaseDateTimeField field = new MockBaseDateTimeField();
098            assertEquals("29", field.getAsText(60L * 29, Locale.ENGLISH));
099            assertEquals("29", field.getAsText(60L * 29, null));
100        }
101    
102        public void test_getAsText_long() {
103            BaseDateTimeField field = new MockBaseDateTimeField();
104            assertEquals("29", field.getAsText(60L * 29));
105        }
106    
107        public void test_getAsText_RP_int_Locale() {
108            BaseDateTimeField field = new MockBaseDateTimeField();
109            assertEquals("20", field.getAsText(new TimeOfDay(12, 30, 40, 50), 20, Locale.ENGLISH));
110            assertEquals("20", field.getAsText(new TimeOfDay(12, 30, 40, 50), 20, null));
111        }
112    
113        public void test_getAsText_RP_Locale() {
114            BaseDateTimeField field = new MockBaseDateTimeField();
115            assertEquals("40", field.getAsText(new TimeOfDay(12, 30, 40, 50), Locale.ENGLISH));
116            assertEquals("40", field.getAsText(new TimeOfDay(12, 30, 40, 50), null));
117        }
118    
119        public void test_getAsText_int_Locale() {
120            BaseDateTimeField field = new MockBaseDateTimeField();
121            assertEquals("80", field.getAsText(80, Locale.ENGLISH));
122            assertEquals("80", field.getAsText(80, null));
123        }
124    
125        //-----------------------------------------------------------------------
126        public void test_getAsShortText_long_Locale() {
127            BaseDateTimeField field = new MockBaseDateTimeField();
128            assertEquals("29", field.getAsShortText(60L * 29, Locale.ENGLISH));
129            assertEquals("29", field.getAsShortText(60L * 29, null));
130        }
131    
132        public void test_getAsShortText_long() {
133            BaseDateTimeField field = new MockBaseDateTimeField();
134            assertEquals("29", field.getAsShortText(60L * 29));
135        }
136    
137        public void test_getAsShortText_RP_int_Locale() {
138            BaseDateTimeField field = new MockBaseDateTimeField();
139            assertEquals("20", field.getAsShortText(new TimeOfDay(12, 30, 40, 50), 20, Locale.ENGLISH));
140            assertEquals("20", field.getAsShortText(new TimeOfDay(12, 30, 40, 50), 20, null));
141        }
142    
143        public void test_getAsShortText_RP_Locale() {
144            BaseDateTimeField field = new MockBaseDateTimeField();
145            assertEquals("40", field.getAsShortText(new TimeOfDay(12, 30, 40, 50), Locale.ENGLISH));
146            assertEquals("40", field.getAsShortText(new TimeOfDay(12, 30, 40, 50), null));
147        }
148    
149        public void test_getAsShortText_int_Locale() {
150            BaseDateTimeField field = new MockBaseDateTimeField();
151            assertEquals("80", field.getAsShortText(80, Locale.ENGLISH));
152            assertEquals("80", field.getAsShortText(80, null));
153        }
154    
155        //-----------------------------------------------------------------------
156        public void test_add_long_int() {
157            MockCountingDurationField.add_int = 0;
158            BaseDateTimeField field = new MockBaseDateTimeField();
159            assertEquals(61, field.add(1L, 1));
160            assertEquals(1, MockCountingDurationField.add_int);
161        }
162    
163        public void test_add_long_long() {
164            MockCountingDurationField.add_long = 0;
165            BaseDateTimeField field = new MockBaseDateTimeField();
166            assertEquals(61, field.add(1L, 1L));
167            assertEquals(1, MockCountingDurationField.add_long);
168        }
169    
170        public void test_add_RP_int_intarray_int() {
171            int[] values = new int[] {10, 20, 30, 40};
172            int[] expected = new int[] {10, 20, 30, 40};
173            BaseDateTimeField field = new MockStandardBaseDateTimeField();
174            int[] result = field.add(new TimeOfDay(), 2, values, 0);
175            assertEquals(true, Arrays.equals(expected, result));
176            
177            values = new int[] {10, 20, 30, 40};
178            expected = new int[] {10, 20, 31, 40};
179            result = field.add(new TimeOfDay(), 2, values, 1);
180            assertEquals(true, Arrays.equals(expected, result));
181            
182            values = new int[] {10, 20, 30, 40};
183            expected = new int[] {10, 21, 0, 40};
184            result = field.add(new TimeOfDay(), 2, values, 30);
185            assertEquals(true, Arrays.equals(expected, result));
186            
187            values = new int[] {23, 59, 30, 40};
188            try {
189                field.add(new TimeOfDay(), 2, values, 30);
190                fail();
191            } catch (IllegalArgumentException ex) {}
192            
193            values = new int[] {10, 20, 30, 40};
194            expected = new int[] {10, 20, 29, 40};
195            result = field.add(new TimeOfDay(), 2, values, -1);
196            assertEquals(true, Arrays.equals(expected, result));
197            
198            values = new int[] {10, 20, 30, 40};
199            expected = new int[] {10, 19, 59, 40};
200            result = field.add(new TimeOfDay(), 2, values, -31);
201            assertEquals(true, Arrays.equals(expected, result));
202            
203            values = new int[] {0, 0, 30, 40};
204            try {
205                field.add(new TimeOfDay(), 2, values, -31);
206                fail();
207            } catch (IllegalArgumentException ex) {}
208            
209            values = new int[] {0, 0};
210            try {
211                field.add(new MockPartial(), 0, values, 1000);
212                fail();
213            } catch (IllegalArgumentException ex) {}
214            
215            values = new int[] {1, 0};
216            try {
217                field.add(new MockPartial(), 0, values, -1000);
218                fail();
219            } catch (IllegalArgumentException ex) {}
220        }
221    
222        //-----------------------------------------------------------------------
223        public void test_addWrapField_long_int() {
224            BaseDateTimeField field = new MockBaseDateTimeField();
225            assertEquals(1029, field.addWrapField(60L * 29, 0));
226            assertEquals(1059, field.addWrapField(60L * 29, 30));
227            assertEquals(1000, field.addWrapField(60L * 29, 31));
228        }
229    
230        public void test_addWrapField_RP_int_intarray_int() {
231            BaseDateTimeField field = new MockBaseDateTimeField();
232            int[] values = new int[] {10, 20, 30, 40};
233            int[] expected = new int[] {10, 20, 30, 40};
234            int[] result = field.addWrapField(new TimeOfDay(), 2, values, 0);
235            assertEquals(true, Arrays.equals(result, expected));
236            
237            values = new int[] {10, 20, 30, 40};
238            expected = new int[] {10, 20, 59, 40};
239            result = field.addWrapField(new TimeOfDay(), 2, values, 29);
240            assertEquals(true, Arrays.equals(result, expected));
241            
242            values = new int[] {10, 20, 30, 40};
243            expected = new int[] {10, 20, 0, 40};
244            result = field.addWrapField(new TimeOfDay(), 2, values, 30);
245            assertEquals(true, Arrays.equals(result, expected));
246            
247            values = new int[] {10, 20, 30, 40};
248            expected = new int[] {10, 20, 1, 40};
249            result = field.addWrapField(new TimeOfDay(), 2, values, 31);
250            assertEquals(true, Arrays.equals(result, expected));
251        }
252    
253        //-----------------------------------------------------------------------
254        public void test_getDifference_long_long() {
255            MockCountingDurationField.difference_long = 0;
256            BaseDateTimeField field = new MockBaseDateTimeField();
257            assertEquals(30, field.getDifference(0L, 0L));
258            assertEquals(1, MockCountingDurationField.difference_long);
259        }
260    
261        public void test_getDifferenceAsLong_long_long() {
262            MockCountingDurationField.difference_long = 0;
263            BaseDateTimeField field = new MockBaseDateTimeField();
264            assertEquals(30, field.getDifferenceAsLong(0L, 0L));
265            assertEquals(1, MockCountingDurationField.difference_long);
266        }
267    
268        //-----------------------------------------------------------------------
269        public void test_set_long_int() {
270            BaseDateTimeField field = new MockBaseDateTimeField();
271            assertEquals(1000, field.set(0L, 0));
272            assertEquals(1029, field.set(0L, 29));
273        }
274    
275        public void test_set_RP_int_intarray_int() {
276            BaseDateTimeField field = new MockBaseDateTimeField();
277            int[] values = new int[] {10, 20, 30, 40};
278            int[] expected = new int[] {10, 20, 30, 40};
279            int[] result = field.set(new TimeOfDay(), 2, values, 30);
280            assertEquals(true, Arrays.equals(result, expected));
281            
282            values = new int[] {10, 20, 30, 40};
283            expected = new int[] {10, 20, 29, 40};
284            result = field.set(new TimeOfDay(), 2, values, 29);
285            assertEquals(true, Arrays.equals(result, expected));
286            
287            values = new int[] {10, 20, 30, 40};
288            expected = new int[] {10, 20, 30, 40};
289            try {
290                field.set(new TimeOfDay(), 2, values, 60);
291                fail();
292            } catch (IllegalArgumentException ex) {}
293            assertEquals(true, Arrays.equals(values, expected));
294            
295            values = new int[] {10, 20, 30, 40};
296            expected = new int[] {10, 20, 30, 40};
297            try {
298                field.set(new TimeOfDay(), 2, values, -1);
299                fail();
300            } catch (IllegalArgumentException ex) {}
301            assertEquals(true, Arrays.equals(values, expected));
302        }
303    
304        public void test_set_long_String_Locale() {
305            BaseDateTimeField field = new MockBaseDateTimeField();
306            assertEquals(1000, field.set(0L, "0", null));
307            assertEquals(1029, field.set(0L, "29", Locale.ENGLISH));
308        }
309    
310        public void test_set_long_String() {
311            BaseDateTimeField field = new MockBaseDateTimeField();
312            assertEquals(1000, field.set(0L, "0"));
313            assertEquals(1029, field.set(0L, "29"));
314        }
315    
316        public void test_set_RP_int_intarray_String_Locale() {
317            BaseDateTimeField field = new MockBaseDateTimeField();
318            int[] values = new int[] {10, 20, 30, 40};
319            int[] expected = new int[] {10, 20, 30, 40};
320            int[] result = field.set(new TimeOfDay(), 2, values, "30", null);
321            assertEquals(true, Arrays.equals(result, expected));
322            
323            values = new int[] {10, 20, 30, 40};
324            expected = new int[] {10, 20, 29, 40};
325            result = field.set(new TimeOfDay(), 2, values, "29", Locale.ENGLISH);
326            assertEquals(true, Arrays.equals(result, expected));
327            
328            values = new int[] {10, 20, 30, 40};
329            expected = new int[] {10, 20, 30, 40};
330            try {
331                field.set(new TimeOfDay(), 2, values, "60", null);
332                fail();
333            } catch (IllegalArgumentException ex) {}
334            assertEquals(true, Arrays.equals(values, expected));
335            
336            values = new int[] {10, 20, 30, 40};
337            expected = new int[] {10, 20, 30, 40};
338            try {
339                field.set(new TimeOfDay(), 2, values, "-1", null);
340                fail();
341            } catch (IllegalArgumentException ex) {}
342            assertEquals(true, Arrays.equals(values, expected));
343        }
344    
345        public void test_convertText() {
346            BaseDateTimeField field = new MockBaseDateTimeField();
347            assertEquals(0, field.convertText("0", null));
348            assertEquals(29, field.convertText("29", null));
349            try {
350                field.convertText("2A", null);
351                fail();
352            } catch (IllegalArgumentException ex) {}
353            try {
354                field.convertText(null, null);
355                fail();
356            } catch (IllegalArgumentException ex) {}
357        }
358    
359        //------------------------------------------------------------------------
360    //    public abstract DurationField getDurationField();
361    //
362    //    public abstract DurationField getRangeDurationField();
363    
364        public void test_isLeap_long() {
365            BaseDateTimeField field = new MockBaseDateTimeField();
366            assertEquals(false, field.isLeap(0L));
367        }
368    
369        public void test_getLeapAmount_long() {
370            BaseDateTimeField field = new MockBaseDateTimeField();
371            assertEquals(0, field.getLeapAmount(0L));
372        }
373    
374        public void test_getLeapDurationField() {
375            BaseDateTimeField field = new MockBaseDateTimeField();
376            assertEquals(null, field.getLeapDurationField());
377        }
378    
379        //-----------------------------------------------------------------------
380        public void test_getMinimumValue() {
381            BaseDateTimeField field = new MockBaseDateTimeField();
382            assertEquals(0, field.getMinimumValue());
383        }
384    
385        public void test_getMinimumValue_long() {
386            BaseDateTimeField field = new MockBaseDateTimeField();
387            assertEquals(0, field.getMinimumValue(0L));
388        }
389    
390        public void test_getMinimumValue_RP() {
391            BaseDateTimeField field = new MockBaseDateTimeField();
392            assertEquals(0, field.getMinimumValue(new TimeOfDay()));
393        }
394    
395        public void test_getMinimumValue_RP_intarray() {
396            BaseDateTimeField field = new MockBaseDateTimeField();
397            assertEquals(0, field.getMinimumValue(new TimeOfDay(), new int[4]));
398        }
399    
400        public void test_getMaximumValue() {
401            BaseDateTimeField field = new MockBaseDateTimeField();
402            assertEquals(59, field.getMaximumValue());
403        }
404    
405        public void test_getMaximumValue_long() {
406            BaseDateTimeField field = new MockBaseDateTimeField();
407            assertEquals(59, field.getMaximumValue(0L));
408        }
409    
410        public void test_getMaximumValue_RP() {
411            BaseDateTimeField field = new MockBaseDateTimeField();
412            assertEquals(59, field.getMaximumValue(new TimeOfDay()));
413        }
414    
415        public void test_getMaximumValue_RP_intarray() {
416            BaseDateTimeField field = new MockBaseDateTimeField();
417            assertEquals(59, field.getMaximumValue(new TimeOfDay(), new int[4]));
418        }
419    
420        //-----------------------------------------------------------------------
421        public void test_getMaximumTextLength_Locale() {
422            BaseDateTimeField field = new MockBaseDateTimeField();
423            assertEquals(2, field.getMaximumTextLength(Locale.ENGLISH));
424    
425            field = new MockBaseDateTimeField() {
426                public int getMaximumValue() {
427                    return 5;
428                }
429            };
430            assertEquals(1, field.getMaximumTextLength(Locale.ENGLISH));
431            
432            field = new MockBaseDateTimeField() {
433                public int getMaximumValue() {
434                    return 555;
435                }
436            };
437            assertEquals(3, field.getMaximumTextLength(Locale.ENGLISH));
438            
439            field = new MockBaseDateTimeField() {
440                public int getMaximumValue() {
441                    return 5555;
442                }
443            };
444            assertEquals(4, field.getMaximumTextLength(Locale.ENGLISH));
445            
446            field = new MockBaseDateTimeField() {
447                public int getMaximumValue() {
448                    return -1;
449                }
450            };
451            assertEquals(2, field.getMaximumTextLength(Locale.ENGLISH));
452        }
453    
454        public void test_getMaximumShortTextLength_Locale() {
455            BaseDateTimeField field = new MockBaseDateTimeField();
456            assertEquals(2, field.getMaximumShortTextLength(Locale.ENGLISH));
457        }
458    
459        //------------------------------------------------------------------------
460        public void test_roundFloor_long() {
461            BaseDateTimeField field = new MockBaseDateTimeField();
462            assertEquals(0L, field.roundFloor(0L));
463            assertEquals(0L, field.roundFloor(29L));
464            assertEquals(0L, field.roundFloor(30L));
465            assertEquals(0L, field.roundFloor(31L));
466            assertEquals(60L, field.roundFloor(60L));
467        }
468    
469        public void test_roundCeiling_long() {
470            BaseDateTimeField field = new MockBaseDateTimeField();
471            assertEquals(0L, field.roundCeiling(0L));
472            assertEquals(60L, field.roundCeiling(29L));
473            assertEquals(60L, field.roundCeiling(30L));
474            assertEquals(60L, field.roundCeiling(31L));
475            assertEquals(60L, field.roundCeiling(60L));
476        }
477    
478        public void test_roundHalfFloor_long() {
479            BaseDateTimeField field = new MockBaseDateTimeField();
480            assertEquals(0L, field.roundHalfFloor(0L));
481            assertEquals(0L, field.roundHalfFloor(29L));
482            assertEquals(0L, field.roundHalfFloor(30L));
483            assertEquals(60L, field.roundHalfFloor(31L));
484            assertEquals(60L, field.roundHalfFloor(60L));
485        }
486    
487        public void test_roundHalfCeiling_long() {
488            BaseDateTimeField field = new MockBaseDateTimeField();
489            assertEquals(0L, field.roundHalfCeiling(0L));
490            assertEquals(0L, field.roundHalfCeiling(29L));
491            assertEquals(60L, field.roundHalfCeiling(30L));
492            assertEquals(60L, field.roundHalfCeiling(31L));
493            assertEquals(60L, field.roundHalfCeiling(60L));
494        }
495    
496        public void test_roundHalfEven_long() {
497            BaseDateTimeField field = new MockBaseDateTimeField();
498            assertEquals(0L, field.roundHalfEven(0L));
499            assertEquals(0L, field.roundHalfEven(29L));
500            assertEquals(0L, field.roundHalfEven(30L));
501            assertEquals(60L, field.roundHalfEven(31L));
502            assertEquals(60L, field.roundHalfEven(60L));
503            assertEquals(60L, field.roundHalfEven(89L));
504            assertEquals(120L, field.roundHalfEven(90L));
505            assertEquals(120L, field.roundHalfEven(91L));
506        }
507    
508        public void test_remainder_long() {
509            BaseDateTimeField field = new MockBaseDateTimeField();
510            assertEquals(0L, field.remainder(0L));
511            assertEquals(29L, field.remainder(29L));
512            assertEquals(30L, field.remainder(30L));
513            assertEquals(31L, field.remainder(31L));
514            assertEquals(0L, field.remainder(60L));
515        }
516    
517        //-----------------------------------------------------------------------
518        static class MockBaseDateTimeField extends BaseDateTimeField {
519            protected MockBaseDateTimeField() {
520                super(DateTimeFieldType.secondOfMinute());
521            }
522            protected MockBaseDateTimeField(DateTimeFieldType type) {
523                super(type);
524            }
525            public int get(long instant) {
526                return (int) (instant / 60L);
527            }
528            public long set(long instant, int value) {
529                return 1000 + value;
530            }
531            public DurationField getDurationField() {
532                return new MockCountingDurationField(DurationFieldType.seconds());
533            }
534            public DurationField getRangeDurationField() {
535                return new MockCountingDurationField(DurationFieldType.minutes());
536            }
537            public int getMinimumValue() {
538                return 0;
539            }
540            public int getMaximumValue() {
541                return 59;
542            }
543            public long roundFloor(long instant) {
544                return (instant / 60L) * 60L;
545            }
546            public boolean isLenient() {
547                return false;
548            }
549        }
550    
551        static class MockStandardBaseDateTimeField extends MockBaseDateTimeField {
552            protected MockStandardBaseDateTimeField() {
553                super();
554            }
555            public DurationField getDurationField() {
556                return ISOChronology.getInstanceUTC().seconds();
557            }
558            public DurationField getRangeDurationField() {
559                return ISOChronology.getInstanceUTC().minutes();
560            }
561        }
562    
563        //-----------------------------------------------------------------------
564        static class MockCountingDurationField extends BaseDurationField {
565            static int add_int = 0;
566            static int add_long = 0;
567            static int difference_long = 0;
568            
569            protected MockCountingDurationField(DurationFieldType type) {
570                super(type);
571            }
572            public boolean isPrecise() {
573                return false;
574            }
575            public long getUnitMillis() {
576                return 0;
577            }
578            public long getValueAsLong(long duration, long instant) {
579                return 0;
580            }
581            public long getMillis(int value, long instant) {
582                return 0;
583            }
584            public long getMillis(long value, long instant) {
585                return 0;
586            }
587            public long add(long instant, int value) {
588                add_int++;
589                return instant + (value * 60L);
590            }
591            public long add(long instant, long value) {
592                add_long++;
593                return instant + (value * 60L);
594            }
595            public long getDifferenceAsLong(long minuendInstant, long subtrahendInstant) {
596                difference_long++;
597                return 30;
598            }
599        }
600    
601        static class MockPartial extends BasePartial {
602            protected DateTimeField getField(int index, Chronology chrono) {
603                if (index == 0) {
604                    return ISOChronology.getInstanceUTC().minuteOfHour();
605                }
606                if (index == 1) {
607                    return ISOChronology.getInstanceUTC().millisOfSecond();
608                }
609                return null;
610            }
611            public int size() {
612                return 2;
613            }
614            
615        }
616    }