KickJava   Java API By Example, From Geeks To Geeks.

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


1 /*
2  * Copyright 2001-2005 Stephen Colebourne
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */

16 package org.joda.time;
17
18 import java.io.ByteArrayInputStream JavaDoc;
19 import java.io.ByteArrayOutputStream JavaDoc;
20 import java.io.ObjectInputStream JavaDoc;
21 import java.io.ObjectOutputStream JavaDoc;
22 import java.lang.reflect.Modifier JavaDoc;
23 import java.util.ArrayList JavaDoc;
24 import java.util.Calendar JavaDoc;
25 import java.util.Collections JavaDoc;
26 import java.util.Comparator JavaDoc;
27 import java.util.Date JavaDoc;
28 import java.util.List JavaDoc;
29
30 import junit.framework.TestCase;
31 import junit.framework.TestSuite;
32
33 import org.joda.time.chrono.ISOChronology;
34 /**
35  * This class is a Junit unit test for the
36  * org.joda.time.DateTimeComparator class.
37  *
38  * @author Guy Allard
39  */

40 public class TestDateTimeComparator extends TestCase {
41
42     private static final Chronology ISO = ISOChronology.getInstance();
43     
44     public static void main(String JavaDoc[] args) {
45         junit.textui.TestRunner.run(suite());
46     }
47
48     public static TestSuite suite() {
49         return new TestSuite(TestDateTimeComparator.class);
50     }
51
52     public TestDateTimeComparator(String JavaDoc name) {
53         super(name);
54     }
55
56     /**
57      * A reference to a DateTime object.
58      */

59     DateTime aDateTime = null;
60     /**
61      * A reference to a DateTime object.
62      */

63     DateTime bDateTime = null;
64     /**
65      * A reference to a DateTimeComparator object
66      * (a Comparator) for millis of seconds.
67      */

68     Comparator JavaDoc cMillis = null;
69     /**
70      * A reference to a DateTimeComparator object
71      * (a Comparator) for seconds.
72      */

73     Comparator JavaDoc cSecond = null;
74     /**
75      * A reference to a DateTimeComparator object
76      * (a Comparator) for minutes.
77      */

78     Comparator JavaDoc cMinute = null;
79     /**
80      * A reference to a DateTimeComparator object
81      * (a Comparator) for hours.
82      */

83     Comparator JavaDoc cHour = null;
84     /**
85      * A reference to a DateTimeComparator object
86      * (a Comparator) for day of the week.
87      */

88     Comparator JavaDoc cDayOfWeek = null;
89     /**
90      * A reference to a DateTimeComparator object
91      * (a Comparator) for day of the month.
92      */

93     Comparator JavaDoc cDayOfMonth = null;
94     /**
95      * A reference to a DateTimeComparator object
96      * (a Comparator) for day of the year.
97      */

98     Comparator JavaDoc cDayOfYear = null;
99     /**
100      * A reference to a DateTimeComparator object
101      * (a Comparator) for week of the weekyear.
102      */

103     Comparator JavaDoc cWeekOfWeekyear = null;
104     /**
105      * A reference to a DateTimeComparator object
106      * (a Comparator) for year given a week of the year.
107      */

108     Comparator JavaDoc cWeekyear = null;
109     /**
110      * A reference to a DateTimeComparator object
111      * (a Comparator) for months.
112      */

113     Comparator JavaDoc cMonth = null;
114     /**
115      * A reference to a DateTimeComparator object
116      * (a Comparator) for year.
117      */

118     Comparator JavaDoc cYear = null;
119     /**
120      * A reference to a DateTimeComparator object
121      * (a Comparator) for the date portion of an
122      * object.
123      */

124     Comparator JavaDoc cDate = null;
125     /**
126      * A reference to a DateTimeComparator object
127      * (a Comparator) for the time portion of an
128      * object.
129      */

130     Comparator JavaDoc cTime = null;
131     /**
132      * Junit <code>setUp()</code> method.
133      */

134     public void setUp() /* throws Exception */ {
135         Chronology chrono = ISOChronology.getInstanceUTC();
136
137         // super.setUp();
138
// Obtain comparator's
139
cMillis = DateTimeComparator.getInstance(null, DateTimeFieldType.secondOfMinute());
140         cSecond = DateTimeComparator.getInstance(DateTimeFieldType.secondOfMinute(), DateTimeFieldType.minuteOfHour());
141         cMinute = DateTimeComparator.getInstance(DateTimeFieldType.minuteOfHour(), DateTimeFieldType.hourOfDay());
142         cHour = DateTimeComparator.getInstance(DateTimeFieldType.hourOfDay(), DateTimeFieldType.dayOfYear());
143         cDayOfWeek = DateTimeComparator.getInstance(DateTimeFieldType.dayOfWeek(), DateTimeFieldType.weekOfWeekyear());
144         cDayOfMonth = DateTimeComparator.getInstance(DateTimeFieldType.dayOfMonth(), DateTimeFieldType.monthOfYear());
145         cDayOfYear = DateTimeComparator.getInstance(DateTimeFieldType.dayOfYear(), DateTimeFieldType.year());
146         cWeekOfWeekyear = DateTimeComparator.getInstance(DateTimeFieldType.weekOfWeekyear(), DateTimeFieldType.weekyear());
147         cWeekyear = DateTimeComparator.getInstance(DateTimeFieldType.weekyear());
148         cMonth = DateTimeComparator.getInstance(DateTimeFieldType.monthOfYear(), DateTimeFieldType.year());
149         cYear = DateTimeComparator.getInstance(DateTimeFieldType.year());
150         cDate = DateTimeComparator.getDateOnlyInstance();
151         cTime = DateTimeComparator.getTimeOnlyInstance();
152     }
153
154     /**
155      * Junit <code>tearDown()</code> method.
156      */

157     protected void tearDown() /* throws Exception */ {
158         // super.tearDown();
159
aDateTime = null;
160         bDateTime = null;
161         //
162
cMillis = null;
163         cSecond = null;
164         cMinute = null;
165         cHour = null;
166         cDayOfWeek = null;
167         cDayOfMonth = null;
168         cDayOfYear = null;
169         cWeekOfWeekyear = null;
170         cWeekyear = null;
171         cMonth = null;
172         cYear = null;
173         cDate = null;
174         cTime = null;
175     }
176
177     //-----------------------------------------------------------------------
178
public void testClass() {
179         assertEquals(true, Modifier.isPublic(DateTimeComparator.class.getModifiers()));
180         assertEquals(false, Modifier.isFinal(DateTimeComparator.class.getModifiers()));
181         assertEquals(1, DateTimeComparator.class.getDeclaredConstructors().length);
182         assertEquals(true, Modifier.isProtected(DateTimeComparator.class.getDeclaredConstructors()[0].getModifiers()));
183     }
184     
185     //-----------------------------------------------------------------------
186
public void testStaticGetInstance() {
187         DateTimeComparator c = DateTimeComparator.getInstance();
188         assertEquals(null, c.getLowerLimit());
189         assertEquals(null, c.getUpperLimit());
190         assertEquals("DateTimeComparator[]", c.toString());
191     }
192     public void testStaticGetDateOnlyInstance() {
193         DateTimeComparator c = DateTimeComparator.getDateOnlyInstance();
194         assertEquals(DateTimeFieldType.dayOfYear(), c.getLowerLimit());
195         assertEquals(null, c.getUpperLimit());
196         assertEquals("DateTimeComparator[dayOfYear-]", c.toString());
197         
198         assertSame(DateTimeComparator.getDateOnlyInstance(), DateTimeComparator.getDateOnlyInstance());
199     }
200     public void testStaticGetTimeOnlyInstance() {
201         DateTimeComparator c = DateTimeComparator.getTimeOnlyInstance();
202         assertEquals(null, c.getLowerLimit());
203         assertEquals(DateTimeFieldType.dayOfYear(), c.getUpperLimit());
204         assertEquals("DateTimeComparator[-dayOfYear]", c.toString());
205         
206         assertSame(DateTimeComparator.getTimeOnlyInstance(), DateTimeComparator.getTimeOnlyInstance());
207     }
208     public void testStaticGetInstanceLower() {
209         DateTimeComparator c = DateTimeComparator.getInstance(DateTimeFieldType.hourOfDay());
210         assertEquals(DateTimeFieldType.hourOfDay(), c.getLowerLimit());
211         assertEquals(null, c.getUpperLimit());
212         assertEquals("DateTimeComparator[hourOfDay-]", c.toString());
213         
214         c = DateTimeComparator.getInstance(null);
215         assertSame(DateTimeComparator.getInstance(), c);
216     }
217     public void testStaticGetInstanceLowerUpper() {
218         DateTimeComparator c = DateTimeComparator.getInstance(DateTimeFieldType.hourOfDay(), DateTimeFieldType.dayOfYear());
219         assertEquals(DateTimeFieldType.hourOfDay(), c.getLowerLimit());
220         assertEquals(DateTimeFieldType.dayOfYear(), c.getUpperLimit());
221         assertEquals("DateTimeComparator[hourOfDay-dayOfYear]", c.toString());
222         
223         c = DateTimeComparator.getInstance(DateTimeFieldType.hourOfDay(), DateTimeFieldType.hourOfDay());
224         assertEquals(DateTimeFieldType.hourOfDay(), c.getLowerLimit());
225         assertEquals(DateTimeFieldType.hourOfDay(), c.getUpperLimit());
226         assertEquals("DateTimeComparator[hourOfDay]", c.toString());
227         
228         c = DateTimeComparator.getInstance(null, null);
229         assertSame(DateTimeComparator.getInstance(), c);
230         
231         c = DateTimeComparator.getInstance(DateTimeFieldType.dayOfYear(), null);
232         assertSame(DateTimeComparator.getDateOnlyInstance(), c);
233         
234         c = DateTimeComparator.getInstance(null, DateTimeFieldType.dayOfYear());
235         assertSame(DateTimeComparator.getTimeOnlyInstance(), c);
236     }
237     
238     //-----------------------------------------------------------------------
239
public void testEqualsHashCode() {
240         DateTimeComparator c1 = DateTimeComparator.getInstance();
241         assertEquals(true, c1.equals(c1));
242         assertEquals(false, c1.equals(null));
243         assertEquals(true, c1.hashCode() == c1.hashCode());
244         
245         DateTimeComparator c2 = DateTimeComparator.getTimeOnlyInstance();
246         assertEquals(true, c2.equals(c2));
247         assertEquals(false, c2.equals(c1));
248         assertEquals(false, c1.equals(c2));
249         assertEquals(false, c2.equals(null));
250         assertEquals(false, c1.hashCode() == c2.hashCode());
251         
252         DateTimeComparator c3 = DateTimeComparator.getTimeOnlyInstance();
253         assertEquals(true, c3.equals(c3));
254         assertEquals(false, c3.equals(c1));
255         assertEquals(true, c3.equals(c2));
256         assertEquals(false, c1.equals(c3));
257         assertEquals(true, c2.equals(c3));
258         assertEquals(false, c1.hashCode() == c3.hashCode());
259         assertEquals(true, c2.hashCode() == c3.hashCode());
260         
261         DateTimeComparator c4 = DateTimeComparator.getDateOnlyInstance();
262         assertEquals(false, c4.hashCode() == c3.hashCode());
263     }
264     
265     //-----------------------------------------------------------------------
266
public void testSerialization1() throws Exception JavaDoc {
267         DateTimeField f = ISO.dayOfYear();
268         f.toString();
269         DateTimeComparator c = DateTimeComparator.getInstance(DateTimeFieldType.hourOfDay(), DateTimeFieldType.dayOfYear());
270         
271         ByteArrayOutputStream JavaDoc baos = new ByteArrayOutputStream JavaDoc();
272         ObjectOutputStream JavaDoc oos = new ObjectOutputStream JavaDoc(baos);
273         oos.writeObject(c);
274         byte[] bytes = baos.toByteArray();
275         oos.close();
276         
277         ByteArrayInputStream JavaDoc bais = new ByteArrayInputStream JavaDoc(bytes);
278         ObjectInputStream JavaDoc ois = new ObjectInputStream JavaDoc(bais);
279         DateTimeComparator result = (DateTimeComparator) ois.readObject();
280         ois.close();
281         
282         assertEquals(c, result);
283     }
284
285     //-----------------------------------------------------------------------
286
public void testSerialization2() throws Exception JavaDoc {
287         DateTimeComparator c = DateTimeComparator.getInstance();
288         
289         ByteArrayOutputStream JavaDoc baos = new ByteArrayOutputStream JavaDoc();
290         ObjectOutputStream JavaDoc oos = new ObjectOutputStream JavaDoc(baos);
291         oos.writeObject(c);
292         byte[] bytes = baos.toByteArray();
293         oos.close();
294         
295         ByteArrayInputStream JavaDoc bais = new ByteArrayInputStream JavaDoc(bytes);
296         ObjectInputStream JavaDoc ois = new ObjectInputStream JavaDoc(bais);
297         DateTimeComparator result = (DateTimeComparator) ois.readObject();
298         ois.close();
299         
300         assertSame(c, result);
301     }
302
303     //-----------------------------------------------------------------------
304
/**
305      * Test all basic comparator operation with DateTime objects.
306      */

307     public void testBasicComps1() {
308         aDateTime = new DateTime( System.currentTimeMillis(), DateTimeZone.UTC );
309         bDateTime = new DateTime( aDateTime.getMillis(), DateTimeZone.UTC );
310         assertEquals( "getMillis", aDateTime.getMillis(),
311             bDateTime.getMillis() );
312         assertEquals( "MILLIS", 0, cMillis.compare( aDateTime, bDateTime ) );
313         assertEquals( "SECOND", 0, cSecond.compare( aDateTime, bDateTime ) );
314         assertEquals( "MINUTE", 0, cMinute.compare( aDateTime, bDateTime ) );
315         assertEquals( "HOUR", 0, cHour.compare( aDateTime, bDateTime ) );
316         assertEquals( "DOW", 0, cDayOfWeek.compare( aDateTime, bDateTime ) );
317         assertEquals( "DOM", 0, cDayOfMonth.compare( aDateTime, bDateTime ) );
318         assertEquals( "DOY", 0, cDayOfYear.compare( aDateTime, bDateTime ) );
319         assertEquals( "WOW", 0, cWeekOfWeekyear.compare( aDateTime, bDateTime ) );
320         assertEquals( "WY", 0, cWeekyear.compare( aDateTime, bDateTime ) );
321         assertEquals( "MONTH", 0, cMonth.compare( aDateTime, bDateTime ) );
322         assertEquals( "YEAR", 0, cYear.compare( aDateTime, bDateTime ) );
323         assertEquals( "DATE", 0, cDate.compare( aDateTime, bDateTime ) );
324         assertEquals( "TIME", 0, cTime.compare( aDateTime, bDateTime ) );
325     } // end of testBasicComps
326

327
328     /**
329      * Test all basic comparator operation with ReadableInstant objects.
330      */

331     public void testBasicComps2() {
332         ReadableInstant aDateTime = new DateTime( System.currentTimeMillis(), DateTimeZone.UTC );
333         ReadableInstant bDateTime = new DateTime( aDateTime.getMillis(), DateTimeZone.UTC );
334         assertEquals( "getMillis", aDateTime.getMillis(),
335             bDateTime.getMillis() );
336         assertEquals( "MILLIS", 0, cMillis.compare( aDateTime, bDateTime ) );
337         assertEquals( "SECOND", 0, cSecond.compare( aDateTime, bDateTime ) );
338         assertEquals( "MINUTE", 0, cMinute.compare( aDateTime, bDateTime ) );
339         assertEquals( "HOUR", 0, cHour.compare( aDateTime, bDateTime ) );
340         assertEquals( "DOW", 0, cDayOfWeek.compare( aDateTime, bDateTime ) );
341         assertEquals( "DOM", 0, cDayOfMonth.compare( aDateTime, bDateTime ) );
342         assertEquals( "DOY", 0, cDayOfYear.compare( aDateTime, bDateTime ) );
343         assertEquals( "WOW", 0, cWeekOfWeekyear.compare( aDateTime, bDateTime ) );
344         assertEquals( "WY", 0, cWeekyear.compare( aDateTime, bDateTime ) );
345         assertEquals( "MONTH", 0, cMonth.compare( aDateTime, bDateTime ) );
346         assertEquals( "YEAR", 0, cYear.compare( aDateTime, bDateTime ) );
347         assertEquals( "DATE", 0, cDate.compare( aDateTime, bDateTime ) );
348         assertEquals( "TIME", 0, cTime.compare( aDateTime, bDateTime ) );
349     } // end of testBasicComps
350

351     /**
352      * Test all basic comparator operation with java Date objects.
353      */

354     public void testBasicComps3() {
355         Date JavaDoc aDateTime
356             = new Date JavaDoc( System.currentTimeMillis() );
357         Date JavaDoc bDateTime
358             = new Date JavaDoc( aDateTime.getTime() );
359         assertEquals( "MILLIS", 0, cMillis.compare( aDateTime, bDateTime ) );
360         assertEquals( "SECOND", 0, cSecond.compare( aDateTime, bDateTime ) );
361         assertEquals( "MINUTE", 0, cMinute.compare( aDateTime, bDateTime ) );
362         assertEquals( "HOUR", 0, cHour.compare( aDateTime, bDateTime ) );
363         assertEquals( "DOW", 0, cDayOfWeek.compare( aDateTime, bDateTime ) );
364         assertEquals( "DOM", 0, cDayOfMonth.compare( aDateTime, bDateTime ) );
365         assertEquals( "DOY", 0, cDayOfYear.compare( aDateTime, bDateTime ) );
366         assertEquals( "WOW", 0, cWeekOfWeekyear.compare( aDateTime, bDateTime ) );
367         assertEquals( "WY", 0, cWeekyear.compare( aDateTime, bDateTime ) );
368         assertEquals( "MONTH", 0, cMonth.compare( aDateTime, bDateTime ) );
369         assertEquals( "YEAR", 0, cYear.compare( aDateTime, bDateTime ) );
370         assertEquals( "DATE", 0, cDate.compare( aDateTime, bDateTime ) );
371         assertEquals( "TIME", 0, cTime.compare( aDateTime, bDateTime ) );
372     } // end of testBasicComps
373

374     /**
375      * Test all basic comparator operation with Long objects.
376      */

377     public void testBasicComps4() {
378         Long JavaDoc aDateTime
379             = new Long JavaDoc( System.currentTimeMillis() );
380         Long JavaDoc bDateTime
381             = new Long JavaDoc( aDateTime.longValue() );
382         assertEquals( "MILLIS", 0, cMillis.compare( aDateTime, bDateTime ) );
383         assertEquals( "SECOND", 0, cSecond.compare( aDateTime, bDateTime ) );
384         assertEquals( "MINUTE", 0, cMinute.compare( aDateTime, bDateTime ) );
385         assertEquals( "HOUR", 0, cHour.compare( aDateTime, bDateTime ) );
386         assertEquals( "DOW", 0, cDayOfWeek.compare( aDateTime, bDateTime ) );
387         assertEquals( "DOM", 0, cDayOfMonth.compare( aDateTime, bDateTime ) );
388         assertEquals( "DOY", 0, cDayOfYear.compare( aDateTime, bDateTime ) );
389         assertEquals( "WOW", 0, cWeekOfWeekyear.compare( aDateTime, bDateTime ) );
390         assertEquals( "WY", 0, cWeekyear.compare( aDateTime, bDateTime ) );
391         assertEquals( "MONTH", 0, cMonth.compare( aDateTime, bDateTime ) );
392         assertEquals( "YEAR", 0, cYear.compare( aDateTime, bDateTime ) );
393         assertEquals( "DATE", 0, cDate.compare( aDateTime, bDateTime ) );
394         assertEquals( "TIME", 0, cTime.compare( aDateTime, bDateTime ) );
395     } // end of testBasicComps
396

397     /**
398      * Test all basic comparator operation with Calendar objects.
399      */

400     public void testBasicComps5() {
401         Calendar JavaDoc aDateTime
402             = Calendar.getInstance(); // right now
403
Calendar JavaDoc bDateTime = aDateTime;
404         assertEquals( "MILLIS", 0, cMillis.compare( aDateTime, bDateTime ) );
405         assertEquals( "SECOND", 0, cSecond.compare( aDateTime, bDateTime ) );
406         assertEquals( "MINUTE", 0, cMinute.compare( aDateTime, bDateTime ) );
407         assertEquals( "HOUR", 0, cHour.compare( aDateTime, bDateTime ) );
408         assertEquals( "DOW", 0, cDayOfWeek.compare( aDateTime, bDateTime ) );
409         assertEquals( "DOM", 0, cDayOfMonth.compare( aDateTime, bDateTime ) );
410         assertEquals( "DOY", 0, cDayOfYear.compare( aDateTime, bDateTime ) );
411         assertEquals( "WOW", 0, cWeekOfWeekyear.compare( aDateTime, bDateTime ) );
412         assertEquals( "WY", 0, cWeekyear.compare( aDateTime, bDateTime ) );
413         assertEquals( "MONTH", 0, cMonth.compare( aDateTime, bDateTime ) );
414         assertEquals( "YEAR", 0, cYear.compare( aDateTime, bDateTime ) );
415         assertEquals( "DATE", 0, cDate.compare( aDateTime, bDateTime ) );
416         assertEquals( "TIME", 0, cTime.compare( aDateTime, bDateTime ) );
417     } // end of testBasicComps
418

419
420     /**
421      * Test unequal comparisons with millis of second comparators.
422      */

423     public void testMillis() {
424         aDateTime = new DateTime( System.currentTimeMillis(), DateTimeZone.UTC );
425         bDateTime = new DateTime( aDateTime.getMillis() + 1, DateTimeZone.UTC );
426         assertEquals( "MillisM1", -1, cMillis.compare( aDateTime, bDateTime ) );
427         assertEquals( "MillisP1", 1, cMillis.compare( bDateTime, aDateTime ) );
428     } // end of testMillis
429

430     /**
431      * Test unequal comparisons with second comparators.
432      */

433     public void testSecond() {
434         aDateTime = getADate( "1969-12-31T23:59:58" );
435         bDateTime = getADate( "1969-12-31T23:50:59" );
436         assertEquals( "SecondM1a", -1, cSecond.compare( aDateTime, bDateTime ) );
437         assertEquals( "SecondP1a", 1, cSecond.compare( bDateTime, aDateTime ) );
438         aDateTime = getADate( "1970-01-01T00:00:00" );
439         bDateTime = getADate( "1970-01-01T00:00:01" );
440         assertEquals( "SecondM1b", -1, cSecond.compare( aDateTime, bDateTime ) );
441         assertEquals( "SecondP1b", 1, cSecond.compare( bDateTime, aDateTime ) );
442     } // end of testSecond
443

444     /**
445      * Test unequal comparisons with minute comparators.
446      */

447     public void testMinute() {
448         aDateTime = getADate( "1969-12-31T23:58:00" );
449         bDateTime = getADate( "1969-12-31T23:59:00" );
450         assertEquals( "MinuteM1a", -1, cMinute.compare( aDateTime, bDateTime ) );
451         assertEquals( "MinuteP1a", 1, cMinute.compare( bDateTime, aDateTime ) );
452         aDateTime = getADate( "1970-01-01T00:00:00" );
453         bDateTime = getADate( "1970-01-01T00:01:00" );
454         assertEquals( "MinuteM1b", -1, cMinute.compare( aDateTime, bDateTime ) );
455         assertEquals( "MinuteP1b", 1, cMinute.compare( bDateTime, aDateTime ) );
456     } // end of testMinute
457

458     /**
459      * Test unequal comparisons with hour comparators.
460      */

461     public void testHour() {
462         aDateTime = getADate( "1969-12-31T22:00:00" );
463         bDateTime = getADate( "1969-12-31T23:00:00" );
464         assertEquals( "HourM1a", -1, cHour.compare( aDateTime, bDateTime ) );
465         assertEquals( "HourP1a", 1, cHour.compare( bDateTime, aDateTime ) );
466         aDateTime = getADate( "1970-01-01T00:00:00" );
467         bDateTime = getADate( "1970-01-01T01:00:00" );
468         assertEquals( "HourM1b", -1, cHour.compare( aDateTime, bDateTime ) );
469         assertEquals( "HourP1b", 1, cHour.compare( bDateTime, aDateTime ) );
470         aDateTime = getADate( "1969-12-31T23:59:59" );
471         bDateTime = getADate( "1970-01-01T00:00:00" );
472         assertEquals( "HourP1c", 1, cHour.compare( aDateTime, bDateTime ) );
473         assertEquals( "HourM1c", -1, cHour.compare( bDateTime, aDateTime ) );
474     } // end of testHour
475

476     /**
477      * Test unequal comparisons with day of week comparators.
478      */

479     public void testDOW() {
480         /*
481          * Dates chosen when I wrote the code, so I know what day of
482          * the week it is.
483          */

484         aDateTime = getADate( "2002-04-12T00:00:00" );
485         bDateTime = getADate( "2002-04-13T00:00:00" );
486         assertEquals( "DOWM1a", -1, cDayOfWeek.compare( aDateTime, bDateTime ) );
487         assertEquals( "DOWP1a", 1, cDayOfWeek.compare( bDateTime, aDateTime ) );
488     } // end of testDOW
489

490     /**
491      * Test unequal comparisons with day of month comparators.
492      */

493     public void testDOM() {
494         aDateTime = getADate( "2002-04-12T00:00:00" );
495         bDateTime = getADate( "2002-04-13T00:00:00" );
496         assertEquals( "DOMM1a", -1, cDayOfMonth.compare( aDateTime, bDateTime ) );
497         assertEquals( "DOMP1a", 1, cDayOfMonth.compare( bDateTime, aDateTime ) );
498         aDateTime = getADate( "2000-12-01T00:00:00" );
499         bDateTime = getADate( "1814-04-30T00:00:00" );
500         assertEquals( "DOMM1b", -1, cDayOfMonth.compare( aDateTime, bDateTime ) );
501         assertEquals( "DOMP1b", 1, cDayOfMonth.compare( bDateTime, aDateTime ) );
502     } // end of testDOM
503

504     /**
505      * Test unequal comparisons with day of year comparators.
506      */

507     public void testDOY() {
508         aDateTime = getADate( "2002-04-12T00:00:00" );
509         bDateTime = getADate( "2002-04-13T00:00:00" );
510         assertEquals( "DOYM1a", -1, cDayOfYear.compare( aDateTime, bDateTime ) );
511         assertEquals( "DOYP1a", 1, cDayOfYear.compare( bDateTime, aDateTime ) );
512         aDateTime = getADate( "2000-02-29T00:00:00" );
513         bDateTime = getADate( "1814-11-30T00:00:00" );
514         assertEquals( "DOYM1b", -1, cDayOfYear.compare( aDateTime, bDateTime ) );
515         assertEquals( "DOYP1b", 1, cDayOfYear.compare( bDateTime, aDateTime ) );
516     } // end of testDOY
517

518     /**
519      * Test unequal comparisons with week of weekyear comparators.
520      */

521     public void testWOW() {
522         // 1st week of year contains Jan 04.
523
aDateTime = getADate( "2000-01-04T00:00:00" );
524         bDateTime = getADate( "2000-01-11T00:00:00" );
525         assertEquals( "WOWM1a", -1,
526             cWeekOfWeekyear.compare( aDateTime, bDateTime ) );
527         assertEquals( "WOWP1a", 1,
528             cWeekOfWeekyear.compare( bDateTime, aDateTime ) );
529         aDateTime = getADate( "2000-01-04T00:00:00" );
530         bDateTime = getADate( "1999-12-31T00:00:00" );
531         assertEquals( "WOWM1b", -1,
532             cWeekOfWeekyear.compare( aDateTime, bDateTime ) );
533         assertEquals( "WOWP1b", 1,
534             cWeekOfWeekyear.compare( bDateTime, aDateTime ) );
535     } // end of testMillis
536

537     /**
538      * Test unequal comparisons with year given the week comparators.
539      */

540     public void testWOYY() {
541         // How do I test the end conditions of this?
542
// Don't understand ......
543
aDateTime = getADate( "1998-12-31T23:59:59" );
544         bDateTime = getADate( "1999-01-01T00:00:00" );
545         assertEquals( "YOYYZ", 0, cWeekyear.compare( aDateTime, bDateTime ) );
546         bDateTime = getADate( "1999-01-04T00:00:00" );
547         assertEquals( "YOYYM1", -1, cWeekyear.compare( aDateTime, bDateTime ) );
548         assertEquals( "YOYYP1", 1, cWeekyear.compare( bDateTime, aDateTime ) );
549     } // end of testWOYY
550

551     /**
552      * Test unequal comparisons with month comparators.
553      */

554     public void testMonth() {
555         aDateTime = getADate( "2002-04-30T00:00:00" );
556         bDateTime = getADate( "2002-05-01T00:00:00" );
557         assertEquals( "MONTHM1a", -1, cMonth.compare( aDateTime, bDateTime ) );
558         assertEquals( "MONTHP1a", 1, cMonth.compare( bDateTime, aDateTime ) );
559         aDateTime = getADate( "1900-01-01T00:00:00" );
560         bDateTime = getADate( "1899-12-31T00:00:00" );
561         assertEquals( "MONTHM1b", -1, cMonth.compare( aDateTime, bDateTime ) );
562         assertEquals( "MONTHP1b", 1, cMonth.compare( bDateTime, aDateTime ) );
563     } // end of testMonth
564

565     /**
566      * Test unequal comparisons with year comparators.
567      */

568     public void testYear() {
569         aDateTime = getADate( "2000-01-01T00:00:00" );
570         bDateTime = getADate( "2001-01-01T00:00:00" );
571         assertEquals( "YEARM1a", -1, cYear.compare( aDateTime, bDateTime ) );
572         assertEquals( "YEARP1a", 1, cYear.compare( bDateTime, aDateTime ) );
573         aDateTime = getADate( "1968-12-31T23:59:59" );
574         bDateTime = getADate( "1970-01-01T00:00:00" );
575         assertEquals( "YEARM1b", -1, cYear.compare( aDateTime, bDateTime ) );
576         assertEquals( "YEARP1b", 1, cYear.compare( bDateTime, aDateTime ) );
577         aDateTime = getADate( "1969-12-31T23:59:59" );
578         bDateTime = getADate( "1970-01-01T00:00:00" );
579         assertEquals( "YEARM1c", -1, cYear.compare( aDateTime, bDateTime ) );
580         assertEquals( "YEARP1c", 1, cYear.compare( bDateTime, aDateTime ) );
581     } // end of testYear
582

583     /*
584      * 'List' processing tests follow.
585      */

586
587      /**
588       * Test sorting with full default comparator.
589       */

590      public void testListBasic() {
591         String JavaDoc[] dtStrs = {
592             "1999-02-01T00:00:00",
593             "1998-01-20T00:00:00"
594         };
595         //
596
List JavaDoc sl = loadAList( dtStrs );
597         boolean isSorted1 = isListSorted( sl );
598         Collections.sort( sl );
599         boolean isSorted2 = isListSorted( sl );
600         assertEquals("ListBasic", !isSorted1, isSorted2);
601      } // end of testListBasic
602

603      /**
604       * Test sorting with millis of second comparator.
605       */

606     public void testListMillis() {
607         //
608
List JavaDoc sl = new ArrayList JavaDoc();
609         long base = 12345L * 1000L;
610         sl.add( new DateTime( base + 999L, DateTimeZone.UTC ) );
611         sl.add( new DateTime( base + 222L, DateTimeZone.UTC ) );
612         sl.add( new DateTime( base + 456L, DateTimeZone.UTC ) );
613         sl.add( new DateTime( base + 888L, DateTimeZone.UTC ) );
614         sl.add( new DateTime( base + 123L, DateTimeZone.UTC ) );
615         sl.add( new DateTime( base + 000L, DateTimeZone.UTC ) );
616         //
617
boolean isSorted1 = isListSorted( sl );
618         Collections.sort( sl, cMillis );
619         boolean isSorted2 = isListSorted( sl );
620         assertEquals("ListLillis", !isSorted1, isSorted2);
621     } // end of testListSecond
622

623
624      /**
625       * Test sorting with second comparator.
626       */

627     public void testListSecond() {
628         String JavaDoc[] dtStrs = {
629             "1999-02-01T00:00:10",
630             "1999-02-01T00:00:30",
631             "1999-02-01T00:00:25",
632             "1999-02-01T00:00:18",
633             "1999-02-01T00:00:01",
634             "1999-02-01T00:00:59",
635             "1999-02-01T00:00:22"
636         };
637         //
638
List JavaDoc sl = loadAList( dtStrs );
639         boolean isSorted1 = isListSorted( sl );
640         Collections.sort( sl, cSecond );
641         boolean isSorted2 = isListSorted( sl );
642         assertEquals("ListSecond", !isSorted1, isSorted2);
643     } // end of testListSecond
644

645      /**
646       * Test sorting with minute comparator.
647       */

648     public void testListMinute() {
649         String JavaDoc[] dtStrs = {
650             "1999-02-01T00:10:00",
651             "1999-02-01T00:30:00",
652             "1999-02-01T00:25:00",
653             "1999-02-01T00:18:00",
654             "1999-02-01T00:01:00",
655             "1999-02-01T00:59:00",
656             "1999-02-01T00:22:00"
657         };
658         //
659
List JavaDoc sl = loadAList( dtStrs );
660         boolean isSorted1 = isListSorted( sl );
661         Collections.sort( sl, cMinute );
662         boolean isSorted2 = isListSorted( sl );
663         assertEquals("ListMinute", !isSorted1, isSorted2);
664     } // end of testListMinute
665

666      /**
667       * Test sorting with hour comparator.
668       */

669     public void testListHour() {
670         String JavaDoc[] dtStrs = {
671             "1999-02-01T10:00:00",
672             "1999-02-01T23:00:00",
673             "1999-02-01T01:00:00",
674             "1999-02-01T15:00:00",
675             "1999-02-01T05:00:00",
676             "1999-02-01T20:00:00",
677             "1999-02-01T17:00:00"
678         };
679         //
680
List JavaDoc sl = loadAList( dtStrs );
681         boolean isSorted1 = isListSorted( sl );
682         Collections.sort( sl, cHour );
683         boolean isSorted2 = isListSorted( sl );
684         assertEquals("ListHour", !isSorted1, isSorted2);
685     } // end of testListHour
686

687
688      /**
689       * Test sorting with day of week comparator.
690       */

691     public void testListDOW() {
692         String JavaDoc[] dtStrs = {
693             /* 2002-04-15 = Monday */
694             "2002-04-21T10:00:00",
695             "2002-04-16T10:00:00",
696             "2002-04-15T10:00:00",
697             "2002-04-17T10:00:00",
698             "2002-04-19T10:00:00",
699             "2002-04-18T10:00:00",
700             "2002-04-20T10:00:00"
701         };
702         //
703
List JavaDoc sl = loadAList( dtStrs );
704         boolean isSorted1 = isListSorted( sl );
705         Collections.sort( sl, cDayOfWeek );
706         boolean isSorted2 = isListSorted( sl );
707         assertEquals("ListDOW", !isSorted1, isSorted2);
708     } // end of testListDOW
709

710      /**
711       * Test sorting with day of month comparator.
712       */

713     public void testListDOM() {
714         String JavaDoc[] dtStrs = {
715             /* 2002-04-14 = Sunday */
716             "2002-04-20T10:00:00",
717             "2002-04-16T10:00:00",
718             "2002-04-15T10:00:00",
719             "2002-04-17T10:00:00",
720             "2002-04-19T10:00:00",
721             "2002-04-18T10:00:00",
722             "2002-04-14T10:00:00"
723         };
724         //
725
List JavaDoc sl = loadAList( dtStrs );
726         boolean isSorted1 = isListSorted( sl );
727         Collections.sort( sl, cDayOfMonth );
728         boolean isSorted2 = isListSorted( sl );
729         assertEquals("ListDOM", !isSorted1, isSorted2);
730     } // end of testListDOM
731

732      /**
733       * Test sorting with day of year comparator.
734       */

735     public void testListDOY() {
736         String JavaDoc[] dtStrs = {
737             "2002-04-20T10:00:00",
738             "2002-01-16T10:00:00",
739             "2002-12-31T10:00:00",
740             "2002-09-14T10:00:00",
741             "2002-09-19T10:00:00",
742             "2002-02-14T10:00:00",
743             "2002-10-30T10:00:00"
744         };
745         //
746
List JavaDoc sl = loadAList( dtStrs );
747         boolean isSorted1 = isListSorted( sl );
748         Collections.sort( sl, cDayOfYear );
749         boolean isSorted2 = isListSorted( sl );
750         assertEquals("ListDOY", !isSorted1, isSorted2);
751     } // end of testListDOY
752

753      /**
754       * Test sorting with week of weekyear comparator.
755       */

756     public void testListWOW() {
757         String JavaDoc[] dtStrs = {
758             "2002-04-01T10:00:00",
759             "2002-01-01T10:00:00",
760             "2002-12-01T10:00:00",
761             "2002-09-01T10:00:00",
762             "2002-09-01T10:00:00",
763             "2002-02-01T10:00:00",
764             "2002-10-01T10:00:00"
765         };
766         //
767
List JavaDoc sl = loadAList( dtStrs );
768         boolean isSorted1 = isListSorted( sl );
769         Collections.sort( sl, cWeekOfWeekyear );
770         boolean isSorted2 = isListSorted( sl );
771         assertEquals("ListWOW", !isSorted1, isSorted2);
772     } // end of testListWOW
773

774      /**
775       * Test sorting with year (given week) comparator.
776       */

777     public void testListYOYY() {
778         // ?? How to catch end conditions ??
779
String JavaDoc[] dtStrs = {
780             "2010-04-01T10:00:00",
781             "2002-01-01T10:00:00"
782         };
783         //
784
List JavaDoc sl = loadAList( dtStrs );
785         boolean isSorted1 = isListSorted( sl );
786         Collections.sort( sl, cWeekyear );
787         boolean isSorted2 = isListSorted( sl );
788         assertEquals("ListYOYY", !isSorted1, isSorted2);
789     } // end of testListYOYY
790

791
792      /**
793       * Test sorting with month comparator.
794       */

795     public void testListMonth() {
796         String JavaDoc[] dtStrs = {
797             "2002-04-01T10:00:00",
798             "2002-01-01T10:00:00",
799             "2002-12-01T10:00:00",
800             "2002-09-01T10:00:00",
801             "2002-09-01T10:00:00",
802             "2002-02-01T10:00:00",
803             "2002-10-01T10:00:00"
804         };
805         //
806
List JavaDoc sl = loadAList( dtStrs );
807         boolean isSorted1 = isListSorted( sl );
808         Collections.sort( sl, cMonth );
809         boolean isSorted2 = isListSorted( sl );
810         assertEquals("ListMonth", !isSorted1, isSorted2);
811     } // end of testListMonth
812

813      /**
814       * Test sorting with year comparator.
815       */

816      public void testListYear() {
817         String JavaDoc[] dtStrs = {
818             "1999-02-01T00:00:00",
819             "1998-02-01T00:00:00",
820             "2525-02-01T00:00:00",
821             "1776-02-01T00:00:00",
822             "1863-02-01T00:00:00",
823             "1066-02-01T00:00:00",
824             "2100-02-01T00:00:00"
825         };
826         //
827
List JavaDoc sl = loadAList( dtStrs );
828         boolean isSorted1 = isListSorted( sl );
829         Collections.sort( sl, cYear );
830         boolean isSorted2 = isListSorted( sl );
831         assertEquals("ListYear", !isSorted1, isSorted2);
832      } // end of testListYear
833

834      /**
835       * Test sorting with date only comparator.
836       */

837     public void testListDate() {
838         String JavaDoc[] dtStrs = {
839             "1999-02-01T00:00:00",
840             "1998-10-03T00:00:00",
841             "2525-05-20T00:00:00",
842             "1776-12-25T00:00:00",
843             "1863-01-31T00:00:00",
844             "1066-09-22T00:00:00",
845             "2100-07-04T00:00:00"
846         };
847         //
848
List JavaDoc sl = loadAList( dtStrs );
849         boolean isSorted1 = isListSorted( sl );
850         Collections.sort( sl, cDate );
851         boolean isSorted2 = isListSorted( sl );
852         assertEquals("ListDate", !isSorted1, isSorted2);
853     } // end of testListDate
854

855      /**
856       * Test sorting with time only comparator.
857       */

858     public void testListTime() {
859         String JavaDoc[] dtStrs = {
860             "1999-02-01T01:02:05",
861             "1999-02-01T22:22:22",
862             "1999-02-01T05:30:45",
863             "1999-02-01T09:17:59",
864             "1999-02-01T09:17:58",
865             "1999-02-01T15:30:00",
866             "1999-02-01T17:00:44"
867         };
868         //
869
List JavaDoc sl = loadAList( dtStrs );
870         boolean isSorted1 = isListSorted( sl );
871         Collections.sort( sl, cTime );
872         boolean isSorted2 = isListSorted( sl );
873         assertEquals("ListTime", !isSorted1, isSorted2);
874     } // end of testListTime
875

876
877     /**
878      * Test comparator operation with null object(s).
879      */

880     public void testNullDT() {
881         // null means now
882
aDateTime = getADate("2000-01-01T00:00:00");
883         assertTrue(cYear.compare(null, aDateTime) > 0);
884         assertTrue(cYear.compare(aDateTime, null) < 0);
885     }
886
887     /**
888      * Test comparator operation with an invalid object type.
889      */

890     public void testInvalidObj() {
891         aDateTime = getADate("2000-01-01T00:00:00");
892         try {
893             cYear.compare("FreeBird", aDateTime);
894             fail("Invalid object failed");
895         } catch (IllegalArgumentException JavaDoc cce) {}
896     }
897
898     // private convenience methods
899
//-----------------------------------------------------------------------
900
/**
901      * Creates a date to test with.
902      */

903     private DateTime getADate(String JavaDoc s) {
904         DateTime retDT = null;
905         try {
906             retDT = new DateTime(s, DateTimeZone.UTC);
907         } catch (IllegalArgumentException JavaDoc pe) {
908             pe.printStackTrace();
909         }
910         return retDT;
911     }
912
913     /**
914      * Load a string array.
915      */

916     private List JavaDoc loadAList(String JavaDoc[] someStrs) {
917         List JavaDoc newList = new ArrayList JavaDoc();
918         try {
919             for (int i = 0; i < someStrs.length; ++i) {
920                 newList.add(new DateTime(someStrs[i], DateTimeZone.UTC));
921             } // end of the for
922
} catch (IllegalArgumentException JavaDoc pe) {
923             pe.printStackTrace();
924         }
925         return newList;
926     }
927
928     /**
929      * Check if the list is sorted.
930      */

931     private boolean isListSorted(List JavaDoc tl) {
932         // tl must be populated with DateTime objects.
933
DateTime lhDT = (DateTime)tl.get(0);
934         DateTime rhDT = null;
935         Long JavaDoc lhVal = new Long JavaDoc( lhDT.getMillis() );
936         Long JavaDoc rhVal = null;
937         for (int i = 1; i < tl.size(); ++i) {
938             rhDT = (DateTime)tl.get(i);
939             rhVal = new Long JavaDoc( rhDT.getMillis() );
940             if ( lhVal.compareTo( rhVal) > 0 ) return false;
941             //
942
lhVal = rhVal; // swap for next iteration
943
lhDT = rhDT; // swap for next iteration
944
}
945         return true;
946     }
947
948 }
949
Popular Tags