001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017:
018: package org.apache.harmony.luni.tests.java.util;
019:
020: import java.util.Calendar;
021: import java.util.Date;
022: import java.util.Locale;
023: import java.util.TimeZone;
024:
025: public class CalendarTest extends junit.framework.TestCase {
026:
027: Locale defaultLocale;
028:
029: /**
030: * @tests java.util.Calendar#set(int, int)
031: */
032: public void test_setII() {
033: // Test for correct result defined by the last set field
034: Calendar cal = Calendar
035: .getInstance(TimeZone.getTimeZone("EST"));
036:
037: cal.clear();
038: cal.set(Calendar.YEAR, 2002);
039: assertTrue("Incorrect result 0: " + cal.getTime().getTime(),
040: cal.getTime().getTime() == 1009861200000L);
041:
042: cal.clear();
043: cal.set(Calendar.YEAR, 2002);
044: cal.set(Calendar.MONTH, Calendar.MARCH);
045: assertTrue("Incorrect result 0a: " + cal.getTime(), cal
046: .getTime().getTime() == 1014958800000L);
047:
048: cal.clear();
049: cal.set(Calendar.YEAR, 2002);
050: cal.set(Calendar.DATE, 24);
051: assertTrue("Incorrect result 0b: " + cal.getTime(), cal
052: .getTime().getTime() == 1011848400000L);
053:
054: cal.set(Calendar.MONTH, Calendar.OCTOBER);
055: cal.set(Calendar.DATE, 31);
056: cal.set(Calendar.MONTH, Calendar.NOVEMBER);
057: cal.set(Calendar.DATE, 26);
058: assertTrue("Incorrect month: " + cal.get(Calendar.MONTH), cal
059: .get(Calendar.MONTH) == Calendar.NOVEMBER);
060:
061: int dow = cal.get(Calendar.DAY_OF_WEEK);
062: cal.set(Calendar.DATE, 27);
063: assertTrue("Incorrect DAY_OF_WEEK: "
064: + cal.get(Calendar.DAY_OF_WEEK) + " expected: " + dow,
065: cal.get(Calendar.DAY_OF_WEEK) != dow);
066:
067: cal.clear();
068: cal.set(Calendar.YEAR, 2002);
069: cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
070: assertTrue("Incorrect result 0c1: " + cal.getTime().getTime(),
071: cal.getTime().getTime() == 1010379600000L);
072:
073: cal.clear();
074: cal.set(Calendar.YEAR, 2002);
075: cal.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
076: assertTrue("Incorrect result 0c2: " + cal.getTime().getTime(),
077: cal.getTime().getTime() == 1009861200000L);
078:
079: cal.clear();
080: cal.set(Calendar.YEAR, 2002);
081: cal.set(Calendar.DAY_OF_WEEK, Calendar.THURSDAY);
082: assertTrue("Incorrect result 0c3: " + cal.getTime(), cal
083: .getTime().getTime() == 1010034000000L);
084:
085: cal.clear();
086: cal.set(Calendar.YEAR, 2002);
087: cal.set(Calendar.WEEK_OF_MONTH, 2);
088: assertTrue("Incorrect result 0d: " + cal.getTime(), cal
089: .getTime().getTime() == 1010293200000L);
090:
091: cal.clear();
092: cal.set(Calendar.YEAR, 2002);
093: cal.set(Calendar.DAY_OF_WEEK_IN_MONTH, 2);
094: assertTrue("Incorrect result 0e: " + cal.getTime(), cal
095: .getTime().getTime() == 1010898000000L);
096:
097: cal.clear();
098: cal.set(Calendar.YEAR, 2002);
099: cal.set(Calendar.WEEK_OF_YEAR, 11);
100: assertTrue("Incorrect result 0f: " + cal.getTime(), cal
101: .getTime().getTime() == 1015736400000L);
102:
103: cal.clear();
104: cal.set(Calendar.YEAR, 2002);
105: cal.set(Calendar.DATE, 24);
106: cal.set(Calendar.WEEK_OF_YEAR, 11);
107: assertTrue("Incorrect result 0g: " + cal.getTime(), cal
108: .getTime().getTime() == 1011848400000L);
109:
110: cal.clear();
111: cal.set(Calendar.YEAR, 2002);
112: cal.get(Calendar.WEEK_OF_YEAR); // Force fields to compute
113: cal.set(Calendar.WEEK_OF_YEAR, 11);
114: assertTrue("Incorrect result 0h: " + cal.getTime(), cal
115: .getTime().getTime() == 1015909200000L);
116:
117: // WEEK_OF_YEAR has priority over MONTH/DATE
118: cal.clear();
119: cal.set(Calendar.YEAR, 2002);
120: cal.set(Calendar.DAY_OF_YEAR, 170);
121: cal.set(Calendar.WEEK_OF_YEAR, 11);
122: cal.set(Calendar.MONTH, Calendar.JANUARY);
123: cal.set(Calendar.DATE, 5);
124: cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
125: assertTrue("Incorrect result 1: " + cal.getTime(), cal
126: .getTime().getTime() == 1015822800000L);
127:
128: // WEEK_OF_YEAR has priority over MONTH/DATE
129: cal.clear();
130: cal.set(Calendar.YEAR, 2002);
131: cal.set(Calendar.WEEK_OF_YEAR, 11);
132: cal.set(Calendar.MONTH, Calendar.JANUARY);
133: cal.set(Calendar.DATE, 5);
134: cal.set(Calendar.DAY_OF_YEAR, 170);
135: cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
136: assertTrue("Incorrect result 1a: " + cal.getTime(), cal
137: .getTime().getTime() == 1015822800000L);
138:
139: // DAY_OF_WEEK has no effect when other fields not set
140: cal.clear();
141: cal.set(Calendar.YEAR, 2002);
142: cal.set(Calendar.MONTH, Calendar.MARCH);
143: cal.set(Calendar.DATE, 11);
144: cal.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
145: assertTrue("Incorrect result 1b: " + cal.getTime(), cal
146: .getTime().getTime() == 1015822800000L);
147: // Regression for HARMONY-4384
148: // Set DAY_OF_WEEK without DATE
149: cal.clear();
150: cal.set(Calendar.YEAR, 2002);
151: cal.set(Calendar.MONTH, Calendar.MARCH);
152: cal.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
153: assertEquals("Incorrect result 1b: " + cal.getTime(),
154: 1015304400000L, cal.getTime().getTime());
155:
156: // WEEK_OF_MONTH has priority
157: cal.clear();
158: cal.set(Calendar.YEAR, 2002);
159: cal.set(Calendar.WEEK_OF_YEAR, 12);
160: cal.set(Calendar.DAY_OF_WEEK_IN_MONTH, 1);
161: cal.set(Calendar.WEEK_OF_MONTH, 3);
162: cal.set(Calendar.MONTH, Calendar.MARCH);
163: cal.set(Calendar.DATE, 5);
164: cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
165: assertTrue("Incorrect result 2: " + cal.getTime(), cal
166: .getTime().getTime() == 1015822800000L);
167:
168: // DAY_OF_WEEK_IN_MONTH has priority over WEEK_OF_YEAR
169: cal.clear();
170: cal.set(Calendar.YEAR, 2002);
171: cal.set(Calendar.WEEK_OF_YEAR, 12);
172: cal.set(Calendar.DAY_OF_WEEK_IN_MONTH, 2);
173: cal.set(Calendar.MONTH, Calendar.MARCH);
174: cal.set(Calendar.DATE, 5);
175: cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
176: assertTrue("Incorrect result 3: " + cal.getTime(), cal
177: .getTime().getTime() == 1015822800000L);
178:
179: // WEEK_OF_MONTH has priority, MONTH not set
180: cal.clear();
181: cal.set(Calendar.YEAR, 2002);
182: cal.set(Calendar.WEEK_OF_YEAR, 12);
183: cal.set(Calendar.DAY_OF_WEEK_IN_MONTH, 1);
184: cal.set(Calendar.WEEK_OF_MONTH, 3);
185: cal.set(Calendar.DATE, 25);
186: cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
187: assertTrue("Incorrect result 4: " + cal.getTime(), cal
188: .getTime().getTime() == 1010984400000L);
189:
190: // WEEK_OF_YEAR has priority when MONTH set last and DAY_OF_WEEK set
191: cal.clear();
192: cal.set(Calendar.YEAR, 2002);
193: cal.set(Calendar.WEEK_OF_YEAR, 11);
194: cal.set(Calendar.DATE, 25);
195: cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
196: cal.set(Calendar.MONTH, Calendar.JANUARY);
197: assertTrue("Incorrect result 5: " + cal.getTime(), cal
198: .getTime().getTime() == 1015822800000L);
199:
200: // Use MONTH/DATE when WEEK_OF_YEAR set but not DAY_OF_WEEK
201: cal.clear();
202: cal.set(Calendar.YEAR, 2002);
203: cal.set(Calendar.WEEK_OF_YEAR, 12);
204: cal.set(Calendar.DATE, 11);
205: cal.set(Calendar.MONTH, Calendar.MARCH);
206: assertTrue("Incorrect result 5a: " + cal.getTime(), cal
207: .getTime().getTime() == 1015822800000L);
208:
209: // Use MONTH/DATE when DAY_OF_WEEK is not set
210: cal.clear();
211: cal.set(Calendar.YEAR, 2002);
212: cal.set(Calendar.WEEK_OF_YEAR, 12);
213: cal.set(Calendar.DATE, 11);
214: cal.set(Calendar.WEEK_OF_MONTH, 1);
215: cal.set(Calendar.MONTH, Calendar.MARCH);
216: assertTrue("Incorrect result 5b: " + cal.getTime(), cal
217: .getTime().getTime() == 1015822800000L);
218:
219: // WEEK_OF_MONTH has priority
220: cal.clear();
221: cal.set(Calendar.YEAR, 2002);
222: cal.set(Calendar.WEEK_OF_YEAR, 12);
223: cal.set(Calendar.DATE, 5);
224: cal.set(Calendar.WEEK_OF_MONTH, 3);
225: cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
226: cal.set(Calendar.MONTH, Calendar.MARCH);
227: assertTrue("Incorrect result 5c: " + cal.getTime(), cal
228: .getTime().getTime() == 1015822800000L);
229:
230: // DATE has priority when set last
231: cal.clear();
232: cal.set(Calendar.YEAR, 2002);
233: cal.set(Calendar.WEEK_OF_YEAR, 12);
234: cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
235: cal.set(Calendar.MONTH, Calendar.MARCH);
236: cal.set(Calendar.DATE, 11);
237: assertTrue("Incorrect result 6: " + cal.getTime(), cal
238: .getTime().getTime() == 1015822800000L);
239:
240: // DATE has priority when set last, MONTH not set
241: cal.clear();
242: cal.set(Calendar.YEAR, 2002);
243: cal.set(Calendar.WEEK_OF_YEAR, 12);
244: cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
245: cal.set(Calendar.DATE, 14);
246: assertTrue("Incorrect result 7: " + cal.getTime(), cal
247: .getTime().getTime() == 1010984400000L);
248:
249: // DAY_OF_YEAR has priority when MONTH set last and DATE not set
250: cal.clear();
251: cal.set(Calendar.YEAR, 2002);
252: cal.set(Calendar.DAY_OF_YEAR, 70);
253: cal.set(Calendar.MONTH, Calendar.JANUARY);
254: assertTrue("Incorrect result 8: " + cal.getTime(), cal
255: .getTime().getTime() == 1015822800000L);
256:
257: // DAY/MONTH has priority when DATE set after DAY_OF_YEAR
258: cal.clear();
259: cal.set(Calendar.YEAR, 2002);
260: cal.set(Calendar.DAY_OF_YEAR, 170);
261: cal.set(Calendar.DATE, 11);
262: cal.set(Calendar.MONTH, Calendar.MARCH);
263: assertTrue("Incorrect result 8a: " + cal.getTime(), cal
264: .getTime().getTime() == 1015822800000L);
265:
266: // DAY_OF_YEAR has priority when set after DATE
267: cal.clear();
268: cal.set(Calendar.YEAR, 2002);
269: cal.set(Calendar.DATE, 15);
270: cal.set(Calendar.DAY_OF_YEAR, 70);
271: cal.set(Calendar.MONTH, Calendar.JANUARY);
272: assertTrue("Incorrect result 8b: " + cal.getTime(), cal
273: .getTime().getTime() == 1015822800000L);
274:
275: // DATE has priority when set last
276: cal.clear();
277: cal.set(Calendar.YEAR, 2002);
278: cal.set(Calendar.DAY_OF_YEAR, 70);
279: cal.set(Calendar.DATE, 14);
280: assertTrue("Incorrect result 9: " + cal.getTime(), cal
281: .getTime().getTime() == 1010984400000L);
282:
283: // DATE has priority when set last
284: cal.clear();
285: cal.set(Calendar.YEAR, 2002);
286: cal.set(Calendar.WEEK_OF_YEAR, 15);
287: cal.set(Calendar.DAY_OF_WEEK, Calendar.THURSDAY);
288: cal.set(Calendar.DATE, 14);
289: assertTrue("Incorrect result 9a: " + cal.getTime(), cal
290: .getTime().getTime() == 1010984400000L);
291:
292: cal.clear();
293: cal.set(Calendar.YEAR, 2002);
294: cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
295: cal.set(Calendar.DATE, 14);
296: cal.set(Calendar.WEEK_OF_YEAR, 11);
297: assertTrue("Incorrect result 9b: " + cal.getTime(), cal
298: .getTime().getTime() == 1015822800000L);
299:
300: cal.clear();
301: cal.set(Calendar.YEAR, 2002);
302: cal.set(Calendar.DATE, 14);
303: cal.set(Calendar.WEEK_OF_YEAR, 11);
304: assertTrue("Incorrect result 9c: " + cal.getTime(), cal
305: .getTime().getTime() == 1010984400000L);
306:
307: cal.clear();
308: cal.set(Calendar.YEAR, 2002);
309: cal.set(Calendar.WEEK_OF_MONTH, 1);
310: cal.set(Calendar.DAY_OF_WEEK, Calendar.THURSDAY);
311: cal.set(Calendar.MONTH, Calendar.MARCH);
312: cal.set(Calendar.DATE, 11);
313: assertTrue("Incorrect result 9d: " + cal.getTime(), cal
314: .getTime().getTime() == 1015822800000L);
315:
316: // DAY_OF_YEAR has priority when DAY_OF_MONTH set last and other fields
317: // not set
318: cal.clear();
319: cal.set(Calendar.YEAR, 2002);
320: cal.set(Calendar.DAY_OF_YEAR, 70);
321: cal.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
322: assertTrue("Incorrect result 10: " + cal.getTime(), cal
323: .getTime().getTime() == 1015822800000L);
324:
325: // MONTH/DATE has priority when DAY_OF_WEEK_IN_MONTH set last but
326: // DAY_OF_WEEK not set
327: cal.clear();
328: cal.set(Calendar.YEAR, 2002);
329: cal.set(Calendar.DATE, 11);
330: cal.set(Calendar.MONTH, Calendar.MARCH);
331: cal.set(Calendar.DAY_OF_WEEK_IN_MONTH, 1);
332: assertTrue("Incorrect result 11: " + cal.getTime(), cal
333: .getTime().getTime() == 1015822800000L);
334:
335: // MONTH/DATE has priority when WEEK_OF_YEAR set last but DAY_OF_WEEK
336: // not set
337: cal.clear();
338: cal.set(Calendar.YEAR, 2002);
339: cal.set(Calendar.DATE, 11);
340: cal.set(Calendar.MONTH, Calendar.MARCH);
341: cal.set(Calendar.WEEK_OF_YEAR, 15);
342: assertTrue("Incorrect result 12: " + cal.getTime(), cal
343: .getTime().getTime() == 1015822800000L);
344:
345: // MONTH/DATE has priority when WEEK_OF_MONTH set last but DAY_OF_WEEK
346: // not set
347: cal.clear();
348: cal.set(Calendar.YEAR, 2002);
349: cal.set(Calendar.DATE, 11);
350: cal.set(Calendar.MONTH, Calendar.MARCH);
351: cal.set(Calendar.WEEK_OF_MONTH, 1);
352: assertTrue("Incorrect result 13: " + cal.getTime(), cal
353: .getTime().getTime() == 1015822800000L);
354:
355: // Ensure last date field set is reset after computing
356: cal.clear();
357: cal.set(Calendar.YEAR, 2002);
358: cal.set(Calendar.DAY_OF_YEAR, 111);
359: cal.get(Calendar.YEAR);
360: cal.set(Calendar.MONTH, Calendar.MARCH);
361: cal.set(Calendar.AM_PM, Calendar.AM);
362: assertTrue("Incorrect result 14: " + cal.getTime(), cal
363: .getTime().getTime() == 1016686800000L);
364:
365: int hour = cal.get(Calendar.HOUR);
366: cal.set(Calendar.HOUR, hour);
367: cal.set(Calendar.AM_PM, Calendar.PM);
368: assertEquals("AM_PM not changed", Calendar.PM, cal
369: .get(Calendar.AM_PM));
370: // setting AM_PM without HOUR should not have any affect
371: cal.set(Calendar.AM_PM, Calendar.AM);
372: assertEquals("AM_PM was changed 1", Calendar.AM, cal
373: .get(Calendar.AM_PM));
374: int hourOfDay = cal.get(Calendar.HOUR_OF_DAY);
375: hour = cal.get(Calendar.HOUR);
376: cal.set(Calendar.AM_PM, Calendar.PM);
377: assertEquals("AM_PM was changed 2", Calendar.PM, cal
378: .get(Calendar.AM_PM));
379: assertEquals(hour, cal.get(Calendar.HOUR));
380: assertEquals(hourOfDay + 12, cal.get(Calendar.HOUR_OF_DAY));
381:
382: // regression test for Harmony-2122
383: cal = Calendar.getInstance();
384: int oldValue = cal.get(Calendar.AM_PM);
385: int newValue = (oldValue == Calendar.AM) ? Calendar.PM
386: : Calendar.AM;
387: cal.set(Calendar.AM_PM, newValue);
388: newValue = cal.get(Calendar.AM_PM);
389: assertTrue(newValue != oldValue);
390: }
391:
392: /**
393: * @tests java.util.Calendar#setTime(java.util.Date)
394: */
395: public void test_setTimeLjava_util_Date() {
396: Calendar cal = Calendar.getInstance();
397: // Use millisecond time for testing in Core
398: cal.setTime(new Date(884581200000L)); // (98, Calendar.JANUARY, 12)
399: assertEquals("incorrect millis", 884581200000L, cal.getTime()
400: .getTime());
401: cal.setTimeZone(TimeZone.getTimeZone("EST"));
402: cal.setTime(new Date(943506000000L)); // (99, Calendar.NOVEMBER, 25)
403: assertTrue("incorrect fields", cal.get(Calendar.YEAR) == 1999
404: && cal.get(Calendar.MONTH) == Calendar.NOVEMBER
405: && cal.get(Calendar.DATE) == 25);
406: }
407:
408: /**
409: * @tests java.util.Calendar#compareTo(Calendar)
410: */
411: public void test_compareToLjava_util_Calendar_null() {
412: Calendar cal = Calendar.getInstance();
413: try {
414: cal.compareTo(null);
415: fail("should throw NullPointerException");
416: } catch (NullPointerException e) {
417: // expected
418: }
419: }
420:
421: /**
422: * @tests java.util.Calendar#compareTo(Calendar)
423: */
424: public void test_compareToLjava_util_Calendar() {
425: Calendar cal = Calendar.getInstance();
426: cal.clear();
427: cal.set(1997, 12, 13, 23, 57);
428:
429: Calendar anotherCal = Calendar.getInstance();
430: anotherCal.clear();
431: anotherCal.set(1997, 12, 13, 23, 57);
432: assertEquals(0, cal.compareTo(anotherCal));
433:
434: anotherCal = Calendar.getInstance();
435: anotherCal.clear();
436: anotherCal.set(1997, 11, 13, 24, 57);
437: assertEquals(1, cal.compareTo(anotherCal));
438:
439: anotherCal = Calendar.getInstance();
440: anotherCal.clear();
441: anotherCal.set(1997, 12, 13, 23, 58);
442: assertEquals(-1, cal.compareTo(anotherCal));
443: }
444:
445: /**
446: * @tests java.util.Calendar#clone()
447: */
448: public void test_clone() {
449: // Regression for HARMONY-475
450: Calendar cal = Calendar.getInstance();
451: cal.set(2006, 5, 6, 11, 35);
452: Calendar anotherCal = (Calendar) cal.clone();
453: // should be deep clone
454: assertNotSame("getTimeZone", cal.getTimeZone(), anotherCal
455: .getTimeZone());
456: }
457:
458: /**
459: * @tests java.util.Calendar#getTimeInMillis()
460: */
461: public void test_getTimeInMillis() {
462: Calendar cal = Calendar.getInstance();
463:
464: int year = Integer.MIN_VALUE + 71;
465: cal.setTimeZone(TimeZone.getTimeZone("GMT"));
466: ;
467: cal.set(Calendar.YEAR, year + 1900);
468: cal.set(Calendar.MONTH, Calendar.JANUARY);
469: cal.set(Calendar.DATE, 1);
470: cal.set(Calendar.HOUR_OF_DAY, 0);
471: cal.set(Calendar.MINUTE, 0);
472: cal.set(Calendar.SECOND, 0);
473: cal.set(Calendar.MILLISECOND, 0);
474:
475: assertEquals(6017546357372606464L, cal.getTimeInMillis());
476: }
477:
478: /**
479: * @tests {@link java.util.Calendar#getActualMaximum(int)}
480: */
481: public void test_getActualMaximum_I() {
482: Calendar c = new MockCalendar();
483: assertEquals("should be equal to 0", 0, c.getActualMaximum(0));
484: }
485:
486: /**
487: * @tests {@link java.util.Calendar#getActualMinimum(int)}
488: */
489: public void test_getActualMinimum_I() {
490: Calendar c = new MockCalendar();
491: assertEquals("should be equal to 0", 0, c.getActualMinimum(0));
492: }
493:
494: private class MockCalendar extends Calendar {
495:
496: public MockCalendar() {
497: super ();
498: }
499:
500: @Override
501: public void add(int field, int value) {
502: }
503:
504: @Override
505: protected void computeFields() {
506: }
507:
508: @Override
509: protected void computeTime() {
510: }
511:
512: @Override
513: public int getGreatestMinimum(int field) {
514: return 0;
515: }
516:
517: @Override
518: public int getLeastMaximum(int field) {
519: return 0;
520: }
521:
522: @Override
523: public int getMaximum(int field) {
524: return 0;
525: }
526:
527: @Override
528: public int getMinimum(int field) {
529: return 0;
530: }
531:
532: @Override
533: public void roll(int field, boolean increment) {
534: }
535: }
536:
537: protected void setUp() {
538: defaultLocale = Locale.getDefault();
539: Locale.setDefault(Locale.US);
540: }
541:
542: protected void tearDown() {
543: Locale.setDefault(defaultLocale);
544: }
545: }
|