Java > Open Source Codes > org > opensubsystems > core > util > DateUtilsTest


1 /*
2  * Copyright (c) 2003 - 2007 OpenSubsystems s.r.o. Slovak Republic. All rights reserved.
3  *
4  * Project: OpenSubsystems
5  *
6  * $Id: DateUtilsTest.java,v 1.4 2007/01/07 06:14:55 bastafidli Exp $
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; version 2 of the License.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20  */
21
22 package org.opensubsystems.core.util;
23
24 import java.text.DateFormat ;
25 import java.util.Calendar ;
26 import java.util.Date ;
27 import java.util.GregorianCalendar ;
28
29 import junit.framework.TestCase;
30
31 /**
32  * Tests for common operations with dates.
33  *
34  * @version $Id: DateUtilsTest.java,v 1.4 2007/01/07 06:14:55 bastafidli Exp $
35  * @author Miro Halas
36  * @code.reviewer Miro Halas
37  * @code.reviewed Initial revision
38  */
39 public class DateUtilsTest extends TestCase
40 {
41    /**
42     * Formatter to format dates and times;
43     */
44    protected DateFormat m_dateTimeFormat;
45
46    /**
47     * Constructor for DateUtilsTest.
48     * @param arg0 - name of the test
49     */
50    public DateUtilsTest(
51       String arg0
52    )
53    {
54       super(arg0);
55       
56       m_dateTimeFormat = DateFormat.getDateTimeInstance();
57    }
58
59    /**
60     * Set up environment for the test case.
61     *
62     * @throws Exception - an error has occured during setting up test
63     */
64    protected void setUp(
65    ) throws Exception
66    {
67       super.setUp();
68    }
69
70    /**
71     * Restore original environment after the test case.
72     *
73     * @throws Exception - an error has occured during tearing down up test
74     */
75    protected void tearDown() throws Exception
76    {
77       super.tearDown();
78    }
79
80    /**
81     * Test comparison of two equal dates.
82     */
83    public void testDateEquals(
84    )
85    {
86       Calendar calGenerate = Calendar.getInstance();
87       
88       // Set date of my birthday ;-)
89 calGenerate.set(1974, 9, 15, 1, 2, 3);
90             
91       // Make sure we have two separate objects
92 Date dtFirst = new Date (calGenerate.getTimeInMillis());
93       Date dtSecond = new Date (calGenerate.getTimeInMillis());
94
95       assertTrue("Two dates must be equal: "
96                         + m_dateTimeFormat.format(dtFirst)
97                         + "(" + dtFirst.getTime() + ") and "
98                         + m_dateTimeFormat.format(dtSecond)
99                         + "(" + dtSecond.getTime() + ")",
100                         DateUtils.dateEquals(dtFirst, dtSecond));
101    }
102
103    /**
104     * Test comparison of null and date.
105     */
106    public void testDateEqualsFirstNull(
107    )
108    {
109       Calendar calGenerate = Calendar.getInstance();
110       
111       // Set date of my birthday ;-)
112 calGenerate.set(1974, 9, 15, 1, 2, 3);
113             
114       Date dtFirst = null;
115       Date dtSecond = new Date (calGenerate.getTimeInMillis());
116
117       assertFalse("Null and date are not equal: "
118                         + "null and "
119                         + m_dateTimeFormat.format(dtSecond)
120                         + "(" + dtSecond.getTime() + ")",
121                         DateUtils.dateEquals(dtFirst, dtSecond));
122    }
123
124    /**
125     * Test comparison of date and null.
126     */
127    public void testDateEqualsSecondNull(
128    )
129    {
130       Calendar calGenerate = Calendar.getInstance();
131       
132       // Set date of my birthday ;-)
133 calGenerate.set(1974, 9, 15, 1, 2, 3);
134             
135       Date dtFirst = new Date (calGenerate.getTimeInMillis());
136       Date dtSecond = null;
137
138       assertFalse("Date and null are not equal: "
139                          + m_dateTimeFormat.format(dtFirst)
140                          + "(" + dtFirst.getTime() + ") and null",
141                          DateUtils.dateEquals(dtFirst, dtSecond));
142    }
143
144    /**
145     * Test comparison of null and null.
146     */
147    public void testDateEqualsNullAndNull(
148    )
149    {
150       Date dtFirst = null;
151       Date dtSecond = null;
152
153       assertTrue("null and null are equal dates",
154                         DateUtils.dateEquals(dtFirst, dtSecond));
155    }
156
157    /**
158     * Test comparison of the same date object.
159     */
160    public void testDateEqualsWithTheSameObject(
161    )
162    {
163       Calendar calGenerate = Calendar.getInstance();
164       
165       // Set date of my birthday ;-)
166 calGenerate.set(1974, 9, 15, 1, 2, 3);
167             
168       // Make sure we have two separate objects
169 Date dtFirst = new Date (calGenerate.getTimeInMillis());
170       Date dtSecond = dtFirst;
171
172       assertTrue("The same date object must be equal: "
173                         + m_dateTimeFormat.format(dtFirst)
174                         + "(" + dtFirst.hashCode() + ") and "
175                         + m_dateTimeFormat.format(dtSecond)
176                         + "(" + dtSecond.hashCode() + ")",
177                         DateUtils.dateEquals(dtFirst, dtSecond));
178    }
179
180    /**
181     * Test comparison of two dates which differ in milliseconds.
182     */
183    public void testDateEqualsWithMilliDiff(
184    )
185    {
186       Calendar calGenerate = Calendar.getInstance();
187       
188       // Set date of my birthday ;-)
189 calGenerate.set(1974, 9, 15, 1, 2, 3);
190       calGenerate.set(Calendar.MILLISECOND, 1);
191             
192       // Make sure we have two separate objects
193 Date dtFirst = new Date (calGenerate.getTimeInMillis());
194
195       calGenerate.set(Calendar.MILLISECOND, 2);
196       Date dtSecond = new Date (calGenerate.getTimeInMillis());
197
198       assertTrue("Two dates differ in millisecond and must be the same: "
199                         + m_dateTimeFormat.format(dtFirst)
200                         + "(" + dtFirst.getTime() + ") and "
201                         + m_dateTimeFormat.format(dtSecond)
202                         + "(" + dtSecond.getTime() + ")",
203                         DateUtils.dateEquals(dtFirst, dtSecond));
204    }
205
206    /**
207     * Test comparison of two dates which differ in seconds.
208     */
209    public void testDateEqualsWithSecondDiff(
210    )
211    {
212       Calendar calGenerate = Calendar.getInstance();
213       
214       // Set date of my birthday ;-)
215 calGenerate.set(1974, 9, 15, 1, 2, 3);
216             
217       // Make sure we have two separate objects
218 Date dtFirst = new Date (calGenerate.getTimeInMillis());
219
220       calGenerate.set(Calendar.SECOND, 4);
221       Date dtSecond = new Date (calGenerate.getTimeInMillis());
222
223       assertTrue("Two dates differ in second and must be the same: "
224                         + m_dateTimeFormat.format(dtFirst)
225                         + "(" + dtFirst.getTime() + ") and "
226                         + m_dateTimeFormat.format(dtSecond)
227                         + "(" + dtSecond.getTime() + ")",
228                         DateUtils.dateEquals(dtFirst, dtSecond));
229    }
230
231    /**
232     * Test comparison of two dates which differ in minutes.
233     */
234    public void testDateEqualsWithMinuteDiff(
235    )
236    {
237       Calendar calGenerate = Calendar.getInstance();
238       
239       // Set date of my birthday ;-)
240 calGenerate.set(1974, 9, 15, 1, 2, 3);
241             
242       // Make sure we have two separate objects
243 Date dtFirst = new Date (calGenerate.getTimeInMillis());
244
245       calGenerate.set(Calendar.MINUTE, 3);
246       Date dtSecond = new Date (calGenerate.getTimeInMillis());
247
248       assertTrue("Two dates differ in minute and must be the same: "
249                         + m_dateTimeFormat.format(dtFirst)
250                         + "(" + dtFirst.getTime() + ") and "
251                         + m_dateTimeFormat.format(dtSecond)
252                         + "(" + dtSecond.getTime() + ")",
253                         DateUtils.dateEquals(dtFirst, dtSecond));
254    }
255
256    /**
257     * Test comparison of two dates which differ in hour.
258     */
259    public void testDateEqualsWithHourDiff(
260    )
261    {
262       Calendar calGenerate = Calendar.getInstance();
263       
264       // Set date of my birthday ;-)
265 calGenerate.set(1974, 9, 15, 1, 2, 3);
266             
267       // Make sure we have two separate objects
268 Date dtFirst = new Date (calGenerate.getTimeInMillis());
269
270       // Use 13 to check if 1AM and 1PM are different
271 calGenerate.set(Calendar.HOUR_OF_DAY, 13);
272       Date dtSecond = new Date (calGenerate.getTimeInMillis());
273
274       assertTrue("Two dates differ in hour and must be the same: "
275                         + m_dateTimeFormat.format(dtFirst)
276                         + "(" + dtFirst.getTime() + ") and "
277                         + m_dateTimeFormat.format(dtSecond)
278                         + "(" + dtSecond.getTime() + ")",
279                         DateUtils.dateEquals(dtFirst, dtSecond));
280    }
281
282    /**
283     * Test comparison of two dates which differ in day.
284     */
285    public void testDateEqualsWithDayDiff(
286    )
287    {
288       Calendar calGenerate = Calendar.getInstance();
289       
290       // Set date of my birthday ;-)
291 calGenerate.set(1974, 9, 15, 1, 2, 3);
292             
293       // Make sure we have two separate objects
294 Date dtFirst = new Date (calGenerate.getTimeInMillis());
295
296       calGenerate.set(Calendar.DATE, 16);
297       Date dtSecond = new Date (calGenerate.getTimeInMillis());
298
299       assertFalse("Two dates differ in day and must be different: "
300                         + m_dateTimeFormat.format(dtFirst)
301                         + "(" + dtFirst.getTime() + ") and "
302                         + m_dateTimeFormat.format(dtSecond)
303                         + "(" + dtSecond.getTime() + ")",
304                         DateUtils.dateEquals(dtFirst, dtSecond));
305    }
306
307    /**
308     * Test comparison of two dates which differ in month.
309     */
310    public void testDateEqualsWithMonthDiff(
311    )
312    {
313       Calendar calGenerate = Calendar.getInstance();
314       
315       // Set date of my birthday ;-)
316 calGenerate.set(1974, 9, 15, 1, 2, 3);
317             
318       // Make sure we have two separate objects
319 Date dtFirst = new Date (calGenerate.getTimeInMillis());
320
321       calGenerate.set(Calendar.MONTH, 10);
322       Date dtSecond = new Date (calGenerate.getTimeInMillis());
323
324       assertFalse("Two dates differ in month and must be different: "
325                         + m_dateTimeFormat.format(dtFirst)
326                         + "(" + dtFirst.getTime() + ") and "
327                         + m_dateTimeFormat.format(dtSecond)
328                         + "(" + dtSecond.getTime() + ")",
329                         DateUtils.dateEquals(dtFirst, dtSecond));
330    }
331
332    /**
333     * Test comparison of two dates which differ in year.
334     */
335    public void testDateEqualsWithYearDiff(
336    )
337    {
338       Calendar calGenerate = Calendar.getInstance();
339       
340       // Set date of my birthday ;-)
341 calGenerate.set(1974, 9, 15, 1, 2, 3);
342             
343       // Make sure we have two separate objects
344 Date dtFirst = new Date (calGenerate.getTimeInMillis());
345
346       calGenerate.set(Calendar.YEAR, 1975);
347       Date dtSecond = new Date (calGenerate.getTimeInMillis());
348
349       assertFalse("Two dates differ in year and must be different: "
350                         + m_dateTimeFormat.format(dtFirst)
351                         + "(" + dtFirst.getTime() + ") and "
352                         + m_dateTimeFormat.format(dtSecond)
353                         + "(" + dtSecond.getTime() + ")",
354                         DateUtils.dateEquals(dtFirst, dtSecond));
355    }
356
357    /**
358     * Test comparison of two dates which differ in era.
359     */
360    public void testDateEqualsWithEraDiff(
361    )
362    {
363       Calendar calGenerate = Calendar.getInstance();
364       
365       // Set date of my birthday ;-)
366 calGenerate.set(1974, 9, 15, 1, 2, 3);
367             
368       // Make sure we have two separate objects
369 Date dtFirst = new Date (calGenerate.getTimeInMillis());
370
371       calGenerate.set(Calendar.ERA, GregorianCalendar.BC);
372       Date dtSecond = new Date (calGenerate.getTimeInMillis());
373
374       assertFalse("Two dates differ in era and must be different: "
375                         + m_dateTimeFormat.format(dtFirst)
376                         + "(" + dtFirst.getTime() + ") and "
377                         + m_dateTimeFormat.format(dtSecond)
378                         + "(" + dtSecond.getTime() + ")",
379                         DateUtils.dateEquals(dtFirst, dtSecond));
380    }
381
382    /**
383     * Test comparison of two equal date times.
384     */
385    public void testDateAndTimeEquals(
386    )
387    {
388       Calendar calGenerate = Calendar.getInstance();
389       
390       // Set date of my birthday ;-)
391 calGenerate.set(1974, 9, 15, 1, 2, 3);
392             
393       // Make sure we have two separate objects
394 Date dtFirst = new Date (calGenerate.getTimeInMillis());
395       Date dtSecond = new Date (calGenerate.getTimeInMillis());
396
397       assertTrue("Two date times must be equal: "
398                         + m_dateTimeFormat.format(dtFirst)
399                         + "(" + dtFirst.getTime() + ") and "
400                         + m_dateTimeFormat.format(dtSecond)
401                         + "(" + dtSecond.getTime() + ")",
402                         DateUtils.dateAndTimeEquals(dtFirst, dtSecond));
403    }
404
405    /**
406     * Test comparison of null and date time.
407     */
408    public void testDateAndTimeEqualsFirstNull(
409    )
410    {
411       Calendar calGenerate = Calendar.getInstance();
412       
413       // Set date of my birthday ;-)
414 calGenerate.set(1974, 9, 15, 1, 2, 3);
415             
416       Date dtFirst = null;
417       Date dtSecond = new Date (calGenerate.getTimeInMillis());
418
419       assertFalse("Null and date time are not equal: "
420                         + "null and "
421                         + m_dateTimeFormat.format(dtSecond)
422                         + "(" + dtSecond.getTime() + ")",
423                         DateUtils.dateAndTimeEquals(dtFirst, dtSecond));
424    }
425
426    /**
427     * Test comparison of date time and null.
428     */
429    public void testDateAndTimeEqualsSecondNull(
430    )
431    {
432       Calendar calGenerate = Calendar.getInstance();
433       
434       // Set date of my birthday ;-)
435 calGenerate.set(1974, 9, 15, 1, 2, 3);
436             
437       Date dtFirst = new Date (calGenerate.getTimeInMillis());
438       Date dtSecond = null;
439
440       assertFalse("Date time and null are not equal: "
441                          + m_dateTimeFormat.format(dtFirst)
442                          + "(" + dtFirst.getTime() + ") and null",
443                          DateUtils.dateAndTimeEquals(dtFirst, dtSecond));
444    }
445
446    /**
447     * Test comparison of null and null.
448     */
449    public void testDateAndTimeEqualsNullAndNull(
450    )
451    {
452       Date dtFirst = null;
453       Date dtSecond = null;
454
455       assertTrue("null and null are equal date times",
456                         DateUtils.dateAndTimeEquals(dtFirst, dtSecond));
457    }
458
459    /**
460     * Test comparison of the same date time object.
461     */
462    public void testDateAndTimeEqualsWithTheSameObject(
463    )
464    {
465       Calendar calGenerate = Calendar.getInstance();
466       
467       // Set date of my birthday ;-)
468 calGenerate.set(1974, 9, 15, 1, 2, 3);
469             
470       // Make sure we have two separate objects
471 Date dtFirst = new Date (calGenerate.getTimeInMillis());
472       Date dtSecond = dtFirst;
473
474       assertTrue("The same date time object must be equal: "
475                         + m_dateTimeFormat.format(dtFirst)
476                         + "(" + dtFirst.hashCode() + ") and "
477                         + m_dateTimeFormat.format(dtSecond)
478                         + "(" + dtSecond.hashCode() + ")",
479                         DateUtils.dateAndTimeEquals(dtFirst, dtSecond));
480    }
481
482    /**
483     * Test comparison of two date times which differ in milliseconds.
484     */
485    public void testDateAndTimeEqualsWithMilliDiff(
486    )
487    {
488       Calendar calGenerate = Calendar.getInstance();
489       
490       // Set date of my birthday ;-)
491 calGenerate.set(1974, 9, 15, 1, 2, 3);
492       calGenerate.set(Calendar.MILLISECOND, 1);
493             
494       // Make sure we have two separate objects
495 Date dtFirst = new Date (calGenerate.getTimeInMillis());
496
497       calGenerate.set(Calendar.MILLISECOND, 2);
498       Date dtSecond = new Date (calGenerate.getTimeInMillis());
499
500       assertFalse("Two date times differ in millisecond and must be the same: "
501                         + m_dateTimeFormat.format(dtFirst)
502                         + "(" + dtFirst.getTime() + ") and "
503                         + m_dateTimeFormat.format(dtSecond)
504                         + "(" + dtSecond.getTime() + ")",
505                         DateUtils.dateAndTimeEquals(dtFirst, dtSecond));
506    }
507
508    /**
509     * Test comparison of two date times which differ in seconds.
510     */
511    public void testDateAndTimeEqualsWithSecondDiff(
512    )
513    {
514       Calendar calGenerate = Calendar.getInstance();
515       
516       // Set date of my birthday ;-)
517 calGenerate.set(1974, 9, 15, 1, 2, 3);
518             
519       // Make sure we have two separate objects
520 Date dtFirst = new Date (calGenerate.getTimeInMillis());
521
522       calGenerate.set(Calendar.SECOND, 4);
523       Date dtSecond = new Date (calGenerate.getTimeInMillis());
524
525       assertFalse("Two date times differ in second and must be the same: "
526                         + m_dateTimeFormat.format(dtFirst)
527                         + "(" + dtFirst.getTime() + ") and "
528                         + m_dateTimeFormat.format(dtSecond)
529                         + "(" + dtSecond.getTime() + ")",
530                         DateUtils.dateAndTimeEquals(dtFirst, dtSecond));
531    }
532
533    /**
534     * Test comparison of two date times which differ in minutes.
535     */
536    public void testDateAndTimeEqualsWithMinuteDiff(
537    )
538    {
539       Calendar calGenerate = Calendar.getInstance();
540       
541       // Set date of my birthday ;-)
542 calGenerate.set(1974, 9, 15, 1, 2, 3);
543             
544       // Make sure we have two separate objects
545 Date dtFirst = new Date (calGenerate.getTimeInMillis());
546
547       calGenerate.set(Calendar.MINUTE, 3);
548       Date dtSecond = new Date (calGenerate.getTimeInMillis());
549
550       assertFalse("Two date times differ in minute and must be the same: "
551                         + m_dateTimeFormat.format(dtFirst)
552                         + "(" + dtFirst.getTime() + ") and "
553                         + m_dateTimeFormat.format(dtSecond)
554                         + "(" + dtSecond.getTime() + ")",
555                         DateUtils.dateAndTimeEquals(dtFirst, dtSecond));
556    }
557
558    /**
559     * Test comparison of two date times which differ in hour.
560     */
561    public void testDateAndTimeEqualsWithHourDiff(
562    )
563    {
564       Calendar calGenerate = Calendar.getInstance();
565       
566       // Set date of my birthday ;-)
567 calGenerate.set(1974, 9, 15, 1, 2, 3);
568             
569       // Make sure we have two separate objects
570 Date dtFirst = new Date (calGenerate.getTimeInMillis());
571
572       // Use 13 to check if 1AM and 1PM are different
573 calGenerate.set(Calendar.HOUR_OF_DAY, 13);
574       Date dtSecond = new Date (calGenerate.getTimeInMillis());
575
576       assertFalse("Two date times differ in hour and must be the same: "
577                         + m_dateTimeFormat.format(dtFirst)
578                         + "(" + dtFirst.getTime() + ") and "
579                         + m_dateTimeFormat.format(dtSecond)
580                         + "(" + dtSecond.getTime() + ")",
581                         DateUtils.dateAndTimeEquals(dtFirst, dtSecond));
582    }
583
584    /**
585     * Test comparison of two date times which differ in day.
586     */
587    public void testDateAndTimeEqualsWithDayDiff(
588    )
589    {
590       Calendar calGenerate = Calendar.getInstance();
591       
592       // Set date of my birthday ;-)
593 calGenerate.set(1974, 9, 15, 1, 2, 3);
594             
595       // Make sure we have two separate objects
596 Date dtFirst = new Date (calGenerate.getTimeInMillis());
597
598       calGenerate.set(Calendar.DATE, 16);
599       Date dtSecond = new Date (calGenerate.getTimeInMillis());
600
601       assertFalse("Two date and times differ in hour and must be different: "
602                         + m_dateTimeFormat.format(dtFirst)
603                         + "(" + dtFirst.getTime() + ") and "
604                         + m_dateTimeFormat.format(dtSecond)
605                         + "(" + dtSecond.getTime() + ")",
606                         DateUtils.dateAndTimeEquals(dtFirst, dtSecond));
607    }
608
609    /**
610     * Test comparison of two date times which differ in month.
611     */
612    public void testDateAndTimeEqualsWithMonthDiff(
613    )
614    {
615       Calendar calGenerate = Calendar.getInstance();
616       
617       // Set date of my birthday ;-)
618 calGenerate.set(1974, 9, 15, 1, 2, 3);
619             
620       // Make sure we have two separate objects
621 Date dtFirst = new Date (calGenerate.getTimeInMillis());
622
623       calGenerate.set(Calendar.MONTH, 10);
624       Date dtSecond = new Date (calGenerate.getTimeInMillis());
625
626       assertFalse("Two date times differ in month and must be different: "
627                         + m_dateTimeFormat.format(dtFirst)
628                         + "(" + dtFirst.getTime() + ") and "
629                         + m_dateTimeFormat.format(dtSecond)
630                         + "(" + dtSecond.getTime() + ")",
631                         DateUtils.dateAndTimeEquals(dtFirst, dtSecond));
632    }
633
634    /**
635     * Test comparison of two date times which differ in year.
636     */
637    public void testDateAndTimeEqualsWithYearDiff(
638    )
639    {
640       Calendar calGenerate = Calendar.getInstance();
641       
642       // Set date of my birthday ;-)
643 calGenerate.set(1974, 9, 15, 1, 2, 3);
644             
645       // Make sure we have two separate objects
646 Date dtFirst = new Date (calGenerate.getTimeInMillis());
647
648       calGenerate.set(Calendar.YEAR, 1975);
649       Date dtSecond = new Date (calGenerate.getTimeInMillis());
650
651       assertFalse("Two date times differ in year and must be different: "
652                         + m_dateTimeFormat.format(dtFirst)
653                         + "(" + dtFirst.getTime() + ") and "
654                         + m_dateTimeFormat.format(dtSecond)
655                         + "(" + dtSecond.getTime() + ")",
656                         DateUtils.dateAndTimeEquals(dtFirst, dtSecond));
657    }
658
659    /**
660     * Test comparison of two date times which differ in era.
661     */
662    public void testDateAndTimeEqualsWithEraDiff(
663    )
664    {
665       Calendar calGenerate = Calendar.getInstance();
666       
667       // Set date of my birthday ;-)
668 calGenerate.set(1974, 9, 15, 1, 2, 3);
669             
670       // Make sure we have two separate objects
671 Date dtFirst = new Date (calGenerate.getTimeInMillis());
672
673       calGenerate.set(Calendar.ERA, GregorianCalendar.BC);
674       Date dtSecond = new Date (calGenerate.getTimeInMillis());
675
676       assertFalse("Two date times differ in era and must be different: "
677                         + m_dateTimeFormat.format(dtFirst)
678                         + "(" + dtFirst.getTime() + ") and "
679                         + m_dateTimeFormat.format(dtSecond)
680                         + "(" + dtSecond.getTime() + ")",
681                         DateUtils.dateAndTimeEquals(dtFirst, dtSecond));
682    }
683
684    /**
685     * Test comparison of two equal times.
686     */
687    public void testTimeEquals(
688    )
689    {
690       Calendar calGenerate = Calendar.getInstance();
691       
692       // Set date of my birthday ;-)
693 calGenerate.set(1974, 9, 15, 1, 2, 3);
694             
695       // Make sure we have two separate objects
696 Date dtFirst = new Date (calGenerate.getTimeInMillis());
697       Date dtSecond = new Date (calGenerate.getTimeInMillis());
698
699       assertTrue("Two times must be equal: "
700                         + m_dateTimeFormat.format(dtFirst)
701                         + "(" + dtFirst.getTime() + ") and "
702                         + m_dateTimeFormat.format(dtSecond)
703                         + "(" + dtSecond.getTime() + ")",
704                         DateUtils.timeEquals(dtFirst, dtSecond, false));
705    }
706
707    /**
708     * Test comparison of null and time.
709     */
710    public void testTimeEqualsFirstNull(
711    )
712    {
713       Calendar calGenerate = Calendar.getInstance();
714       
715       // Set date of my birthday ;-)
716 calGenerate.set(1974, 9, 15, 1, 2, 3);
717             
718       Date dtFirst = null;
719       Date dtSecond = new Date (calGenerate.getTimeInMillis());
720
721       assertFalse("Null and time are not equal: "
722                         + "null and "
723                         + m_dateTimeFormat.format(dtSecond)
724                         + "(" + dtSecond.getTime() + ")",
725                         DateUtils.timeEquals(dtFirst, dtSecond, false));
726    }
727
728    /**
729     * Test comparison of time and null.
730     */
731    public void testTimeEqualsSecondNull(
732    )
733    {
734       Calendar calGenerate = Calendar.getInstance();
735       
736       // Set date of my birthday ;-)
737 calGenerate.set(1974, 9, 15, 1, 2, 3);
738             
739       Date dtFirst = new Date (calGenerate.getTimeInMillis());
740       Date dtSecond = null;
741
742       assertFalse("Time and null are not equal: "
743                          + m_dateTimeFormat.format(dtFirst)
744                          + "(" + dtFirst.getTime() + ") and null",
745                          DateUtils.timeEquals(dtFirst, dtSecond, false));
746    }
747
748    /**
749     * Test comparison of null and null.
750     */
751    public void testTimeEqualsNullAndNull(
752    )
753    {
754       Date dtFirst = null;
755       Date dtSecond = null;
756
757       assertTrue("null and null are equal times",
758                         DateUtils.timeEquals(dtFirst, dtSecond, false));
759    }
760
761    /**
762     * Test comparison of the same time object.
763     */
764    public void testTimeEqualsWithTheSameObject(
765    )
766    {
767       Calendar calGenerate = Calendar.getInstance();
768       
769       // Set date of my birthday ;-)
770 calGenerate.set(1974, 9, 15, 1, 2, 3);
771             
772       // Make sure we have two separate objects
773 Date dtFirst = new Date (calGenerate.getTimeInMillis());
774       Date dtSecond = dtFirst;
775
776       assertTrue("The same time object must be equal: "
777                         + m_dateTimeFormat.format(dtFirst)
778                         + "(" + dtFirst.hashCode() + ") and "
779                         + m_dateTimeFormat.format(dtSecond)
780                         + "(" + dtSecond.hashCode() + ")",
781                         DateUtils.timeEquals(dtFirst, dtSecond, false));
782    }
783
784    /**
785     * Test comparison of two times which differ in milliseconds.
786     */
787    public void testTimeEqualsWithMilliDiff(
788    )
789    {
790       Calendar calGenerate = Calendar.getInstance();
791       
792       // Set date of my birthday ;-)
793 calGenerate.set(1974, 9, 15, 1, 2, 3);
794       calGenerate.set(Calendar.MILLISECOND, 1);
795             
796       // Make sure we have two separate objects
797 Date dtFirst = new Date (calGenerate.getTimeInMillis());
798
799       calGenerate.set(Calendar.MILLISECOND, 2);
800       Date dtSecond = new Date (calGenerate.getTimeInMillis());
801
802       assertFalse("Two times differ in millisecond and are not be the same: "
803                          + m_dateTimeFormat.format(dtFirst)
804                          + "(" + dtFirst.getTime() + ") and "
805                          + m_dateTimeFormat.format(dtSecond)
806                          + "(" + dtSecond.getTime() + ")",
807                          DateUtils.timeEquals(dtFirst, dtSecond, false));
808    }
809
810    /**
811     * Test comparison of two times which differ in milliseconds and ignoring
812     * the milliseconds.
813     */
814    public void testTimeEqualsWithMilliDiffIgnored(
815    )
816    {
817       Calendar calGenerate = Calendar.getInstance();
818       
819       // Set date of my birthday ;-)
820 calGenerate.set(1974, 9, 15, 1, 2, 3);
821       calGenerate.set(Calendar.MILLISECOND, 1);
822             
823       // Make sure we have two separate objects
824 Date dtFirst = new Date (calGenerate.getTimeInMillis());
825
826       calGenerate.set(Calendar.MILLISECOND, 2);
827       Date dtSecond = new Date (calGenerate.getTimeInMillis());
828
829       assertTrue("Two times differ in millisecond but when ignoring milliseconds" +
830                         " they should be the same: "
831                         + m_dateTimeFormat.format(dtFirst)
832                         + "(" + dtFirst.getTime() + ") and "
833                         + m_dateTimeFormat.format(dtSecond)
834                         + "(" + dtSecond.getTime() + ")",
835                         DateUtils.timeEquals(dtFirst, dtSecond, true));
836    }
837
838    /**
839     * Test comparison of two dates which differ in seconds.
840     */
841    public void testTimeEqualsWithSecondDiff(
842    )
843    {
844       Calendar calGenerate = Calendar.getInstance();
845       
846       // Set date of my birthday ;-)
847 calGenerate.set(1974, 9, 15, 1, 2, 3);
848             
849       // Make sure we have two separate objects
850 Date dtFirst = new Date (calGenerate.getTimeInMillis());
851
852       calGenerate.set(Calendar.SECOND, 4);
853       Date dtSecond = new Date (calGenerate.getTimeInMillis());
854
855       assertFalse("Two times differ in second and are not the same: "
856                          + m_dateTimeFormat.format(dtFirst)
857                          + "(" + dtFirst.getTime() + ") and "
858                          + m_dateTimeFormat.format(dtSecond)
859                          + "(" + dtSecond.getTime() + ")",
860                          DateUtils.timeEquals(dtFirst, dtSecond, false));
861    }
862
863    /**
864     * Test comparison of two times which differ in minutes.
865     */
866    public void testTimeEqualsWithMinuteDiff(
867    )
868    {
869       Calendar calGenerate = Calendar.getInstance();
870       
871       // Set date of my birthday ;-)
872 calGenerate.set(1974, 9, 15, 1, 2, 3);
873             
874       // Make sure we have two separate objects
875 Date dtFirst = new Date (calGenerate.getTimeInMillis());
876
877       calGenerate.set(Calendar.MINUTE, 3);
878       Date dtSecond = new Date (calGenerate.getTimeInMillis());
879
880       assertFalse("Two times differ in minute and are not the same: "
881                          + m_dateTimeFormat.format(dtFirst)
882                          + "(" + dtFirst.getTime() + ") and "
883                          + m_dateTimeFormat.format(dtSecond)
884                          + "(" + dtSecond.getTime() + ")",
885                          DateUtils.timeEquals(dtFirst, dtSecond, false));
886    }
887
888    /**
889     * Test comparison of two times which differ in hours.
890     */
891    public void testTimeEqualsWithHourDiff(
892    )
893    {
894       Calendar calGenerate = Calendar.getInstance();
895       
896       // Set date of my birthday ;-)
897 calGenerate.set(1974, 9, 15, 1, 2, 3);
898             
899       // Make sure we have two separate objects
900 Date dtFirst = new Date (calGenerate.getTimeInMillis());
901
902       // Use 13 to check if 1AM and 1PM are different
903 calGenerate.set(Calendar.HOUR_OF_DAY, 13);
904       Date dtSecond = new Date (calGenerate.getTimeInMillis());
905
906       assertFalse("Two times differ in hour and are not the same: "
907                          + m_dateTimeFormat.format(dtFirst)
908                          + "(" + dtFirst.getTime() + ") and "
909                          + m_dateTimeFormat.format(dtSecond)
910                          + "(" + dtSecond.getTime() + ")",
911                          DateUtils.timeEquals(dtFirst, dtSecond, false));
912    }
913
914    /**
915     * Test comparison of two times which differ in day.
916     */
917    public void testTimeEqualsWithDayDiff(
918    )
919    {
920       Calendar calGenerate = Calendar.getInstance();
921       
922       // Set date of my birthday ;-)
923 calGenerate.set(1974, 9, 15, 1, 2, 3);
924             
925       // Make sure we have two separate objects
926 Date dtFirst = new Date (calGenerate.getTimeInMillis());
927
928       calGenerate.set(Calendar.DATE, 16);
929       Date dtSecond = new Date (calGenerate.getTimeInMillis());
930
931       assertTrue("Two times differ in day and must be the same: "
932                         + m_dateTimeFormat.format(dtFirst)
933                         + "(" + dtFirst.getTime() + ") and "
934                         + m_dateTimeFormat.format(dtSecond)
935                         + "(" + dtSecond.getTime() + ")",
936                         DateUtils.timeEquals(dtFirst, dtSecond, false));
937    }
938
939    /**
940     * Test comparison of two dates which differ in month.
941     */
942    public void testTimeEqualsWithMonthDiff(
943    )
944    {
945       Calendar calGenerate = Calendar.getInstance();
946       
947       // Set date of my birthday ;-)
948 calGenerate.set(1974, 9, 15, 1, 2, 3);
949             
950       // Make sure we have two separate objects
951 Date dtFirst = new Date (calGenerate.getTimeInMillis());
952
953       calGenerate.set(Calendar.MONTH, 10);
954       Date dtSecond = new Date (calGenerate.getTimeInMillis());
955
956       assertTrue("Two times differ in month and must be the same: "
957                         + m_dateTimeFormat.format(dtFirst)
958                         + "(" + dtFirst.getTime() + ") and "
959                         + m_dateTimeFormat.format(dtSecond)
960                         + "(" + dtSecond.getTime() + ")",
961                         DateUtils.timeEquals(dtFirst, dtSecond, false));
962    }
963
964    /**
965     * Test comparison of two dates which differ in year.
966     */
967    public void testTimeEqualsWithYearDiff(
968    )
969    {
970       Calendar calGenerate = Calendar.getInstance();
971       
972       // Set date of my birthday ;-)
973 calGenerate.set(1974, 9, 15, 1, 2, 3);
974             
975       // Make sure we have two separate objects
976 Date dtFirst = new Date (calGenerate.getTimeInMillis());
977
978       calGenerate.set(Calendar.YEAR, 1975);
979       Date dtSecond = new Date (calGenerate.getTimeInMillis());
980
981       assertTrue("Two times differ in year and must be the same: "
982                         + m_dateTimeFormat.format(dtFirst)
983                         + "(" + dtFirst.getTime() + ") and "
984                         + m_dateTimeFormat.format(dtSecond)
985                         + "(" + dtSecond.getTime() + ")",
986                         DateUtils.timeEquals(dtFirst, dtSecond, false));
987    }
988
989    /**
990     * Test comparison of two dates which differ in era.
991     */
992    public void testTimeEqualsWithEraDiff(
993    )
994    {
995       Calendar calGenerate = Calendar.getInstance();
996       
997       // Set date of my birthday ;-)
998 calGenerate.set(1974, 9, 15, 1, 2, 3);
999             
1000      // Make sure we have two separate objects
1001 Date dtFirst = new Date (calGenerate.getTimeInMillis());
1002
1003      calGenerate.set(Calendar.ERA, GregorianCalendar.BC);
1004      Date dtSecond = new Date (calGenerate.getTimeInMillis());
1005
1006      assertTrue("Two times differ in era and must be different: "
1007                        + m_dateTimeFormat.format(dtFirst)
1008                        + "(" + dtFirst.getTime() + ") and "
1009                        + m_dateTimeFormat.format(dtSecond)
1010                        + "(" + dtSecond.getTime() + ")",
1011                        DateUtils.timeEquals(dtFirst, dtSecond, false));
1012   }
1013}
1014

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags