CalendarTest.java revision 8ba0b9bad4ee13bb30fa75c531921802c05611ac
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 tests.api.java.util;
19
20import dalvik.annotation.TestLevel;
21import dalvik.annotation.TestTargetClass;
22import dalvik.annotation.TestTargetNew;
23import dalvik.annotation.TestTargets;
24import tests.support.Support_Locale;
25
26import java.util.Calendar;
27import java.util.Date;
28import java.util.Locale;
29import java.util.TimeZone;
30
31@TestTargetClass(Calendar.class)
32public class CalendarTest extends junit.framework.TestCase {
33
34    Locale defaultLocale;
35
36    /**
37     * @tests java.util.Calendar#set(int, int)
38     */
39    @TestTargetNew(
40        level = TestLevel.COMPLETE,
41        notes = "",
42        method = "set",
43        args = {int.class, int.class}
44    )
45    public void test_setII() {
46        // Test for correct result defined by the last set field
47        Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("EST"));
48
49        cal.clear();
50        cal.set(Calendar.YEAR, 2002);
51        assertTrue("Incorrect result 0: " + cal.getTime().getTime(), cal
52                .getTime().getTime() == 1009861200000L);
53
54        cal.clear();
55        cal.set(Calendar.YEAR, 2002);
56        cal.set(Calendar.MONTH, Calendar.MARCH);
57        assertTrue("Incorrect result 0a: " + cal.getTime(), cal.getTime()
58                .getTime() == 1014958800000L);
59
60        cal.clear();
61        cal.set(Calendar.YEAR, 2002);
62        cal.set(Calendar.DATE, 24);
63        assertTrue("Incorrect result 0b: " + cal.getTime(), cal.getTime()
64                .getTime() == 1011848400000L);
65
66        cal.set(Calendar.MONTH, Calendar.OCTOBER);
67        cal.set(Calendar.DATE, 31);
68        cal.set(Calendar.MONTH, Calendar.NOVEMBER);
69        cal.set(Calendar.DATE, 26);
70        assertTrue("Incorrect month: " + cal.get(Calendar.MONTH), cal
71                .get(Calendar.MONTH) == Calendar.NOVEMBER);
72
73        int dow = cal.get(Calendar.DAY_OF_WEEK);
74        cal.set(Calendar.DATE, 27);
75        assertTrue("Incorrect DAY_OF_WEEK: " + cal.get(Calendar.DAY_OF_WEEK)
76                + " expected: " + dow, cal.get(Calendar.DAY_OF_WEEK) != dow);
77
78        cal.clear();
79        cal.set(Calendar.YEAR, 2002);
80        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
81        assertTrue("Incorrect result 0c1: " + cal.getTime().getTime(), cal
82                .getTime().getTime() == 1010379600000L);
83
84        cal.clear();
85        cal.set(Calendar.YEAR, 2002);
86        cal.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
87        assertTrue("Incorrect result 0c2: " + cal.getTime().getTime(), cal
88                .getTime().getTime() == 1009861200000L);
89
90        cal.clear();
91        cal.set(Calendar.YEAR, 2002);
92        cal.set(Calendar.DAY_OF_WEEK, Calendar.THURSDAY);
93        assertTrue("Incorrect result 0c3: " + cal.getTime(), cal.getTime()
94                .getTime() == 1010034000000L);
95
96        cal.clear();
97        cal.set(Calendar.YEAR, 2002);
98        cal.set(Calendar.WEEK_OF_MONTH, 2);
99        assertTrue("Incorrect result 0d: " + cal.getTime(), cal.getTime()
100                .getTime() == 1010293200000L);
101
102        cal.clear();
103        cal.set(Calendar.YEAR, 2002);
104        cal.set(Calendar.DAY_OF_WEEK_IN_MONTH, 2);
105        assertTrue("Incorrect result 0e: " + cal.getTime(), cal.getTime()
106                .getTime() == 1010898000000L);
107
108        cal.clear();
109        cal.set(Calendar.YEAR, 2002);
110        cal.set(Calendar.WEEK_OF_YEAR, 11);
111        assertTrue("Incorrect result 0f: " + cal.getTime(), cal.getTime()
112                .getTime() == 1015736400000L);
113
114        cal.clear();
115        cal.set(Calendar.YEAR, 2002);
116        cal.set(Calendar.DATE, 24);
117        cal.set(Calendar.WEEK_OF_YEAR, 11);
118        assertTrue("Incorrect result 0g: " + cal.getTime(), cal.getTime()
119                .getTime() == 1011848400000L);
120
121        cal.clear();
122        cal.set(Calendar.YEAR, 2002);
123        cal.get(Calendar.WEEK_OF_YEAR); // Force fields to compute
124        cal.set(Calendar.WEEK_OF_YEAR, 11);
125        assertTrue("Incorrect result 0h: " + cal.getTime(), cal.getTime()
126                .getTime() == 1015909200000L);
127
128        // WEEK_OF_YEAR has priority over MONTH/DATE
129        cal.clear();
130        cal.set(Calendar.YEAR, 2002);
131        cal.set(Calendar.DAY_OF_YEAR, 170);
132        cal.set(Calendar.WEEK_OF_YEAR, 11);
133        cal.set(Calendar.MONTH, Calendar.JANUARY);
134        cal.set(Calendar.DATE, 5);
135        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
136        assertTrue("Incorrect result 1: " + cal.getTime(), cal.getTime()
137                .getTime() == 1015822800000L);
138
139        // WEEK_OF_YEAR has priority over MONTH/DATE
140        cal.clear();
141        cal.set(Calendar.YEAR, 2002);
142        cal.set(Calendar.WEEK_OF_YEAR, 11);
143        cal.set(Calendar.MONTH, Calendar.JANUARY);
144        cal.set(Calendar.DATE, 5);
145        cal.set(Calendar.DAY_OF_YEAR, 170);
146        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
147        assertTrue("Incorrect result 1a: " + cal.getTime(), cal.getTime()
148                .getTime() == 1015822800000L);
149
150        // DAY_OF_WEEK has no effect when other fields not set
151        cal.clear();
152        cal.set(Calendar.YEAR, 2002);
153        cal.set(Calendar.MONTH, Calendar.MARCH);
154        cal.set(Calendar.DATE, 11);
155        cal.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
156        assertTrue("Incorrect result 1b: " + cal.getTime(), cal.getTime()
157                .getTime() == 1015822800000L);
158
159        // WEEK_OF_MONTH has priority
160        cal.clear();
161        cal.set(Calendar.YEAR, 2002);
162        cal.set(Calendar.WEEK_OF_YEAR, 12);
163        cal.set(Calendar.DAY_OF_WEEK_IN_MONTH, 1);
164        cal.set(Calendar.WEEK_OF_MONTH, 3);
165        cal.set(Calendar.MONTH, Calendar.MARCH);
166        cal.set(Calendar.DATE, 5);
167        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
168        assertTrue("Incorrect result 2: " + cal.getTime(), cal.getTime()
169                .getTime() == 1015822800000L);
170
171        // DAY_OF_WEEK_IN_MONTH has priority over WEEK_OF_YEAR
172        cal.clear();
173        cal.set(Calendar.YEAR, 2002);
174        cal.set(Calendar.WEEK_OF_YEAR, 12);
175        cal.set(Calendar.DAY_OF_WEEK_IN_MONTH, 2);
176        cal.set(Calendar.MONTH, Calendar.MARCH);
177        cal.set(Calendar.DATE, 5);
178        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
179        assertTrue("Incorrect result 3: " + cal.getTime(), cal.getTime()
180                .getTime() == 1015822800000L);
181
182        // WEEK_OF_MONTH has priority, MONTH not set
183        cal.clear();
184        cal.set(Calendar.YEAR, 2002);
185        cal.set(Calendar.WEEK_OF_YEAR, 12);
186        cal.set(Calendar.DAY_OF_WEEK_IN_MONTH, 1);
187        cal.set(Calendar.WEEK_OF_MONTH, 3);
188        cal.set(Calendar.DATE, 25);
189        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
190        assertTrue("Incorrect result 4: " + cal.getTime(), cal.getTime()
191                .getTime() == 1010984400000L);
192
193        // WEEK_OF_YEAR has priority when MONTH set last and DAY_OF_WEEK set
194        cal.clear();
195        cal.set(Calendar.YEAR, 2002);
196        cal.set(Calendar.WEEK_OF_YEAR, 11);
197        cal.set(Calendar.DATE, 25);
198        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
199        cal.set(Calendar.MONTH, Calendar.JANUARY);
200        assertTrue("Incorrect result 5: " + cal.getTime(), cal.getTime()
201                .getTime() == 1015822800000L);
202
203        // Use MONTH/DATE when WEEK_OF_YEAR set but not DAY_OF_WEEK
204        cal.clear();
205        cal.set(Calendar.YEAR, 2002);
206        cal.set(Calendar.WEEK_OF_YEAR, 12);
207        cal.set(Calendar.DATE, 11);
208        cal.set(Calendar.MONTH, Calendar.MARCH);
209        assertTrue("Incorrect result 5a: " + cal.getTime(), cal.getTime()
210                .getTime() == 1015822800000L);
211
212        // Use MONTH/DATE when DAY_OF_WEEK is not set
213        cal.clear();
214        cal.set(Calendar.YEAR, 2002);
215        cal.set(Calendar.WEEK_OF_YEAR, 12);
216        cal.set(Calendar.DATE, 11);
217        cal.set(Calendar.WEEK_OF_MONTH, 1);
218        cal.set(Calendar.MONTH, Calendar.MARCH);
219        assertTrue("Incorrect result 5b: " + cal.getTime(), cal.getTime()
220                .getTime() == 1015822800000L);
221
222        // WEEK_OF_MONTH has priority
223        cal.clear();
224        cal.set(Calendar.YEAR, 2002);
225        cal.set(Calendar.WEEK_OF_YEAR, 12);
226        cal.set(Calendar.DATE, 5);
227        cal.set(Calendar.WEEK_OF_MONTH, 3);
228        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
229        cal.set(Calendar.MONTH, Calendar.MARCH);
230        assertTrue("Incorrect result 5c: " + cal.getTime(), cal.getTime()
231                .getTime() == 1015822800000L);
232
233        // DATE has priority when set last
234        cal.clear();
235        cal.set(Calendar.YEAR, 2002);
236        cal.set(Calendar.WEEK_OF_YEAR, 12);
237        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
238        cal.set(Calendar.MONTH, Calendar.MARCH);
239        cal.set(Calendar.DATE, 11);
240        assertTrue("Incorrect result 6: " + cal.getTime(), cal.getTime()
241                .getTime() == 1015822800000L);
242
243        // DATE has priority when set last, MONTH not set
244        cal.clear();
245        cal.set(Calendar.YEAR, 2002);
246        cal.set(Calendar.WEEK_OF_YEAR, 12);
247        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
248        cal.set(Calendar.DATE, 14);
249        assertTrue("Incorrect result 7: " + cal.getTime(), cal.getTime()
250                .getTime() == 1010984400000L);
251
252        // DAY_OF_YEAR has priority when MONTH set last and DATE not set
253        cal.clear();
254        cal.set(Calendar.YEAR, 2002);
255        cal.set(Calendar.DAY_OF_YEAR, 70);
256        cal.set(Calendar.MONTH, Calendar.JANUARY);
257        assertTrue("Incorrect result 8: " + cal.getTime(), cal.getTime()
258                .getTime() == 1015822800000L);
259
260        // DAY/MONTH has priority when DATE set after DAY_OF_YEAR
261        cal.clear();
262        cal.set(Calendar.YEAR, 2002);
263        cal.set(Calendar.DAY_OF_YEAR, 170);
264        cal.set(Calendar.DATE, 11);
265        cal.set(Calendar.MONTH, Calendar.MARCH);
266        assertTrue("Incorrect result 8a: " + cal.getTime(), cal.getTime()
267                .getTime() == 1015822800000L);
268
269        // DAY_OF_YEAR has priority when set after DATE
270        cal.clear();
271        cal.set(Calendar.YEAR, 2002);
272        cal.set(Calendar.DATE, 15);
273        cal.set(Calendar.DAY_OF_YEAR, 70);
274        cal.set(Calendar.MONTH, Calendar.JANUARY);
275        assertTrue("Incorrect result 8b: " + cal.getTime(), cal.getTime()
276                .getTime() == 1015822800000L);
277
278        // DATE has priority when set last
279        cal.clear();
280        cal.set(Calendar.YEAR, 2002);
281        cal.set(Calendar.DAY_OF_YEAR, 70);
282        cal.set(Calendar.DATE, 14);
283        assertTrue("Incorrect result 9: " + cal.getTime(), cal.getTime()
284                .getTime() == 1010984400000L);
285
286        // DATE has priority when set last
287        cal.clear();
288        cal.set(Calendar.YEAR, 2002);
289        cal.set(Calendar.WEEK_OF_YEAR, 15);
290        cal.set(Calendar.DAY_OF_WEEK, Calendar.THURSDAY);
291        cal.set(Calendar.DATE, 14);
292        assertTrue("Incorrect result 9a: " + cal.getTime(), cal.getTime()
293                .getTime() == 1010984400000L);
294
295        cal.clear();
296        cal.set(Calendar.YEAR, 2002);
297        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
298        cal.set(Calendar.DATE, 14);
299        cal.set(Calendar.WEEK_OF_YEAR, 11);
300        assertTrue("Incorrect result 9b: " + cal.getTime(), cal.getTime()
301                .getTime() == 1015822800000L);
302
303        cal.clear();
304        cal.set(Calendar.YEAR, 2002);
305        cal.set(Calendar.DATE, 14);
306        cal.set(Calendar.WEEK_OF_YEAR, 11);
307        assertTrue("Incorrect result 9c: " + cal.getTime(), cal.getTime()
308                .getTime() == 1010984400000L);
309
310        cal.clear();
311        cal.set(Calendar.YEAR, 2002);
312        cal.set(Calendar.WEEK_OF_MONTH, 1);
313        cal.set(Calendar.DAY_OF_WEEK, Calendar.THURSDAY);
314        cal.set(Calendar.MONTH, Calendar.MARCH);
315        cal.set(Calendar.DATE, 11);
316        assertTrue("Incorrect result 9d: " + cal.getTime(), cal.getTime()
317                .getTime() == 1015822800000L);
318
319        // DAY_OF_YEAR has priority when DAY_OF_MONTH set last and other fields
320        // not set
321        cal.clear();
322        cal.set(Calendar.YEAR, 2002);
323        cal.set(Calendar.DAY_OF_YEAR, 70);
324        cal.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
325        assertTrue("Incorrect result 10: " + cal.getTime(), cal.getTime()
326                .getTime() == 1015822800000L);
327
328        // MONTH/DATE has priority when DAY_OF_WEEK_IN_MONTH set last but
329        // DAY_OF_WEEK not set
330        cal.clear();
331        cal.set(Calendar.YEAR, 2002);
332        cal.set(Calendar.DATE, 11);
333        cal.set(Calendar.MONTH, Calendar.MARCH);
334        cal.set(Calendar.DAY_OF_WEEK_IN_MONTH, 1);
335        assertTrue("Incorrect result 11: " + cal.getTime(), cal.getTime()
336                .getTime() == 1015822800000L);
337
338        // MONTH/DATE has priority when WEEK_OF_YEAR set last but DAY_OF_WEEK
339        // not set
340        cal.clear();
341        cal.set(Calendar.YEAR, 2002);
342        cal.set(Calendar.DATE, 11);
343        cal.set(Calendar.MONTH, Calendar.MARCH);
344        cal.set(Calendar.WEEK_OF_YEAR, 15);
345        assertTrue("Incorrect result 12: " + cal.getTime(), cal.getTime()
346                .getTime() == 1015822800000L);
347
348        // MONTH/DATE has priority when WEEK_OF_MONTH set last but DAY_OF_WEEK
349        // not set
350        cal.clear();
351        cal.set(Calendar.YEAR, 2002);
352        cal.set(Calendar.DATE, 11);
353        cal.set(Calendar.MONTH, Calendar.MARCH);
354        cal.set(Calendar.WEEK_OF_MONTH, 1);
355        assertTrue("Incorrect result 13: " + cal.getTime(), cal.getTime()
356                .getTime() == 1015822800000L);
357
358        // Ensure last date field set is reset after computing
359        cal.clear();
360        cal.set(Calendar.YEAR, 2002);
361        cal.set(Calendar.DAY_OF_YEAR, 111);
362        cal.get(Calendar.YEAR);
363        cal.set(Calendar.MONTH, Calendar.MARCH);
364        cal.set(Calendar.AM_PM, Calendar.AM);
365        assertTrue("Incorrect result 14: " + cal.getTime(), cal.getTime()
366                .getTime() == 1016686800000L);
367
368        int hour = cal.get(Calendar.HOUR);
369        cal.set(Calendar.HOUR, hour);
370        cal.set(Calendar.AM_PM, Calendar.PM);
371        assertEquals("AM_PM not changed", Calendar.PM, cal.get(Calendar.AM_PM));
372        // setting AM_PM without HOUR should not have any affect
373        cal.set(Calendar.AM_PM, Calendar.AM);
374        assertEquals("AM_PM was changed 1",
375                Calendar.AM, cal.get(Calendar.AM_PM));
376        int hourOfDay = cal.get(Calendar.HOUR_OF_DAY);
377        hour = cal.get(Calendar.HOUR);
378        cal.set(Calendar.AM_PM, Calendar.PM);
379        assertEquals("AM_PM was changed 2",
380                Calendar.PM, cal.get(Calendar.AM_PM));
381        assertEquals(hour, cal.get(Calendar.HOUR));
382        assertEquals(hourOfDay + 12, cal.get(Calendar.HOUR_OF_DAY));
383
384        // regression test for Harmony-2122
385        cal = Calendar.getInstance();
386        int oldValue = cal.get(Calendar.AM_PM);
387        int newValue = (oldValue == Calendar.AM) ? Calendar.PM : Calendar.AM;
388        cal.set(Calendar.AM_PM, newValue);
389        newValue = cal.get(Calendar.AM_PM);
390        assertTrue(newValue != oldValue);
391
392        cal.setLenient(false);
393
394        try {
395            cal.set(-1, 3);
396            fail("ArrayIndexOutOfBoundsException expected");
397        } catch (ArrayIndexOutOfBoundsException e) {
398            //expected
399        }
400
401        try {
402            cal.set(Calendar.FIELD_COUNT + 1, 3);
403            fail("ArrayIndexOutOfBoundsException expected");
404        } catch (ArrayIndexOutOfBoundsException e) {
405            //expected
406        }
407    }
408
409    /**
410     * @tests java.util.Calendar#setTime(java.util.Date)
411     */
412    @TestTargetNew(
413        level = TestLevel.COMPLETE,
414        notes = "",
415        method = "setTime",
416        args = {java.util.Date.class}
417    )
418    public void test_setTimeLjava_util_Date() {
419        Calendar cal = Calendar.getInstance();
420        // Use millisecond time for testing in Core
421        cal.setTime(new Date(884581200000L)); // (98, Calendar.JANUARY, 12)
422        assertEquals("incorrect millis", 884581200000L, cal.getTime().getTime());
423        cal.setTimeZone(TimeZone.getTimeZone("EST"));
424        cal.setTime(new Date(943506000000L)); // (99, Calendar.NOVEMBER, 25)
425        assertTrue("incorrect fields", cal.get(Calendar.YEAR) == 1999
426                && cal.get(Calendar.MONTH) == Calendar.NOVEMBER
427                && cal.get(Calendar.DATE) == 25);
428    }
429
430    /**
431     * @tests java.util.Calendar#compareTo(Calendar)
432     */
433    @TestTargetNew(
434        level = TestLevel.PARTIAL_COMPLETE,
435        notes = "Verifies NullPointerException.",
436        method = "compareTo",
437        args = {java.util.Calendar.class}
438    )
439    public void test_compareToLjava_util_Calendar_null() {
440        Calendar cal = Calendar.getInstance();
441        try {
442            cal.compareTo(null);
443            fail("should throw NullPointerException");
444        } catch (NullPointerException e) {
445            // expected
446        }
447    }
448
449    /**
450     * @tests java.util.Calendar#compareTo(Calendar)
451     */
452    @TestTargetNew(
453        level = TestLevel.COMPLETE,
454        notes = "",
455        method = "compareTo",
456        args = {java.util.Calendar.class}
457    )
458    public void test_compareToLjava_util_Calendar() {
459        Calendar cal = Calendar.getInstance();
460        cal.clear();
461        cal.set(1997, 12, 13, 23, 57);
462
463        Calendar anotherCal = Calendar.getInstance();
464        anotherCal.clear();
465        anotherCal.set(1997, 12, 13, 23, 57);
466        assertEquals(0, cal.compareTo(anotherCal));
467
468        anotherCal = Calendar.getInstance();
469        anotherCal.clear();
470        anotherCal.set(1997, 11, 13, 24, 57);
471        assertEquals(1, cal.compareTo(anotherCal));
472
473        anotherCal = Calendar.getInstance();
474        anotherCal.clear();
475        anotherCal.set(1997, 12, 13, 23, 58);
476        assertEquals(-1, cal.compareTo(anotherCal));
477
478        try {
479            cal.compareTo(null);
480            fail("NullPointerException expected");
481        } catch (NullPointerException e) {
482            //expected
483        }
484
485        MockCalendar mc = new MockCalendar();
486
487        try {
488            cal.compareTo(mc);
489            fail("IllegalArgumentException expected");
490        } catch (IllegalArgumentException e) {
491            //expected
492        }
493    }
494
495    /**
496     * @tests java.util.Calendar#clone()
497     */
498    @TestTargetNew(
499        level = TestLevel.COMPLETE,
500        notes = "",
501        method = "clone",
502        args = {}
503    )
504    public void test_clone() {
505        // Regression for HARMONY-475
506        Calendar cal = Calendar.getInstance();
507        cal.set(2006, 5, 6, 11, 35);
508        Calendar anotherCal = (Calendar) cal.clone();
509        // should be deep clone
510        assertNotSame("getTimeZone", cal.getTimeZone(), anotherCal
511                .getTimeZone());
512    }
513
514    /**
515     * @tests java.util.Calendar#getTimeInMillis()
516     */
517    @TestTargetNew(
518        level = TestLevel.COMPLETE,
519        notes = "",
520        method = "getTimeInMillis",
521        args = {}
522    )
523    public void test_getTimeInMillis() {
524        Calendar cal = Calendar.getInstance();
525
526        int year = Integer.MIN_VALUE + 71;
527        cal.setTimeZone(TimeZone.getTimeZone("GMT"));;
528        cal.set(Calendar.YEAR, year + 1900);
529        cal.set(Calendar.MONTH, Calendar.JANUARY);
530        cal.set(Calendar.DATE, 1);
531        cal.set(Calendar.HOUR_OF_DAY, 0);
532        cal.set(Calendar.MINUTE, 0);
533        cal.set(Calendar.SECOND, 0);
534        cal.set(Calendar.MILLISECOND, 0);
535
536        assertEquals(6017546357372606464L, cal.getTimeInMillis());
537    }
538
539    /**
540     * @tests {@link java.util.Calendar#getActualMaximum(int)}
541     */
542    @TestTargetNew(
543        level = TestLevel.COMPLETE,
544        notes = "",
545        method = "getActualMaximum",
546        args = {int.class}
547    )
548    public void test_getActualMaximum_I() {
549        Calendar c = new MockCalendar();
550        assertEquals("should be equal to 0", 0, c.getActualMaximum(0));
551    }
552
553    /**
554     * @tests {@link java.util.Calendar#getActualMinimum(int)}
555     */
556    @TestTargets({
557        @TestTargetNew(
558            level = TestLevel.COMPLETE,
559            notes = "",
560            method = "getActualMinimum",
561            args = {int.class}
562        ),
563        @TestTargetNew(
564            level = TestLevel.COMPLETE,
565            notes = "",
566            method = "Calendar",
567            args = {}
568        )
569    })
570    public void test_getActualMinimum_I() {
571        Calendar c = new MockCalendar();
572        assertEquals("should be equal to 0", 0, c.getActualMinimum(0));
573    }
574
575    private class MockCalendar extends Calendar {
576
577        public MockCalendar() {
578            super();
579        }
580
581        public MockCalendar(TimeZone default1, Locale germany) {
582            super(default1, germany);
583        }
584
585        @Override
586        public void add(int field, int value) {
587        }
588
589        @Override
590        protected void computeFields() {
591        }
592
593        @Override
594        protected void computeTime() {
595            throw new IllegalArgumentException();
596        }
597
598        @Override
599        public int getGreatestMinimum(int field) {
600            return 0;
601        }
602
603        @Override
604        public int getLeastMaximum(int field) {
605            return 0;
606        }
607
608        @Override
609        public int getMaximum(int field) {
610            return 0;
611        }
612
613        @Override
614        public int getMinimum(int field) {
615            return 0;
616        }
617
618        @Override
619        public void roll(int field, boolean increment) {
620        }
621    }
622
623    @TestTargetNew(
624        level = TestLevel.COMPLETE,
625        notes = "",
626        method = "Calendar",
627        args = {java.util.TimeZone.class, java.util.Locale.class}
628    )
629    public void test_ConstructorLjava_utilTimeZoneLjava_util_Locale() {
630        assertNotNull(new MockCalendar(TimeZone.getDefault(), Locale.GERMANY));
631    }
632
633    @TestTargetNew(
634        level = TestLevel.COMPLETE,
635        notes = "Test calls dummy implementation of abstract method.",
636        method = "add",
637        args = {int.class, int.class}
638    )
639    public void test_addII() {
640        MockCalendar mc = new MockCalendar();
641
642        mc.add(Calendar.DAY_OF_YEAR, 7);
643    }
644
645    @TestTargetNew(
646        level = TestLevel.COMPLETE,
647        notes = "",
648        method = "after",
649        args = {java.lang.Object.class}
650    )
651    public void test_afterLjava_lang_Object() {
652        MockCalendar mcBefore = new MockCalendar();
653        MockCalendar mc       = new MockCalendar();
654        MockCalendar mcAfter  = new MockCalendar();
655        MockCalendar mcSame   = new MockCalendar();
656
657        mcBefore.setTimeInMillis(1000);
658        mc.setTimeInMillis(10000);
659        mcAfter.setTimeInMillis(100000);
660        mcSame.setTimeInMillis(10000);
661
662        assertTrue(mc.after(mcBefore));
663        assertFalse(mc.after(mcAfter));
664        assertFalse(mc.after(mcSame));
665        assertFalse(mc.after(mc));
666        assertFalse(mc.after(new String()));
667    }
668
669    @TestTargetNew(
670        level = TestLevel.COMPLETE,
671        notes = "",
672        method = "before",
673        args = {java.lang.Object.class}
674    )
675    public void test_beforeLjava_lang_Object() {
676        MockCalendar mcBefore = new MockCalendar();
677        MockCalendar mc       = new MockCalendar();
678        MockCalendar mcAfter  = new MockCalendar();
679        MockCalendar mcSame   = new MockCalendar();
680
681        mcBefore.setTimeInMillis(1000);
682        mc.setTimeInMillis(10000);
683        mcAfter.setTimeInMillis(100000);
684        mcSame.setTimeInMillis(10000);
685
686        assertFalse(mc.before(mcBefore));
687        assertTrue(mc.before(mcAfter));
688        assertFalse(mc.before(mcSame));
689        assertFalse(mc.before(mc));
690        assertFalse(mc.before(new String()));
691    }
692
693    @TestTargetNew(
694        level = TestLevel.COMPLETE,
695        notes = "",
696        method = "clear",
697        args = {}
698    )
699    public void test_clear() {
700        MockCalendar mc1 = new MockCalendar();
701        MockCalendar mc2 = new MockCalendar();
702
703        assertTrue(mc1.toString().equals(mc2.toString()));
704        mc1.set(2008, Calendar.SEPTEMBER, 23, 18, 0, 0);
705        assertFalse(mc1.toString().equals(mc2.toString()));
706        mc1.clear();
707        assertTrue(mc1.toString().equals(mc2.toString()));
708    }
709
710    @TestTargetNew(
711        level = TestLevel.COMPLETE,
712        notes = "",
713        method = "clear",
714        args = {int.class}
715    )
716    public void test_clearI() {
717        MockCalendar mc1 = new MockCalendar();
718        MockCalendar mc2 = new MockCalendar();
719
720        assertTrue(mc1.toString().equals(mc2.toString()));
721        mc1.set(2008, Calendar.SEPTEMBER, 23, 18, 0, 0);
722        assertFalse(mc1.toString().equals(mc2.toString()));
723        mc1.clear(Calendar.YEAR);
724        mc1.clear(Calendar.MONTH);
725        mc1.clear(Calendar.DAY_OF_MONTH);
726        mc1.clear(Calendar.HOUR_OF_DAY);
727        mc1.clear(Calendar.MINUTE);
728        mc1.clear(Calendar.SECOND);
729        mc1.clear(Calendar.MILLISECOND);
730        assertTrue(mc1.toString().equals(mc2.toString()));
731    }
732
733    class Mock_Calendar extends Calendar {
734        boolean flagComplete = false;
735        @Override
736        public void add(int field, int amount) {
737
738        }
739
740        @Override
741        protected void computeFields() {
742            this.set(MONTH, this.internalGet(MONTH)%12);
743        }
744
745        @Override
746        protected void computeTime() {
747        }
748
749        @Override
750        public int getGreatestMinimum(int field) {
751            return 0;
752        }
753
754        @Override
755        public int getLeastMaximum(int field) {
756            return 0;
757        }
758
759        @Override
760        public int getMaximum(int field) {
761            return 0;
762        }
763
764        @Override
765        public int getMinimum(int field) {
766            return 0;
767        }
768
769        @Override
770        public void roll(int field, boolean up) {
771        }
772
773        @Override
774        public void complete() {
775            computeTime();
776            computeFields();
777            flagComplete = true;
778        }
779
780        public boolean isCompleted () {
781            return flagComplete;
782        }
783
784        public int internalGetField(int field) {
785            return super.internalGet(field);
786        }
787    }
788
789    @TestTargetNew(
790        level = TestLevel.COMPLETE,
791        notes = "",
792        method = "complete",
793        args = {}
794    )
795    public void test_complete() {
796        Mock_Calendar cal = new Mock_Calendar();
797
798        assertFalse(cal.isCompleted());
799        cal.setTimeInMillis(1000);
800        cal.get(Calendar.MONTH);
801        assertTrue(cal.isCompleted());
802    }
803
804    @TestTargetNew(
805        level = TestLevel.COMPLETE,
806        notes = "",
807        method = "computeFields",
808        args = {}
809    )
810    public void test_computeFields() {
811        Calendar cal1 = Calendar.getInstance(TimeZone.getTimeZone("GMT+2"), defaultLocale);
812        Calendar cal2 = Calendar.getInstance(TimeZone.getTimeZone("GMT+2"), defaultLocale);
813
814        cal1.setTimeInMillis(1222185600225L);
815        cal2.set(2008, Calendar.SEPTEMBER, 23, 18, 0, 0);
816        assertFalse(cal1.toString().equals(cal2.toString()));
817        cal1.get(Calendar.YEAR);
818        cal2.getTimeInMillis();
819        cal1.set(Calendar.MILLISECOND, 0);
820        cal2.set(Calendar.MILLISECOND, 0);
821        // tests fails in this line.
822        assertTrue(cal1.toString().equals(cal2.toString()));
823    }
824
825    @TestTargetNew(
826        level = TestLevel.COMPLETE,
827        notes = "",
828        method = "equals",
829        args = {java.lang.Object.class}
830    )
831    public void test_equals() {
832        Calendar cal1 = Calendar.getInstance(TimeZone.getTimeZone("GMT+2"), defaultLocale);
833        Calendar cal2 = Calendar.getInstance(TimeZone.getTimeZone("GMT+2"), defaultLocale);
834
835        cal1.setTimeInMillis(1222185600225L);
836        cal2.set(2008, Calendar.SEPTEMBER, 23, 18, 0, 0);
837        assertFalse(cal1.equals(cal2));
838        cal1.get(Calendar.YEAR);
839        cal2.getTimeInMillis();
840        cal1.set(Calendar.MILLISECOND, 0);
841        cal2.set(Calendar.MILLISECOND, 0);
842        // tests fails on following line.
843        assertTrue(cal1.equals(cal2));
844    }
845
846    @TestTargetNew(
847        level = TestLevel.COMPLETE,
848        notes = "",
849        method = "get",
850        args = {int.class}
851    )
852    public void test_getI() {
853        Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("GMT+2"), defaultLocale);
854
855        cal.setTimeInMillis(1222185600225L);
856        assertEquals(cal.get(Calendar.ERA), 1);
857        assertEquals(cal.get(Calendar.YEAR), 2008);
858        assertEquals(cal.get(Calendar.MONTH), Calendar.SEPTEMBER);
859        assertEquals(cal.get(Calendar.DAY_OF_MONTH), 23);
860        // Following line returns wrong value. Behavior uncompatible with RI.
861        assertEquals(cal.get(Calendar.HOUR_OF_DAY), 18);
862        assertEquals(cal.get(Calendar.MINUTE), 0);
863
864        try {
865            cal.get(-1);
866            fail("ArrayIndexOutOfBoundsException expected");
867        } catch (ArrayIndexOutOfBoundsException e) {
868            //expected
869        }
870
871        try {
872            cal.get(Calendar.FIELD_COUNT + 1);
873            fail("ArrayIndexOutOfBoundsException expected");
874        } catch (ArrayIndexOutOfBoundsException e) {
875            //expected
876        }
877    }
878
879    @TestTargetNew(
880        level = TestLevel.COMPLETE,
881        notes = "",
882        method = "getAvailableLocales",
883        args = {}
884    )
885    public void test_getAvailableLocales() {
886        assertNotNull(Calendar.getAvailableLocales());
887    }
888
889    @TestTargets({
890        @TestTargetNew(
891            level = TestLevel.COMPLETE,
892            notes = "",
893            method = "getFirstDayOfWeek",
894            args = {}
895        ),
896        @TestTargetNew(
897            level = TestLevel.COMPLETE,
898            notes = "",
899            method = "getInstance",
900            args = {}
901        )
902    })
903    public void test_getFirstDayOfWeek() {
904        Locale[] requiredLocales = {Locale.US, Locale.FRANCE};
905        if (!Support_Locale.areLocalesAvailable(requiredLocales)) {
906            // locale dependent test, bug 1943269
907            return;
908        }
909        Calendar cal = Calendar.getInstance();
910
911        assertEquals(Calendar.SUNDAY, cal.getFirstDayOfWeek());
912        Locale.setDefault(Locale.FRANCE);
913        cal = Calendar.getInstance();
914        assertEquals(Calendar.MONDAY, cal.getFirstDayOfWeek());
915        Locale.setDefault(Locale.US);
916    }
917
918    @TestTargetNew(
919        level = TestLevel.COMPLETE,
920        notes = "",
921        method = "getInstance",
922        args = {java.util.Locale.class}
923    )
924    public void test_getInstanceLjava_util_Locale() {
925        Locale[] requiredLocales = {Locale.US, Locale.FRANCE};
926        if (!Support_Locale.areLocalesAvailable(requiredLocales)) {
927            // locale dependent test, bug 1943269
928            return;
929        }
930        Calendar cal1 = Calendar.getInstance(Locale.FRANCE);
931        Locale.setDefault(Locale.FRANCE);
932        Calendar cal2 = Calendar.getInstance();
933        assertSame(cal1.getFirstDayOfWeek(), cal2.getFirstDayOfWeek());
934        Locale.setDefault(Locale.US);
935        cal2 = Calendar.getInstance();
936        assertNotSame(cal1.getFirstDayOfWeek(), cal2.getFirstDayOfWeek());
937    }
938
939    @TestTargetNew(
940        level = TestLevel.COMPLETE,
941        notes = "",
942        method = "getInstance",
943        args = {java.util.TimeZone.class}
944    )
945    public void test_get_InstanceLjava_util_TimeZone() {
946        Calendar cal1 = Calendar.getInstance(TimeZone.getTimeZone("GMT-6"));
947        Calendar cal2 = Calendar.getInstance(TimeZone.getTimeZone("GMT+1"));
948        assertNotSame(cal1.getTimeZone().getRawOffset(), cal2.getTimeZone().getRawOffset());
949    }
950
951    @TestTargetNew(
952        level = TestLevel.COMPLETE,
953        notes = "",
954        method = "getInstance",
955        args = {java.util.TimeZone.class, java.util.Locale.class}
956    )
957    public void test_getInstanceLjava_util_TimeZoneLjava_util_Locale() {
958        Locale[] requiredLocales = {Locale.US, Locale.FRANCE};
959        if (!Support_Locale.areLocalesAvailable(requiredLocales)) {
960            // locale dependent test, bug 1943269
961            return;
962        }
963        Calendar cal1 = Calendar.getInstance(TimeZone.getTimeZone("GMT-6"), Locale.FRANCE);
964        Locale.setDefault(Locale.FRANCE);
965        Calendar cal2 = Calendar.getInstance(TimeZone.getTimeZone("GMT+1"));
966        assertSame(cal1.getFirstDayOfWeek(), cal2.getFirstDayOfWeek());
967        assertNotSame(cal1.getTimeZone().getRawOffset(), cal2.getTimeZone().getRawOffset());
968        Locale.setDefault(Locale.US);
969        cal2 = Calendar.getInstance(TimeZone.getTimeZone("GMT+1"));
970        assertNotSame(cal1.getFirstDayOfWeek(), cal2.getFirstDayOfWeek());
971        assertNotSame(cal1.getTimeZone().getRawOffset(), cal2.getTimeZone().getRawOffset());
972    }
973
974    @TestTargetNew(
975        level = TestLevel.COMPLETE,
976        notes = "",
977        method = "getMinimalDaysInFirstWeek",
978        args = {}
979    )
980    public void test_getMinimalDaysInFirstWeek() {
981        Locale[] requiredLocales = {Locale.US, Locale.FRANCE};
982        if (!Support_Locale.areLocalesAvailable(requiredLocales)) {
983            // locale dependent test, bug 1943269
984            return;
985        }
986        Calendar cal = Calendar.getInstance();
987        assertTrue(cal.getMinimalDaysInFirstWeek()==1);
988        Locale.setDefault(Locale.FRANCE);
989        cal = Calendar.getInstance();
990        assertTrue(cal.getMinimalDaysInFirstWeek()==4);
991        Locale.setDefault(Locale.US);
992    }
993
994    @TestTargetNew(
995        level = TestLevel.COMPLETE,
996        notes = "",
997        method = "getTime",
998        args = {}
999    )
1000    public void test_getTime() {
1001        Calendar cal = Calendar.getInstance();
1002        Date d = new Date(1222185600225L);
1003
1004        cal.setTimeInMillis(1222185600225L);
1005        assertEquals(d.getTime(), cal.getTimeInMillis());
1006        assertEquals(d, cal.getTime());
1007    }
1008
1009    @TestTargetNew(
1010        level = TestLevel.COMPLETE,
1011        notes = "",
1012        method = "getTimeZone",
1013        args = {}
1014    )
1015    public void test_getTimeZone() {
1016        Calendar cal = Calendar.getInstance();
1017        cal.setTimeZone(TimeZone.getTimeZone("GMT-6"));
1018
1019        assertEquals(TimeZone.getTimeZone("GMT-6"), cal.getTimeZone());
1020        cal = Calendar.getInstance(TimeZone.getTimeZone("GMT-8"));
1021        assertEquals(TimeZone.getTimeZone("GMT-8"), cal.getTimeZone());
1022    }
1023
1024    @TestTargetNew(
1025        level = TestLevel.COMPLETE,
1026        notes = "",
1027        method = "hashCode",
1028        args = {}
1029    )
1030    public void test_hashCode() {
1031        Locale[] requiredLocales = {Locale.US, Locale.FRANCE};
1032        if (!Support_Locale.areLocalesAvailable(requiredLocales)) {
1033            // locale dependent test, bug 1943269
1034            return;
1035        }
1036        Calendar cal1 = Calendar.getInstance();
1037        Locale.setDefault(Locale.FRANCE);
1038        Calendar cal2 = Calendar.getInstance();
1039        Locale.setDefault(Locale.US);
1040        assertTrue(cal1.hashCode() != cal2.hashCode());
1041    }
1042
1043    @TestTargetNew(
1044        level = TestLevel.COMPLETE,
1045        notes = "",
1046        method = "internalGet",
1047        args = {int.class}
1048    )
1049    public void test_internalGet() {
1050        Mock_Calendar mc = new Mock_Calendar();
1051        assertEquals(0, mc.internalGetField(Calendar.MONTH));
1052        mc.set(Calendar.MONTH, 35);
1053        assertEquals(35, mc.internalGetField(Calendar.MONTH));
1054        assertEquals(11, mc.get(Calendar.MONTH));
1055    }
1056
1057    @TestTargets({
1058        @TestTargetNew(
1059            level = TestLevel.COMPLETE,
1060            notes = "",
1061            method = "isLenient",
1062            args = {}
1063        ),
1064        @TestTargetNew(
1065            level = TestLevel.COMPLETE,
1066            notes = "",
1067            method = "setLenient",
1068            args = {boolean.class}
1069        )
1070    })
1071    public void test_isLenient() {
1072        Calendar cal = Calendar.getInstance();
1073        assertTrue(cal.isLenient());
1074        cal.set(Calendar.MONTH, 35);
1075        cal.get(Calendar.MONTH);
1076        cal.setLenient(false);
1077        cal.set(Calendar.MONTH, 35);
1078        try {
1079            cal.get(Calendar.MONTH);
1080            fail("IllegalArgumentException expected");
1081        } catch (IllegalArgumentException e) {
1082            //expected
1083        }
1084        assertFalse(cal.isLenient());
1085        cal.setLenient(true);
1086        cal.set(Calendar.MONTH, 35);
1087        cal.get(Calendar.MONTH);
1088        assertTrue(cal.isLenient());
1089    }
1090
1091    @TestTargetNew(
1092        level = TestLevel.COMPLETE,
1093        notes = "",
1094        method = "isSet",
1095        args = {int.class}
1096    )
1097    public void test_isSet() {
1098        Calendar cal = Calendar.getInstance();
1099        cal.clear();
1100        assertFalse(cal.isSet(Calendar.MONTH));
1101        cal.set(Calendar.MONTH, 35);
1102        assertTrue(cal.isSet(Calendar.MONTH));
1103        assertFalse(cal.isSet(Calendar.YEAR));
1104        cal.get(Calendar.MONTH);
1105        assertTrue(cal.isSet(Calendar.YEAR));
1106    }
1107
1108    @TestTargetNew(
1109        level = TestLevel.COMPLETE,
1110        notes = "",
1111        method = "roll",
1112        args = {int.class, int.class}
1113    )
1114    public void test_rollII() {
1115        Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("GMT+2"), defaultLocale);
1116
1117        cal.setTimeInMillis(1222185600225L);
1118        cal.roll(Calendar.DAY_OF_MONTH, 200);
1119        assertEquals(cal.get(Calendar.ERA), 1);
1120        assertEquals(cal.get(Calendar.YEAR), 2008);
1121        assertEquals(cal.get(Calendar.MONTH), Calendar.SEPTEMBER);
1122        assertEquals(cal.get(Calendar.DAY_OF_MONTH), 13);
1123        // Following line returns wrong value. Behavior uncompatible with RI.
1124        assertEquals(cal.get(Calendar.HOUR_OF_DAY), 18);
1125        assertEquals(cal.get(Calendar.MINUTE), 0);
1126        cal.roll(Calendar.DAY_OF_MONTH, -200);
1127        assertEquals(cal.get(Calendar.ERA), 1);
1128        assertEquals(cal.get(Calendar.YEAR), 2008);
1129        assertEquals(cal.get(Calendar.MONTH), Calendar.SEPTEMBER);
1130        assertEquals(cal.get(Calendar.DAY_OF_MONTH), 23);
1131        assertEquals(cal.get(Calendar.HOUR_OF_DAY), 18);
1132        assertEquals(cal.get(Calendar.MINUTE), 0);
1133    }
1134
1135    @TestTargets({
1136        @TestTargetNew(
1137            level = TestLevel.COMPLETE,
1138            notes = "",
1139            method = "set",
1140            args = {int.class, int.class, int.class}
1141        ),
1142        @TestTargetNew(
1143            level = TestLevel.COMPLETE,
1144            notes = "",
1145            method = "setTimeInMillis",
1146            args = {long.class}
1147        )
1148    })
1149    public void test_setIII() {
1150        Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("GMT+2"), defaultLocale);
1151
1152        cal.setTimeInMillis(1222185600225L);
1153        assertEquals(1222185600225L, cal.getTimeInMillis());
1154        assertEquals(cal.get(Calendar.YEAR), 2008);
1155        assertEquals(cal.get(Calendar.MONTH), Calendar.SEPTEMBER);
1156        assertEquals(cal.get(Calendar.DAY_OF_MONTH), 23);
1157        assertEquals(cal.get(Calendar.SECOND), 0);
1158
1159        cal.set(1970, Calendar.JANUARY, 1);
1160        assertEquals(cal.get(Calendar.ERA), 1);
1161        // Following line returns wrong value. Behavior uncompatible with RI.
1162        assertEquals(cal.get(Calendar.HOUR_OF_DAY), 18);
1163        assertEquals(cal.get(Calendar.MINUTE), 0);
1164        assertEquals(cal.get(Calendar.SECOND), 0);
1165
1166        assertEquals(cal.get(Calendar.YEAR), 1970);
1167        assertEquals(cal.get(Calendar.MONTH), 0);
1168        assertEquals(cal.get(Calendar.DAY_OF_MONTH), 1);
1169    }
1170
1171    @TestTargetNew(
1172        level = TestLevel.COMPLETE,
1173        notes = "",
1174        method = "set",
1175        args = {int.class, int.class, int.class, int.class, int.class}
1176    )
1177    public void test_setIIIII() {
1178        Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("GMT+2"), defaultLocale);
1179
1180        cal.setTimeInMillis(1222185600225L);
1181        assertEquals(cal.get(Calendar.YEAR), 2008);
1182        assertEquals(cal.get(Calendar.MONTH), Calendar.SEPTEMBER);
1183        assertEquals(cal.get(Calendar.DAY_OF_MONTH), 23);
1184        // Following line returns wrong value. Behavior uncompatible with RI.
1185        assertEquals(cal.get(Calendar.HOUR_OF_DAY), 18);
1186        assertEquals(cal.get(Calendar.MINUTE), 0);
1187        assertEquals(cal.get(Calendar.SECOND), 0);
1188
1189        cal.set(1970, Calendar.JANUARY, 1, 0, 10);
1190        assertEquals(cal.get(Calendar.ERA), 1);
1191        assertEquals(cal.get(Calendar.SECOND), 0);
1192
1193        assertEquals(cal.get(Calendar.YEAR), 1970);
1194        assertEquals(cal.get(Calendar.MONTH), 0);
1195        assertEquals(cal.get(Calendar.DAY_OF_MONTH), 1);
1196        assertEquals(cal.get(Calendar.HOUR_OF_DAY), 0);
1197        assertEquals(cal.get(Calendar.MINUTE), 10);
1198    }
1199
1200    @TestTargetNew(
1201        level = TestLevel.COMPLETE,
1202        notes = "",
1203        method = "set",
1204        args = {int.class, int.class, int.class, int.class, int.class, int.class}
1205    )
1206    public void test_setIIIIII() {
1207        Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("GMT+2"), defaultLocale);
1208
1209        cal.setTimeInMillis(1222185600225L);
1210        assertEquals(cal.get(Calendar.YEAR), 2008);
1211        assertEquals(cal.get(Calendar.MONTH), Calendar.SEPTEMBER);
1212        assertEquals(cal.get(Calendar.DAY_OF_MONTH), 23);
1213        // Following line returns wrong value. Behavior uncompatible with RI.
1214        assertEquals(cal.get(Calendar.HOUR_OF_DAY), 18);
1215        assertEquals(cal.get(Calendar.MINUTE), 0);
1216        assertEquals(cal.get(Calendar.SECOND), 0);
1217
1218        cal.set(1970, Calendar.JANUARY, 1, 0, 10, 33);
1219        assertEquals(cal.get(Calendar.ERA), 1);
1220
1221        assertEquals(cal.get(Calendar.YEAR), 1970);
1222        assertEquals(cal.get(Calendar.MONTH), 0);
1223        assertEquals(cal.get(Calendar.DAY_OF_MONTH), 1);
1224        assertEquals(cal.get(Calendar.HOUR_OF_DAY), 0);
1225        assertEquals(cal.get(Calendar.MINUTE), 10);
1226        assertEquals(cal.get(Calendar.SECOND), 33);
1227    }
1228
1229    @TestTargetNew(
1230        level = TestLevel.COMPLETE,
1231        notes = "",
1232        method = "setFirstDayOfWeek",
1233        args = {int.class}
1234    )
1235    public void test_setFirstDayOfWeekI() {
1236        Calendar cal = Calendar.getInstance();
1237
1238        for (int i = 0; i < 10; i++) {
1239            cal.setFirstDayOfWeek(i);
1240            assertEquals(i, cal.getFirstDayOfWeek());
1241        }
1242        cal.setLenient(false);
1243        cal.setFirstDayOfWeek(10);
1244        cal.setFirstDayOfWeek(-10);
1245    }
1246
1247    @TestTargetNew(
1248        level = TestLevel.COMPLETE,
1249        notes = "",
1250        method = "setMinimalDaysInFirstWeek",
1251        args = {int.class}
1252    )
1253    public void test_setMinimalDaysInFirstWeekI() {
1254        Calendar cal = Calendar.getInstance();
1255
1256        for (int i = 0; i < 10; i++) {
1257            cal.setMinimalDaysInFirstWeek(i);
1258            assertEquals(i, cal.getMinimalDaysInFirstWeek());
1259        }
1260        cal.setLenient(false);
1261        cal.setMinimalDaysInFirstWeek(10);
1262        cal.setMinimalDaysInFirstWeek(-10);
1263    }
1264
1265    @TestTargetNew(
1266        level = TestLevel.COMPLETE,
1267        notes = "",
1268        method = "setTimeZone",
1269        args = {java.util.TimeZone.class}
1270    )
1271    public void test_setTimeZoneLjava_util_TimeZone() {
1272        Calendar cal = Calendar.getInstance();
1273        cal.setTimeZone(TimeZone.getTimeZone("GMT-6"));
1274        assertEquals(TimeZone.getTimeZone("GMT-6"), cal.getTimeZone());
1275        cal = Calendar.getInstance(TimeZone.getTimeZone("GMT-8"));
1276        cal.setTimeZone(TimeZone.getTimeZone("GMT-6"));
1277        assertEquals(TimeZone.getTimeZone("GMT-6"), cal.getTimeZone());
1278
1279        cal.setTimeZone(null);
1280    }
1281
1282    @TestTargetNew(
1283        level = TestLevel.COMPLETE,
1284        notes = "",
1285        method = "toString",
1286        args = {}
1287    )
1288    public void test_toString() {
1289        Calendar cal1 = Calendar.getInstance();
1290        Calendar cal2 = Calendar.getInstance();
1291        cal1.setTimeZone(TimeZone.getTimeZone("GMT-6"));
1292        cal2.setTimeZone(TimeZone.getTimeZone("GMT-8"));
1293        cal1.set(Calendar.MILLISECOND, 0);
1294        cal2.set(Calendar.MILLISECOND, 0);
1295        assertFalse(cal1.toString().equals(cal2.toString()));
1296        cal1.setTimeZone(TimeZone.getTimeZone("GMT-8"));
1297        assertTrue(cal1.toString().equals(cal2.toString()));
1298    }
1299
1300    @TestTargetNew(
1301        level = TestLevel.ADDITIONAL,
1302        method = "get",
1303        args = {int.class}
1304    )
1305    public void test_EdgeCases() {
1306        Calendar c = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
1307
1308        c.setTimeInMillis(Long.MAX_VALUE);
1309
1310        assertEquals(292278994, c.get(Calendar.YEAR));
1311        assertEquals(Calendar.AUGUST, c.get(Calendar.MONTH));
1312        assertEquals(17, c.get(Calendar.DAY_OF_MONTH));
1313        assertEquals(Calendar.SUNDAY, c.get(Calendar.DAY_OF_WEEK));
1314        assertEquals(7, c.get(Calendar.HOUR_OF_DAY));
1315        assertEquals(12, c.get(Calendar.MINUTE));
1316        assertEquals(55, c.get(Calendar.SECOND));
1317    }
1318
1319    protected void setUp() {
1320        defaultLocale = Locale.getDefault();
1321        Locale.setDefault(Locale.US);
1322    }
1323
1324    protected void tearDown() {
1325        Locale.setDefault(defaultLocale);
1326    }
1327}
1328