001    /*
002     *  Copyright 2001-2009 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 junit.framework.TestCase;
019    import junit.framework.TestSuite;
020    
021    import org.joda.time.base.BaseSingleFieldPeriod;
022    
023    /**
024     * This class is a Junit unit test for BaseSingleFieldPeriod.
025     *
026     * @author Stephen Colebourne
027     */
028    public class TestBaseSingleFieldPeriod extends TestCase {
029        // Test in 2002/03 as time zones are more well known
030        // (before the late 90's they were all over the place)
031        private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris");
032    
033        public static void main(String[] args) {
034            junit.textui.TestRunner.run(suite());
035        }
036    
037        public static TestSuite suite() {
038            return new TestSuite(TestBaseSingleFieldPeriod.class);
039        }
040    
041        public TestBaseSingleFieldPeriod(String name) {
042            super(name);
043        }
044    
045        protected void setUp() throws Exception {
046        }
047    
048        protected void tearDown() throws Exception {
049        }
050    
051        //-----------------------------------------------------------------------
052        public void testFactory_between_RInstant() {
053            // test using Days
054            DateTime start = new DateTime(2006, 6, 9, 12, 0, 0, 0, PARIS);
055            DateTime end1 = new DateTime(2006, 6, 12, 12, 0, 0, 0, PARIS);
056            DateTime end2 = new DateTime(2006, 6, 15, 18, 0, 0, 0, PARIS);
057            
058            assertEquals(3, Single.between(start, end1, DurationFieldType.days()));
059            assertEquals(0, Single.between(start, start, DurationFieldType.days()));
060            assertEquals(0, Single.between(end1, end1, DurationFieldType.days()));
061            assertEquals(-3, Single.between(end1, start, DurationFieldType.days()));
062            assertEquals(6, Single.between(start, end2, DurationFieldType.days()));
063            try {
064                Single.between(start, (ReadableInstant) null, DurationFieldType.days());
065                fail();
066            } catch (IllegalArgumentException ex) {
067                // expected
068            }
069            try {
070                Single.between((ReadableInstant) null, end1, DurationFieldType.days());
071                fail();
072            } catch (IllegalArgumentException ex) {
073                // expected
074            }
075            try {
076                Single.between((ReadableInstant) null, (ReadableInstant) null, DurationFieldType.days());
077                fail();
078            } catch (IllegalArgumentException ex) {
079                // expected
080            }
081        }
082    
083        public void testFactory_between_RPartial() {
084            LocalDate start = new LocalDate(2006, 6, 9);
085            LocalDate end1 = new LocalDate(2006, 6, 12);
086            YearMonthDay end2 = new YearMonthDay(2006, 6, 15);
087            
088            Single zero = new Single(0);
089            assertEquals(3, Single.between(start, end1, zero));
090            assertEquals(0, Single.between(start, start, zero));
091            assertEquals(0, Single.between(end1, end1, zero));
092            assertEquals(-3, Single.between(end1, start, zero));
093            assertEquals(6, Single.between(start, end2, zero));
094            try {
095                Single.between(start, (ReadablePartial) null, zero);
096                fail();
097            } catch (IllegalArgumentException ex) {
098                // expected
099            }
100            try {
101                Single.between((ReadablePartial) null, end1, zero);
102                fail();
103            } catch (IllegalArgumentException ex) {
104                // expected
105            }
106            try {
107                Single.between((ReadablePartial) null, (ReadablePartial) null, zero);
108                fail();
109            } catch (IllegalArgumentException ex) {
110                // expected
111            }
112            try {
113                Single.between(start, new LocalTime(), zero);
114                fail();
115            } catch (IllegalArgumentException ex) {
116                // expected
117            }
118            try {
119                Single.between(new Partial(DateTimeFieldType.dayOfWeek(), 2), new Partial(DateTimeFieldType.dayOfMonth(), 3), zero);
120                fail();
121            } catch (IllegalArgumentException ex) {
122                // expected
123            }
124            Partial p = new Partial(
125                    new DateTimeFieldType[] {DateTimeFieldType.year(), DateTimeFieldType.hourOfDay()},
126                    new int[] {1, 2});
127            try {
128                Single.between(p, p, zero);
129                fail();
130            } catch (IllegalArgumentException ex) {
131                // expected
132            }
133        }
134    
135        public void testFactory_standardPeriodIn_RPeriod() {
136            assertEquals(0, Single.standardPeriodIn((ReadablePeriod) null, DateTimeConstants.MILLIS_PER_DAY));
137            assertEquals(0, Single.standardPeriodIn(Period.ZERO, DateTimeConstants.MILLIS_PER_DAY));
138            assertEquals(1, Single.standardPeriodIn(new Period(0, 0, 0, 1, 0, 0, 0, 0), DateTimeConstants.MILLIS_PER_DAY));
139            assertEquals(123, Single.standardPeriodIn(Period.days(123), DateTimeConstants.MILLIS_PER_DAY));
140            assertEquals(-987, Single.standardPeriodIn(Period.days(-987), DateTimeConstants.MILLIS_PER_DAY));
141            assertEquals(1, Single.standardPeriodIn(Period.hours(47), DateTimeConstants.MILLIS_PER_DAY));
142            assertEquals(2, Single.standardPeriodIn(Period.hours(48), DateTimeConstants.MILLIS_PER_DAY));
143            assertEquals(2, Single.standardPeriodIn(Period.hours(49), DateTimeConstants.MILLIS_PER_DAY));
144            assertEquals(14, Single.standardPeriodIn(Period.weeks(2), DateTimeConstants.MILLIS_PER_DAY));
145            try {
146                Single.standardPeriodIn(Period.months(1), DateTimeConstants.MILLIS_PER_DAY);
147                fail();
148            } catch (IllegalArgumentException ex) {
149                // expeceted
150            }
151        }
152    
153        //-----------------------------------------------------------------------
154        public void testValueIndexMethods() {
155            Single test = new Single(20);
156            assertEquals(1, test.size());
157            assertEquals(20, test.getValue(0));
158            try {
159                test.getValue(1);
160                fail();
161            } catch (IndexOutOfBoundsException ex) {
162                // expected
163            }
164        }
165    
166        public void testFieldTypeIndexMethods() {
167            Single test = new Single(20);
168            assertEquals(1, test.size());
169            assertEquals(DurationFieldType.days(), test.getFieldType(0));
170            try {
171                test.getFieldType(1);
172                fail();
173            } catch (IndexOutOfBoundsException ex) {
174                // expected
175            }
176        }
177    
178        public void testIsSupported() {
179            Single test = new Single(20);
180            assertEquals(false, test.isSupported(DurationFieldType.years()));
181            assertEquals(false, test.isSupported(DurationFieldType.months()));
182            assertEquals(false, test.isSupported(DurationFieldType.weeks()));
183            assertEquals(true, test.isSupported(DurationFieldType.days()));
184            assertEquals(false, test.isSupported(DurationFieldType.hours()));
185            assertEquals(false, test.isSupported(DurationFieldType.minutes()));
186            assertEquals(false, test.isSupported(DurationFieldType.seconds()));
187            assertEquals(false, test.isSupported(DurationFieldType.millis()));
188        }        
189    
190        public void testGet() {
191            Single test = new Single(20);
192            assertEquals(0, test.get(DurationFieldType.years()));
193            assertEquals(0, test.get(DurationFieldType.months()));
194            assertEquals(0, test.get(DurationFieldType.weeks()));
195            assertEquals(20, test.get(DurationFieldType.days()));
196            assertEquals(0, test.get(DurationFieldType.hours()));
197            assertEquals(0, test.get(DurationFieldType.minutes()));
198            assertEquals(0, test.get(DurationFieldType.seconds()));
199            assertEquals(0, test.get(DurationFieldType.millis()));
200        }
201    
202        //-----------------------------------------------------------------------
203        public void testEqualsHashCode() {
204            Single testA = new Single(20);
205            Single testB = new Single(20);
206            assertEquals(true, testA.equals(testB));
207            assertEquals(true, testB.equals(testA));
208            assertEquals(true, testA.equals(testA));
209            assertEquals(true, testB.equals(testB));
210            assertEquals(true, testA.hashCode() == testB.hashCode());
211            assertEquals(true, testA.hashCode() == testA.hashCode());
212            assertEquals(true, testB.hashCode() == testB.hashCode());
213            
214            Single testC = new Single(30);
215            assertEquals(false, testA.equals(testC));
216            assertEquals(false, testB.equals(testC));
217            assertEquals(false, testC.equals(testA));
218            assertEquals(false, testC.equals(testB));
219            assertEquals(false, testA.hashCode() == testC.hashCode());
220            assertEquals(false, testB.hashCode() == testC.hashCode());
221            
222            assertEquals(true, testA.equals(Days.days(20)));
223            assertEquals(true, testA.equals(new Period(0, 0, 0, 20, 0, 0, 0, 0, PeriodType.days())));
224            assertEquals(false, testA.equals(Period.days(2)));
225            assertEquals(false, testA.equals("Hello"));
226            assertEquals(false, testA.equals(Hours.hours(2)));
227            assertEquals(false, testA.equals(null));
228        }
229    
230        public void testCompareTo() {
231            Single test1 = new Single(21);
232            Single test2 = new Single(22);
233            Single test3 = new Single(23);
234            assertEquals(true, test1.compareTo(test1) == 0);
235            assertEquals(true, test1.compareTo(test2) < 0);
236            assertEquals(true, test1.compareTo(test3) < 0);
237            assertEquals(true, test2.compareTo(test1) > 0);
238            assertEquals(true, test2.compareTo(test2) == 0);
239            assertEquals(true, test2.compareTo(test3) < 0);
240            assertEquals(true, test3.compareTo(test1) > 0);
241            assertEquals(true, test3.compareTo(test2) > 0);
242            assertEquals(true, test3.compareTo(test3) == 0);
243            
244    //        try {
245    //            test1.compareTo("Hello");
246    //            fail();
247    //        } catch (ClassCastException ex) {
248    //            // expected
249    //        }
250    //        try {
251    //            test1.compareTo(new Period(0, 0, 0, 21, 0, 0, 0, 0, PeriodType.days()));
252    //            fail();
253    //        } catch (ClassCastException ex) {
254    //            // expected
255    //        }
256            try {
257                test1.compareTo(null);
258                fail();
259            } catch (NullPointerException ex) {
260                // expected
261            }
262        }
263    
264        //-----------------------------------------------------------------------
265        public void testToPeriod() {
266            Single test = new Single(20);
267            Period expected = Period.days(20);
268            assertEquals(expected, test.toPeriod());
269        }
270    
271        public void testToMutablePeriod() {
272            Single test = new Single(20);
273            MutablePeriod expected = new MutablePeriod(0, 0, 0, 20, 0, 0, 0, 0);
274            assertEquals(expected, test.toMutablePeriod());
275        }
276    
277    //    public void testToDurationFrom() {
278    //        Period test = new Period(123L);
279    //        assertEquals(new Duration(123L), test.toDurationFrom(new Instant(0L)));
280    //    }
281    //
282    //    public void testToDurationTo() {
283    //        Period test = new Period(123L);
284    //        assertEquals(new Duration(123L), test.toDurationTo(new Instant(123L)));
285    //    }
286    //
287    
288        //-----------------------------------------------------------------------
289        public void testGetSetValue() {
290            Single test = new Single(20);
291            assertEquals(20, test.getValue());
292            test.setValue(10);
293            assertEquals(10, test.getValue());
294        }
295    
296        //-----------------------------------------------------------------------
297        /** Test class. */
298        static class Single extends BaseSingleFieldPeriod {
299    
300            public Single(int period) {
301                super(period);
302            }
303            
304            public static int between(ReadableInstant start, ReadableInstant end, DurationFieldType field) {
305                return BaseSingleFieldPeriod.between(start, end, field);
306            }
307            
308            public static int between(ReadablePartial start, ReadablePartial end, ReadablePeriod zeroInstance) {
309                return BaseSingleFieldPeriod.between(start, end, zeroInstance);
310            }
311            
312            public static int standardPeriodIn(ReadablePeriod period, long millisPerUnit) {
313                return BaseSingleFieldPeriod.standardPeriodIn(period, millisPerUnit);
314            }
315            
316            public DurationFieldType getFieldType() {
317                return DurationFieldType.days();
318            }
319    
320            public PeriodType getPeriodType() {
321                return PeriodType.days();
322            }
323            
324            public int getValue() {
325                return super.getValue();
326            }
327            
328            public void setValue(int value) {
329                super.setValue(value);
330            }
331        }
332    
333    }