1/*
2 *  Licensed to the Apache Software Foundation (ASF) under one or more
3 *  contributor license agreements.  See the NOTICE file distributed with
4 *  this work for additional information regarding copyright ownership.
5 *  The ASF licenses this file to You under the Apache License, Version 2.0
6 *  (the "License"); you may not use this file except in compliance with
7 *  the License.  You may obtain a copy of the License at
8 *
9 *     http://www.apache.org/licenses/LICENSE-2.0
10 *
11 *  Unless required by applicable law or agreed to in writing, software
12 *  distributed under the License is distributed on an "AS IS" BASIS,
13 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 *  See the License for the specific language governing permissions and
15 *  limitations under the License.
16 */
17
18package org.apache.harmony.tests.java.util;
19
20import java.text.DateFormat;
21import java.util.Calendar;
22import java.util.Date;
23import java.util.GregorianCalendar;
24import java.util.Locale;
25import java.util.TimeZone;
26
27public class DateTest extends junit.framework.TestCase {
28
29    /**
30     * java.util.Date#Date()
31     */
32    public void test_Constructor() {
33        // Test for method java.util.Date()
34        GregorianCalendar gc = new GregorianCalendar(1998, Calendar.OCTOBER,
35                13, 19, 9);
36        long oldTime = gc.getTime().getTime();
37        long now = new Date().getTime();
38        assertTrue("Created incorrect date: " + oldTime + " now: " + now,
39                oldTime < now);
40    }
41
42    /**
43     * java.util.Date#Date(int, int, int)
44     */
45    public void test_ConstructorIII() {
46        // Test for method java.util.Date(int, int, int)
47        Date d1 = new Date(70, 0, 1); // the epoch + local time
48
49        // the epoch + local time
50        Date d2 = new Date(0 + d1.getTimezoneOffset() * 60 * 1000);
51
52        assertTrue("Created incorrect date", d1.equals(d2));
53
54        Date date = new Date(99, 5, 22);
55        Calendar cal = new GregorianCalendar(1999, Calendar.JUNE, 22);
56        assertTrue("Wrong time zone", date.equals(cal.getTime()));
57    }
58
59    /**
60     * java.util.Date#Date(int, int, int, int, int)
61     */
62    public void test_ConstructorIIIII() {
63        // Test for method java.util.Date(int, int, int, int, int)
64
65        // the epoch + local time + (1 hour and 1 minute)
66        Date d1 = new Date(70, 0, 1, 1, 1);
67
68        // the epoch + local time + (1 hour and 1 minute)
69        Date d2 = new Date(0 + d1.getTimezoneOffset() * 60 * 1000 + 60 * 60
70                * 1000 + 60 * 1000);
71
72        assertTrue("Created incorrect date", d1.equals(d2));
73    }
74
75    /**
76     * java.util.Date#Date(int, int, int, int, int, int)
77     */
78    public void test_ConstructorIIIIII() {
79        // Test for method java.util.Date(int, int, int, int, int, int)
80
81        // the epoch + local time + (1 hour and 1 minute + 1 second)
82        Date d1 = new Date(70, 0, 1, 1, 1, 1);
83
84        // the epoch + local time + (1 hour and 1 minute + 1 second)
85        Date d2 = new Date(0 + d1.getTimezoneOffset() * 60 * 1000 + 60 * 60
86                * 1000 + 60 * 1000 + 1000);
87
88        assertTrue("Created incorrect date", d1.equals(d2));
89    }
90
91    /**
92     * java.util.Date#Date(java.lang.String)
93     */
94    public void test_ConstructorLjava_lang_String() {
95        // Test for method java.util.Date(java.lang.String)
96        Date d1 = new Date("January 1, 1970, 00:00:00 GMT"); // the epoch
97        Date d2 = new Date(0); // the epoch
98        assertTrue("Created incorrect date", d1.equals(d2));
99
100        try {
101            // Regression for HARMONY-238
102            new Date(null);
103            fail("Constructor Date((String)null) should "
104                    + "throw IllegalArgumentException");
105        } catch (IllegalArgumentException e) {
106            // expected
107        }
108    }
109
110    /**
111     * java.util.Date#after(java.util.Date)
112     */
113    public void test_afterLjava_util_Date() {
114        // Test for method boolean java.util.Date.after(java.util.Date)
115        Date d1 = new Date(0);
116        Date d2 = new Date(1900000);
117        assertTrue("Older was returned as newer", d2.after(d1));
118        assertTrue("Newer was returned as older", !d1.after(d2));
119
120        try {
121            d1.after(null);
122            fail("NullPointerException expected");
123        } catch (NullPointerException e) {
124            //expected
125        }
126    }
127
128    /**
129     * java.util.Date#before(java.util.Date)
130     */
131    public void test_beforeLjava_util_Date() {
132        // Test for method boolean java.util.Date.before(java.util.Date)
133        Date d1 = new Date(0);
134        Date d2 = new Date(1900000);
135        assertTrue("Older was returned as newer", !d2.before(d1));
136        assertTrue("Newer was returned as older", d1.before(d2));
137
138        try {
139            d1.before(null);
140            fail("NullPointerException expected");
141        } catch (NullPointerException e) {
142            //expected
143        }
144    }
145
146    /**
147     * java.util.Date#clone()
148     */
149    public void test_clone() {
150        // Test for method java.lang.Object java.util.Date.clone()
151        Date d1 = new Date(100000);
152        Date d2 = (Date) d1.clone();
153        assertTrue(
154                "Cloning date results in same reference--new date is equivalent",
155                d1 != d2);
156        assertTrue("Cloning date results unequal date", d1.equals(d2));
157    }
158
159    /**
160     * java.util.Date#compareTo(java.util.Date)
161     */
162    public void test_compareToLjava_util_Date() {
163        // Test for method int java.util.Date.compareTo(java.util.Date)
164        final int someNumber = 10000;
165        Date d1 = new Date(someNumber);
166        Date d2 = new Date(someNumber);
167        Date d3 = new Date(someNumber + 1);
168        Date d4 = new Date(someNumber - 1);
169        assertEquals("Comparing a date to itself did not answer zero", 0, d1
170                .compareTo(d1));
171        assertEquals("Comparing equal dates did not answer zero", 0, d1
172                .compareTo(d2));
173        assertEquals("date1.compareTo(date2), where date1 > date2, did not result in 1",
174                1, d1.compareTo(d4));
175        assertEquals("date1.compareTo(date2), where date1 < date2, did not result in -1",
176                -1, d1.compareTo(d3));
177
178        try {
179            d1.compareTo(null);
180            fail("NullPointerException expected");
181        } catch (NullPointerException e) {
182            //expected
183        }
184    }
185
186    /**
187     * java.util.Date#equals(java.lang.Object)
188     */
189    public void test_equalsLjava_lang_Object() {
190        // Test for method boolean java.util.Date.equals(java.lang.Object)
191        Date d1 = new Date(0);
192        Date d2 = new Date(1900000);
193        Date d3 = new Date(1900000);
194        assertTrue("Equality test failed", d2.equals(d3));
195        assertTrue("Equality test failed", !d1.equals(d2));
196    }
197
198    /**
199     * java.util.Date#getDate()
200     */
201    public void test_getDate() {
202        // Test for method int java.util.Date.getDate()
203        Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9)
204                .getTime();
205        assertEquals("Returned incorrect date", 13, d.getDate());
206    }
207
208    /**
209     * java.util.Date#getDay()
210     */
211    public void test_getDay() {
212        // Test for method int java.util.Date.getDay()
213        Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9)
214                .getTime();
215        assertEquals("Returned incorrect day", 2, d.getDay());
216    }
217
218    /**
219     * java.util.Date#getHours()
220     */
221    public void test_getHours() {
222        // Test for method int java.util.Date.getHours()
223        Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9)
224                .getTime();
225        assertEquals("Returned incorrect hours", 19, d.getHours());
226    }
227
228    /**
229     * java.util.Date#getMinutes()
230     */
231    public void test_getMinutes() {
232        // Test for method int java.util.Date.getMinutes()
233        Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9)
234                .getTime();
235        assertEquals("Returned incorrect minutes", 9, d.getMinutes());
236    }
237
238    /**
239     * java.util.Date#getMonth()
240     */
241    public void test_getMonth() {
242        // Test for method int java.util.Date.getMonth()
243        Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9)
244                .getTime();
245        assertEquals("Returned incorrect month", 9, d.getMonth());
246    }
247
248    /**
249     * java.util.Date#getSeconds()
250     */
251    public void test_getSeconds() {
252        // Test for method int java.util.Date.getSeconds()
253        Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9)
254                .getTime();
255        assertEquals("Returned incorrect seconds", 0, d.getSeconds());
256    }
257
258    /**
259     * java.util.Date#getTime()
260     */
261    public void test_getTime() {
262        // Test for method long java.util.Date.getTime()
263        Date d1 = new Date(0);
264        Date d2 = new Date(1900000);
265        assertEquals("Returned incorrect time", 1900000, d2.getTime());
266        assertEquals("Returned incorrect time", 0, d1.getTime());
267    }
268
269    /**
270     * java.util.Date#getTimezoneOffset()
271     */
272    public void test_getTimezoneOffset() {
273        // Test for method int java.util.Date.getTimezoneOffset()
274        assertTrue("Used to test", true);
275    }
276
277    /**
278     * java.util.Date#getYear()
279     */
280    public void test_getYear() {
281        // Test for method int java.util.Date.getYear()
282        Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9)
283                .getTime();
284        assertEquals("Returned incorrect year", 98, d.getYear());
285    }
286
287    /**
288     * java.util.Date#hashCode()
289     */
290    public void test_hashCode() {
291        // Test for method int java.util.Date.hashCode()
292        Date d1 = new Date(0);
293        Date d2 = new Date(1900000);
294        assertEquals("Returned incorrect hash", 1900000, d2.hashCode());
295        assertEquals("Returned incorrect hash", 0, d1.hashCode());
296    }
297
298    /**
299     * java.util.Date#parse(java.lang.String)
300     */
301    public void test_parseLjava_lang_String() {
302        // Test for method long java.util.Date.parse(java.lang.String)
303        Date d = new Date(Date.parse("13 October 1998"));
304        GregorianCalendar cal = new GregorianCalendar();
305        cal.setTime(d);
306        assertEquals("Parsed incorrect month", 9, cal.get(Calendar.MONTH));
307        assertEquals("Parsed incorrect year", 1998, cal.get(Calendar.YEAR));
308        assertEquals("Parsed incorrect date", 13, cal.get(Calendar.DATE));
309
310        d = new Date(Date.parse("Jan-12 1999"));
311        assertTrue("Wrong parsed date 1", d.equals(new GregorianCalendar(1999,
312                0, 12).getTime()));
313        d = new Date(Date.parse("Jan12-1999"));
314        assertTrue("Wrong parsed date 2", d.equals(new GregorianCalendar(1999,
315                0, 12).getTime()));
316        d = new Date(Date.parse("Jan12 69-1"));
317        cal.setTimeZone(TimeZone.getTimeZone("GMT"));
318        cal.clear();
319        cal.set(1969, Calendar.JANUARY, 12, 1, 0);
320        assertTrue("Wrong parsed date 3", d.equals(cal.getTime()));
321        d = new Date(Date.parse("6:45:13 3/2/1200 MST"));
322        cal.setTimeZone(TimeZone.getTimeZone("MST"));
323        cal.clear();
324        cal.set(1200, 2, 2, 6, 45, 13);
325        assertTrue("Wrong parsed date 4", d.equals(cal.getTime()));
326        d = new Date(Date.parse("Mon, 22 Nov 1999 12:52:06 GMT"));
327        cal.setTimeZone(TimeZone.getTimeZone("GMT"));
328        cal.clear();
329        cal.set(1999, Calendar.NOVEMBER, 22, 12, 52, 06);
330        assertTrue("Wrong parsed date 5", d.equals(cal.getTime()));
331
332        try {
333            // Regression for HARMONY-259
334            Date.parse(null);
335            fail("Date.parse(null) should throw IllegalArgumentException");
336        } catch (IllegalArgumentException e) {
337            // expected
338        }
339
340        // Regression for HARMONY-102
341        assertEquals("Assert 0: parse failure",
342                -5400000, Date.parse("Sat, 1 Jan 1970 +0130 00:00:00"));
343        assertEquals("Assert 1: parse failure",
344                858600000, Date.parse("00:00:00 GMT +0130 Sat, 11 Jan 1970"));
345    }
346
347    /**
348     * java.util.Date#setDate(int)
349     */
350    public void test_setDateI() {
351        // Test for method void java.util.Date.setDate(int)
352        Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9)
353                .getTime();
354        d.setDate(23);
355        assertEquals("Set incorrect date", 23, d.getDate());
356    }
357
358    /**
359     * java.util.Date#setHours(int)
360     */
361    public void test_setHoursI() {
362        // Test for method void java.util.Date.setHours(int)
363        Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9)
364                .getTime();
365        d.setHours(23);
366        assertEquals("Set incorrect hours", 23, d.getHours());
367    }
368
369    /**
370     * java.util.Date#setMinutes(int)
371     */
372    public void test_setMinutesI() {
373        // Test for method void java.util.Date.setMinutes(int)
374        Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9)
375                .getTime();
376        d.setMinutes(45);
377        assertEquals("Set incorrect mins", 45, d.getMinutes());
378    }
379
380    /**
381     * java.util.Date#setMonth(int)
382     */
383    public void test_setMonthI() {
384        // Test for method void java.util.Date.setMonth(int)
385        Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9)
386                .getTime();
387        d.setMonth(0);
388        assertEquals("Set incorrect month", 0, d.getMonth());
389    }
390
391    /**
392     * java.util.Date#setSeconds(int)
393     */
394    public void test_setSecondsI() {
395        // Test for method void java.util.Date.setSeconds(int)
396        Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9)
397                .getTime();
398        d.setSeconds(13);
399        assertEquals("Set incorrect seconds", 13, d.getSeconds());
400    }
401
402    /**
403     * java.util.Date#setTime(long)
404     */
405    public void test_setTimeJ() {
406        // Test for method void java.util.Date.setTime(long)
407        Date d1 = new Date(0);
408        Date d2 = new Date(1900000);
409        d1.setTime(900);
410        d2.setTime(890000);
411        assertEquals("Returned incorrect time", 890000, d2.getTime());
412        assertEquals("Returned incorrect time", 900, d1.getTime());
413    }
414
415    /**
416     * java.util.Date#setYear(int)
417     */
418    public void test_setYearI() {
419        // Test for method void java.util.Date.setYear(int)
420        Date d = new GregorianCalendar(1998, Calendar.OCTOBER, 13, 19, 9)
421                .getTime();
422        d.setYear(8);
423        assertEquals("Set incorrect year", 8, d.getYear());
424    }
425
426    /**
427     * java.util.Date#toGMTString()
428     */
429    public void test_toGMTString() {
430        // Test for method java.lang.String java.util.Date.toGMTString()
431        assertEquals("Did not convert epoch to GMT string correctly", "1 Jan 1970 00:00:00 GMT", new Date(0)
432                .toGMTString());
433        assertEquals("Did not convert epoch + 1yr to GMT string correctly",
434                "1 Jan 1971 00:00:00 GMT", new Date((long) 365 * 24 * 60 * 60 * 1000).toGMTString()
435        );
436    }
437
438    /**
439     * java.util.Date#toString()
440     */
441    public void test_toString() {
442        // Test for method java.lang.String java.util.Date.toString()
443        Calendar cal = Calendar.getInstance();
444        cal.set(Calendar.DATE, 1);
445        cal.set(Calendar.MONTH, Calendar.JANUARY);
446        cal.set(Calendar.YEAR, 1970);
447        cal.set(Calendar.HOUR_OF_DAY, 0);
448        cal.set(Calendar.MINUTE, 0);
449        cal.set(Calendar.SECOND, 0);
450        Date d = cal.getTime();
451        String result = d.toString();
452        assertTrue("Incorrect result: " + d, result
453                .startsWith("Thu Jan 01 00:00:00")
454                && result.endsWith("1970"));
455
456        TimeZone tz = TimeZone.getDefault();
457        TimeZone.setDefault(TimeZone.getTimeZone("GMT-5"));
458        try {
459            Date d1 = new Date(0);
460            assertTrue("Returned incorrect string: " + d1, d1.toString()
461                    .equals("Wed Dec 31 19:00:00 GMT-05:00 1969"));
462        } finally {
463            TimeZone.setDefault(tz);
464        }
465
466        // Test for HARMONY-5468
467        TimeZone.setDefault(TimeZone.getTimeZone("MST"));
468        Date d2 = new Date(108, 7, 27);
469        assertTrue("Returned incorrect string: " + d2, d2.toString()
470                .startsWith("Wed Aug 27 00:00:00")
471                && d2.toString().endsWith("2008"));
472    }
473
474    /**
475     * java.util.Date#UTC(int, int, int, int, int, int)
476     */
477    public void test_UTCIIIIII() {
478        // Test for method long java.util.Date.UTC(int, int, int, int, int, int)
479        assertTrue("Returned incorrect UTC value for epoch", Date.UTC(70, 0, 1,
480                0, 0, 0) == (long) 0);
481        assertTrue("Returned incorrect UTC value for epoch +1yr", Date.UTC(71,
482                0, 1, 0, 0, 0) == (long) 365 * 24 * 60 * 60 * 1000);
483    }
484    /**
485     * java.util.Date#toLocaleString() Test for method java.lang.String
486     *        java.util.Date.toGMTString()
487     */
488    public void test_toLocaleString() {
489        Locale loc = Locale.getDefault();
490        Locale.setDefault(Locale.US);
491        TimeZone tz = TimeZone.getDefault();
492        TimeZone.setDefault(TimeZone.getTimeZone("GMT"));
493        // This test assumes a default DateFormat.is24Hour setting.
494        DateFormat.is24Hour = null;
495        try {
496            assertEquals("Did not convert epoch to GMT string correctly", "Jan 1, 1970 12:00:00 AM",
497                    new Date(0).toLocaleString());
498            assertEquals("Did not convert epoch + 1yr to GMT string correctly",
499                    "Jan 1, 1971 12:00:00 AM",
500                    new Date((long)365 * 24 * 60 * 60 * 1000).toLocaleString());
501        } finally {
502            Locale.setDefault(loc);
503            TimeZone.setDefault(tz);
504        }
505    }
506
507    static TimeZone defaultTimeZone = TimeZone.getDefault();
508
509    /**
510     * Sets up the fixture, for example, open a network connection. This method
511     * is called before a test is executed.
512     */
513    protected void setUp() {
514    }
515
516    /**
517     * Tears down the fixture, for example, close a network connection. This
518     * method is called after a test is executed.
519     */
520    protected void tearDown() {
521        TimeZone.setDefault(defaultTimeZone);
522    }
523}
524