001    /*
002     *  Copyright 2001-2006 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.io.ByteArrayInputStream;
019    import java.io.ByteArrayOutputStream;
020    import java.io.ObjectInputStream;
021    import java.io.ObjectOutputStream;
022    
023    import junit.framework.TestCase;
024    import junit.framework.TestSuite;
025    
026    /**
027     * This class is a Junit unit test for Weeks.
028     *
029     * @author Stephen Colebourne
030     */
031    public class TestWeeks extends TestCase {
032        // Test in 2002/03 as time zones are more well known
033        // (before the late 90's they were all over the place)
034        private static final DateTimeZone PARIS = DateTimeZone.forID("Europe/Paris");
035    
036        public static void main(String[] args) {
037            junit.textui.TestRunner.run(suite());
038        }
039    
040        public static TestSuite suite() {
041            return new TestSuite(TestWeeks.class);
042        }
043    
044        public TestWeeks(String name) {
045            super(name);
046        }
047    
048        protected void setUp() throws Exception {
049        }
050    
051        protected void tearDown() throws Exception {
052        }
053    
054        //-----------------------------------------------------------------------
055        public void testConstants() {
056            assertEquals(0, Weeks.ZERO.getWeeks());
057            assertEquals(1, Weeks.ONE.getWeeks());
058            assertEquals(2, Weeks.TWO.getWeeks());
059            assertEquals(3, Weeks.THREE.getWeeks());
060            assertEquals(Integer.MAX_VALUE, Weeks.MAX_VALUE.getWeeks());
061            assertEquals(Integer.MIN_VALUE, Weeks.MIN_VALUE.getWeeks());
062        }
063    
064        //-----------------------------------------------------------------------
065        public void testFactory_weeks_int() {
066            assertSame(Weeks.ZERO, Weeks.weeks(0));
067            assertSame(Weeks.ONE, Weeks.weeks(1));
068            assertSame(Weeks.TWO, Weeks.weeks(2));
069            assertSame(Weeks.THREE, Weeks.weeks(3));
070            assertSame(Weeks.MAX_VALUE, Weeks.weeks(Integer.MAX_VALUE));
071            assertSame(Weeks.MIN_VALUE, Weeks.weeks(Integer.MIN_VALUE));
072            assertEquals(-1, Weeks.weeks(-1).getWeeks());
073            assertEquals(4, Weeks.weeks(4).getWeeks());
074        }
075    
076        //-----------------------------------------------------------------------
077        public void testFactory_weeksBetween_RInstant() {
078            DateTime start = new DateTime(2006, 6, 9, 12, 0, 0, 0, PARIS);
079            DateTime end1 = new DateTime(2006, 6, 30, 12, 0, 0, 0, PARIS);
080            DateTime end2 = new DateTime(2006, 7, 21, 12, 0, 0, 0, PARIS);
081            
082            assertEquals(3, Weeks.weeksBetween(start, end1).getWeeks());
083            assertEquals(0, Weeks.weeksBetween(start, start).getWeeks());
084            assertEquals(0, Weeks.weeksBetween(end1, end1).getWeeks());
085            assertEquals(-3, Weeks.weeksBetween(end1, start).getWeeks());
086            assertEquals(6, Weeks.weeksBetween(start, end2).getWeeks());
087        }
088    
089        public void testFactory_weeksBetween_RPartial() {
090            LocalDate start = new LocalDate(2006, 6, 9);
091            LocalDate end1 = new LocalDate(2006, 6, 30);
092            YearMonthDay end2 = new YearMonthDay(2006, 7, 21);
093            
094            assertEquals(3, Weeks.weeksBetween(start, end1).getWeeks());
095            assertEquals(0, Weeks.weeksBetween(start, start).getWeeks());
096            assertEquals(0, Weeks.weeksBetween(end1, end1).getWeeks());
097            assertEquals(-3, Weeks.weeksBetween(end1, start).getWeeks());
098            assertEquals(6, Weeks.weeksBetween(start, end2).getWeeks());
099        }
100    
101        public void testFactory_weeksIn_RInterval() {
102            DateTime start = new DateTime(2006, 6, 9, 12, 0, 0, 0, PARIS);
103            DateTime end1 = new DateTime(2006, 6, 30, 12, 0, 0, 0, PARIS);
104            DateTime end2 = new DateTime(2006, 7, 21, 12, 0, 0, 0, PARIS);
105            
106            assertEquals(0, Weeks.weeksIn((ReadableInterval) null).getWeeks());
107            assertEquals(3, Weeks.weeksIn(new Interval(start, end1)).getWeeks());
108            assertEquals(0, Weeks.weeksIn(new Interval(start, start)).getWeeks());
109            assertEquals(0, Weeks.weeksIn(new Interval(end1, end1)).getWeeks());
110            assertEquals(6, Weeks.weeksIn(new Interval(start, end2)).getWeeks());
111        }
112    
113        public void testFactory_standardWeeksIn_RPeriod() {
114            assertEquals(0, Weeks.standardWeeksIn((ReadablePeriod) null).getWeeks());
115            assertEquals(0, Weeks.standardWeeksIn(Period.ZERO).getWeeks());
116            assertEquals(1, Weeks.standardWeeksIn(new Period(0, 0, 1, 0, 0, 0, 0, 0)).getWeeks());
117            assertEquals(123, Weeks.standardWeeksIn(Period.weeks(123)).getWeeks());
118            assertEquals(-987, Weeks.standardWeeksIn(Period.weeks(-987)).getWeeks());
119            assertEquals(1, Weeks.standardWeeksIn(Period.days(13)).getWeeks());
120            assertEquals(2, Weeks.standardWeeksIn(Period.days(14)).getWeeks());
121            assertEquals(2, Weeks.standardWeeksIn(Period.days(15)).getWeeks());
122            try {
123                Weeks.standardWeeksIn(Period.months(1));
124                fail();
125            } catch (IllegalArgumentException ex) {
126                // expeceted
127            }
128        }
129    
130        public void testFactory_parseWeeks_String() {
131            assertEquals(0, Weeks.parseWeeks((String) null).getWeeks());
132            assertEquals(0, Weeks.parseWeeks("P0W").getWeeks());
133            assertEquals(1, Weeks.parseWeeks("P1W").getWeeks());
134            assertEquals(-3, Weeks.parseWeeks("P-3W").getWeeks());
135            assertEquals(2, Weeks.parseWeeks("P0Y0M2W").getWeeks());
136            assertEquals(2, Weeks.parseWeeks("P2WT0H0M").getWeeks());
137            try {
138                Weeks.parseWeeks("P1Y1D");
139                fail();
140            } catch (IllegalArgumentException ex) {
141                // expeceted
142            }
143            try {
144                Weeks.parseWeeks("P1WT1H");
145                fail();
146            } catch (IllegalArgumentException ex) {
147                // expeceted
148            }
149        }
150    
151        //-----------------------------------------------------------------------
152        public void testGetMethods() {
153            Weeks test = Weeks.weeks(20);
154            assertEquals(20, test.getWeeks());
155        }
156    
157        public void testGetFieldType() {
158            Weeks test = Weeks.weeks(20);
159            assertEquals(DurationFieldType.weeks(), test.getFieldType());
160        }
161    
162        public void testGetPeriodType() {
163            Weeks test = Weeks.weeks(20);
164            assertEquals(PeriodType.weeks(), test.getPeriodType());
165        }
166    
167        //-----------------------------------------------------------------------
168        public void testIsGreaterThan() {
169            assertEquals(true, Weeks.THREE.isGreaterThan(Weeks.TWO));
170            assertEquals(false, Weeks.THREE.isGreaterThan(Weeks.THREE));
171            assertEquals(false, Weeks.TWO.isGreaterThan(Weeks.THREE));
172            assertEquals(true, Weeks.ONE.isGreaterThan(null));
173            assertEquals(false, Weeks.weeks(-1).isGreaterThan(null));
174        }
175    
176        public void testIsLessThan() {
177            assertEquals(false, Weeks.THREE.isLessThan(Weeks.TWO));
178            assertEquals(false, Weeks.THREE.isLessThan(Weeks.THREE));
179            assertEquals(true, Weeks.TWO.isLessThan(Weeks.THREE));
180            assertEquals(false, Weeks.ONE.isLessThan(null));
181            assertEquals(true, Weeks.weeks(-1).isLessThan(null));
182        }
183    
184        //-----------------------------------------------------------------------
185        public void testToString() {
186            Weeks test = Weeks.weeks(20);
187            assertEquals("P20W", test.toString());
188            
189            test = Weeks.weeks(-20);
190            assertEquals("P-20W", test.toString());
191        }
192    
193        //-----------------------------------------------------------------------
194        public void testSerialization() throws Exception {
195            Weeks test = Weeks.THREE;
196            
197            ByteArrayOutputStream baos = new ByteArrayOutputStream();
198            ObjectOutputStream oos = new ObjectOutputStream(baos);
199            oos.writeObject(test);
200            byte[] bytes = baos.toByteArray();
201            oos.close();
202            
203            ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
204            ObjectInputStream ois = new ObjectInputStream(bais);
205            Weeks result = (Weeks) ois.readObject();
206            ois.close();
207            
208            assertSame(test, result);
209        }
210    
211        //-----------------------------------------------------------------------
212        public void testToStandardDays() {
213            Weeks test = Weeks.weeks(2);
214            Days expected = Days.days(14);
215            assertEquals(expected, test.toStandardDays());
216            
217            try {
218                Weeks.MAX_VALUE.toStandardDays();
219                fail();
220            } catch (ArithmeticException ex) {
221                // expected
222            }
223        }
224    
225        public void testToStandardHours() {
226            Weeks test = Weeks.weeks(2);
227            Hours expected = Hours.hours(2 * 7 * 24);
228            assertEquals(expected, test.toStandardHours());
229            
230            try {
231                Weeks.MAX_VALUE.toStandardHours();
232                fail();
233            } catch (ArithmeticException ex) {
234                // expected
235            }
236        }
237    
238        public void testToStandardMinutes() {
239            Weeks test = Weeks.weeks(2);
240            Minutes expected = Minutes.minutes(2 * 7 * 24 * 60);
241            assertEquals(expected, test.toStandardMinutes());
242            
243            try {
244                Weeks.MAX_VALUE.toStandardMinutes();
245                fail();
246            } catch (ArithmeticException ex) {
247                // expected
248            }
249        }
250    
251        public void testToStandardSeconds() {
252            Weeks test = Weeks.weeks(2);
253            Seconds expected = Seconds.seconds(2 * 7 * 24 * 60 * 60);
254            assertEquals(expected, test.toStandardSeconds());
255            
256            try {
257                Weeks.MAX_VALUE.toStandardSeconds();
258                fail();
259            } catch (ArithmeticException ex) {
260                // expected
261            }
262        }
263    
264        public void testToStandardDuration() {
265            Weeks test = Weeks.weeks(20);
266            Duration expected = new Duration(20L * DateTimeConstants.MILLIS_PER_WEEK);
267            assertEquals(expected, test.toStandardDuration());
268            
269            expected = new Duration(((long) Integer.MAX_VALUE) * DateTimeConstants.MILLIS_PER_WEEK);
270            assertEquals(expected, Weeks.MAX_VALUE.toStandardDuration());
271        }
272    
273        //-----------------------------------------------------------------------
274        public void testPlus_int() {
275            Weeks test2 = Weeks.weeks(2);
276            Weeks result = test2.plus(3);
277            assertEquals(2, test2.getWeeks());
278            assertEquals(5, result.getWeeks());
279            
280            assertEquals(1, Weeks.ONE.plus(0).getWeeks());
281            
282            try {
283                Weeks.MAX_VALUE.plus(1);
284                fail();
285            } catch (ArithmeticException ex) {
286                // expected
287            }
288        }
289    
290        public void testPlus_Weeks() {
291            Weeks test2 = Weeks.weeks(2);
292            Weeks test3 = Weeks.weeks(3);
293            Weeks result = test2.plus(test3);
294            assertEquals(2, test2.getWeeks());
295            assertEquals(3, test3.getWeeks());
296            assertEquals(5, result.getWeeks());
297            
298            assertEquals(1, Weeks.ONE.plus(Weeks.ZERO).getWeeks());
299            assertEquals(1, Weeks.ONE.plus((Weeks) null).getWeeks());
300            
301            try {
302                Weeks.MAX_VALUE.plus(Weeks.ONE);
303                fail();
304            } catch (ArithmeticException ex) {
305                // expected
306            }
307        }
308    
309        public void testMinus_int() {
310            Weeks test2 = Weeks.weeks(2);
311            Weeks result = test2.minus(3);
312            assertEquals(2, test2.getWeeks());
313            assertEquals(-1, result.getWeeks());
314            
315            assertEquals(1, Weeks.ONE.minus(0).getWeeks());
316            
317            try {
318                Weeks.MIN_VALUE.minus(1);
319                fail();
320            } catch (ArithmeticException ex) {
321                // expected
322            }
323        }
324    
325        public void testMinus_Weeks() {
326            Weeks test2 = Weeks.weeks(2);
327            Weeks test3 = Weeks.weeks(3);
328            Weeks result = test2.minus(test3);
329            assertEquals(2, test2.getWeeks());
330            assertEquals(3, test3.getWeeks());
331            assertEquals(-1, result.getWeeks());
332            
333            assertEquals(1, Weeks.ONE.minus(Weeks.ZERO).getWeeks());
334            assertEquals(1, Weeks.ONE.minus((Weeks) null).getWeeks());
335            
336            try {
337                Weeks.MIN_VALUE.minus(Weeks.ONE);
338                fail();
339            } catch (ArithmeticException ex) {
340                // expected
341            }
342        }
343    
344        public void testMultipliedBy_int() {
345            Weeks test = Weeks.weeks(2);
346            assertEquals(6, test.multipliedBy(3).getWeeks());
347            assertEquals(2, test.getWeeks());
348            assertEquals(-6, test.multipliedBy(-3).getWeeks());
349            assertSame(test, test.multipliedBy(1));
350            
351            Weeks halfMax = Weeks.weeks(Integer.MAX_VALUE / 2 + 1);
352            try {
353                halfMax.multipliedBy(2);
354                fail();
355            } catch (ArithmeticException ex) {
356                // expected
357            }
358        }
359    
360        public void testDividedBy_int() {
361            Weeks test = Weeks.weeks(12);
362            assertEquals(6, test.dividedBy(2).getWeeks());
363            assertEquals(12, test.getWeeks());
364            assertEquals(4, test.dividedBy(3).getWeeks());
365            assertEquals(3, test.dividedBy(4).getWeeks());
366            assertEquals(2, test.dividedBy(5).getWeeks());
367            assertEquals(2, test.dividedBy(6).getWeeks());
368            assertSame(test, test.dividedBy(1));
369            
370            try {
371                Weeks.ONE.dividedBy(0);
372                fail();
373            } catch (ArithmeticException ex) {
374                // expected
375            }
376        }
377    
378        public void testNegated() {
379            Weeks test = Weeks.weeks(12);
380            assertEquals(-12, test.negated().getWeeks());
381            assertEquals(12, test.getWeeks());
382            
383            try {
384                Weeks.MIN_VALUE.negated();
385                fail();
386            } catch (ArithmeticException ex) {
387                // expected
388            }
389        }
390    
391        //-----------------------------------------------------------------------
392        public void testAddToLocalDate() {
393            Weeks test = Weeks.weeks(3);
394            LocalDate date = new LocalDate(2006, 6, 1);
395            LocalDate expected = new LocalDate(2006, 6, 22);
396            assertEquals(expected, date.plus(test));
397        }
398    
399    }