1 /*
2 * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 /**
25 * @test
26 * @bug 4064654 4374886 4984320 4984574 4944795
27 * @library /java/text/testlib
28 * @summary test for Calendar
29 * @key randomness
30 */
31
32 import java.util.*;
33 import java.text.*;
34 import java.io.*;
35
36 public class CalendarTest extends IntlTest {
37 static final int ONE_DAY = 24*60*60*1000;
38 static final int EPOCH_JULIAN = 2440588;
39
40 public static void main(String argv[]) throws Exception {
41 new CalendarTest().run(argv);
42 }
43
44 /**
45 * Test the behavior of the GregorianCalendar around the changeover.
46 */
47 public void TestGregorianChangeover() {
48 TimeZone savedZone = TimeZone.getDefault();
49 /*
50 Changeover -7 days: 1582/9/28 dow=6
51 Changeover -6 days: 1582/9/29 dow=7
52 Changeover -5 days: 1582/9/30 dow=1
53 Changeover -4 days: 1582/10/1 dow=2
54 Changeover -3 days: 1582/10/2 dow=3
55 Changeover -2 days: 1582/10/3 dow=4
56 Changeover -1 days: 1582/10/4 dow=5
57 Changeover +0 days: 1582/10/15 dow=6
58 Changeover +1 days: 1582/10/16 dow=7
59 Changeover +2 days: 1582/10/17 dow=1
60 Changeover +3 days: 1582/10/18 dow=2
61 Changeover +4 days: 1582/10/19 dow=3
62 Changeover +5 days: 1582/10/20 dow=4
63 Changeover +6 days: 1582/10/21 dow=5
64 Changeover +7 days: 1582/10/22 dow=6
65 */
66 int MON[] = { 9, 9, 9,10,10,10,10, 10, 10, 10, 10, 10, 10, 10, 10 };
67 int DOM[] = { 28, 29, 30, 1, 2, 3, 4, 15, 16, 17, 18, 19, 20, 21, 22 };
68 int DOW[] = { 6, 7, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6 };
69 // ^ <-Changeover Fri Oct 15 1582
70
71 try {
72 TimeZone.setDefault(TimeZone.getTimeZone("GMT"));
73 Date co = new Date(1582-1900, Calendar.OCTOBER, 15);
74 GregorianCalendar cal = new GregorianCalendar();
75 int j = 0;
76 for (int i = -7; i <= 7; ++i, ++j) {
77 Date d = new Date(co.getTime() + i*ONE_DAY);
78 cal.setTime(d);
79 int y = cal.get(Calendar.YEAR);
80 int mon = cal.get(Calendar.MONTH)+1-Calendar.JANUARY;
81 int dom = cal.get(Calendar.DATE);
82 int dow = cal.get(Calendar.DAY_OF_WEEK);
83
84 logln("Changeover " + (i>=0?"+":"") + i +
85 " days: " + y + "/" + mon + "/" + dom + " dow=" + dow);
86 if (y != 1582 || mon != MON[j] || dom != DOM[j] || dow != DOW[j]) {
87 errln(" Fail: Above line is wrong");
88 }
89 }
90 }
91 finally {
92 TimeZone.setDefault(savedZone);
93 }
94 }
95
96 /**
97 * Test the mapping between millis and fields. For the purposes
98 * of this test, we don't care about timezones and week data
99 * (first day of week, minimal days in first week).
100 */
101 public void TestMapping() {
102 TimeZone saveZone = TimeZone.getDefault();
103 int[] DATA = {
104 // Julian# Year Month DOM JULIAN:Year, Month, DOM
105 2440588, 1970, Calendar.JANUARY, 1, 1969, Calendar.DECEMBER, 19,
106 2415080, 1900, Calendar.MARCH, 1, 1900, Calendar.FEBRUARY, 17,
107 2451604, 2000, Calendar.FEBRUARY, 29, 2000, Calendar.FEBRUARY, 16,
108 2452269, 2001, Calendar.DECEMBER, 25, 2001, Calendar.DECEMBER, 12,
109 2416526, 1904, Calendar.FEBRUARY, 15, 1904, Calendar.FEBRUARY, 2,
110 2416656, 1904, Calendar.JUNE, 24, 1904, Calendar.JUNE, 11,
111 1721426, 1, Calendar.JANUARY, 1, 1, Calendar.JANUARY, 3,
112 2000000, 763, Calendar.SEPTEMBER, 18, 763, Calendar.SEPTEMBER, 14,
113 4000000, 6239, Calendar.JULY, 12, 6239, Calendar.MAY, 28,
114 8000000, 17191, Calendar.FEBRUARY, 26, 17190, Calendar.OCTOBER, 22,
115 10000000, 22666, Calendar.DECEMBER, 20, 22666, Calendar.JULY, 5,
116 };
117
118 try {
119 TimeZone.setDefault(TimeZone.getTimeZone("UTC"));
120 Date PURE_GREGORIAN = new Date(Long.MIN_VALUE);
121 Date PURE_JULIAN = new Date(Long.MAX_VALUE);
122 GregorianCalendar cal = new GregorianCalendar();
123 for (int i = 0; i < DATA.length; i += 7) {
124 int julian = DATA[i];
125 int year = DATA[i+1];
126 int month = DATA[i+2];
127 int dom = DATA[i+3];
128 int year2, month2, dom2;
129 long millis = ((long)julian - EPOCH_JULIAN) * ONE_DAY;
130 String s;
131
132 // Test Gregorian computation
133 cal.setGregorianChange(PURE_GREGORIAN);
134 cal.clear();
135 cal.set(year, month, dom);
136 long calMillis = cal.getTime().getTime();
137 long delta = calMillis - millis;
138 cal.setTime(new Date(millis));
139 year2 = cal.get(Calendar.YEAR);
140 month2 = cal.get(Calendar.MONTH);
141 dom2 = cal.get(Calendar.DAY_OF_MONTH);
142 s = "G " + year + "-" + (month+1-Calendar.JANUARY) + "-" + dom +
143 " => " + calMillis +
144 " (" + ((float)delta/ONE_DAY) + " day delta) => " +
145 year2 + "-" + (month2+1-Calendar.JANUARY) + "-" + dom2;
146 if (delta != 0 || year != year2 || month != month2 ||
147 dom != dom2) {
148 errln(s + " FAIL");
149 } else {
150 logln(s);
151 }
152
153 // Test Julian computation
154 year = DATA[i+4];
155 month = DATA[i+5];
156 dom = DATA[i+6];
157 cal.setGregorianChange(PURE_JULIAN);
158 cal.clear();
159 cal.set(year, month, dom);
160 calMillis = cal.getTime().getTime();
161 delta = calMillis - millis;
162 cal.setTime(new Date(millis));
163 year2 = cal.get(Calendar.YEAR);
164 month2 = cal.get(Calendar.MONTH);
165 dom2 = cal.get(Calendar.DAY_OF_MONTH);
166 s = "J " + year + "-" + (month+1-Calendar.JANUARY) + "-" + dom +
167 " => " + calMillis +
168 " (" + ((float)delta/ONE_DAY) + " day delta) => " +
169 year2 + "-" + (month2+1-Calendar.JANUARY) + "-" + dom2;
170 if (delta != 0 || year != year2 || month != month2 ||
171 dom != dom2) {
172 errln(s + " FAIL");
173 } else {
174 logln(s);
175 }
176 }
177
178 cal.setGregorianChange(new Date(1582-1900, Calendar.OCTOBER, 15));
179 auxMapping(cal, 1582, Calendar.OCTOBER, 4);
180 auxMapping(cal, 1582, Calendar.OCTOBER, 15);
181 auxMapping(cal, 1582, Calendar.OCTOBER, 16);
182 for (int y = 800; y < 3000; y += 1+(int)100*Math.random()) {
183 for (int m = Calendar.JANUARY; m <= Calendar.DECEMBER; ++m) {
184 auxMapping(cal, y, m, 15);
185 }
186 }
187 }
188 finally {
189 TimeZone.setDefault(saveZone);
190 }
191 }
192 private void auxMapping(Calendar cal, int y, int m, int d) {
193 cal.clear();
194 cal.set(y, m, d);
195 long millis = cal.getTime().getTime();
196 cal.setTime(new Date(millis));
197 int year2 = cal.get(Calendar.YEAR);
198 int month2 = cal.get(Calendar.MONTH);
199 int dom2 = cal.get(Calendar.DAY_OF_MONTH);
200 if (y != year2 || m != month2 || dom2 != d)
201 errln("Round-trip failure: " + y + "-" + (m+1) + "-"+d+" =>ms=> " +
202 year2 + "-" + (month2+1) + "-" + dom2);
203 }
204
205 public void TestGenericAPI() {
206 if (Locale.getDefault().equals(new Locale("th", "TH"))) {
207 return;
208 }
209
210 String str;
211
212 Date when = new Date(90, Calendar.APRIL, 15);
213
214 String tzid = "TestZone";
215 int tzoffset = 123400;
216
217 SimpleTimeZone zone = new SimpleTimeZone(tzoffset, tzid);
218 Calendar cal = (Calendar)Calendar.getInstance((SimpleTimeZone)zone.clone());
219
220 if (!zone.equals(cal.getTimeZone())) errln("FAIL: Calendar.getTimeZone failed");
221
222 Calendar cal2 = Calendar.getInstance(cal.getTimeZone());
223
224 cal.setTime(when);
225 cal2.setTime(when);
226
227 if (!(cal.equals(cal2))) errln("FAIL: Calendar.operator== failed");
228 // if ((*cal != *cal2)) errln("FAIL: Calendar.operator!= failed");
229 if (!cal.equals(cal2) ||
230 cal.before(cal2) ||
231 cal.after(cal2)) errln("FAIL: equals/before/after failed");
232
233 cal2.setTime(new Date(when.getTime() + 1000));
234 if (cal.equals(cal2) ||
235 cal2.before(cal) ||
236 cal.after(cal2)) errln("FAIL: equals/before/after failed");
237
238 cal.roll(Calendar.SECOND, true);
239 if (!cal.equals(cal2) ||
240 cal.before(cal2) ||
241 cal.after(cal2)) errln("FAIL: equals/before/after failed");
242
243 // Roll back to January
244 cal.roll(Calendar.MONTH, (int)(1 + Calendar.DECEMBER - cal.get(Calendar.MONTH)));
245 if (cal.equals(cal2) ||
246 cal2.before(cal) ||
247 cal.after(cal2)) errln("FAIL: equals/before/after failed");
248
249 // C++ only
250 /* TimeZone z = cal.orphanTimeZone();
251 if (z.getID(str) != tzid ||
252 z.getRawOffset() != tzoffset)
253 errln("FAIL: orphanTimeZone failed");
254 */
255
256 for (int i = 0; i < 2; ++i) {
257 boolean lenient = ( i > 0 );
258 cal.setLenient(lenient);
259 if (lenient != cal.isLenient()) errln("FAIL: setLenient/isLenient failed");
260 // Later: Check for lenient behavior
261 }
262
263 int i;
264 for (i = Calendar.SUNDAY; i <= Calendar.SATURDAY; ++i) {
265 cal.setFirstDayOfWeek(i);
266 if (cal.getFirstDayOfWeek() != i) errln("FAIL: set/getFirstDayOfWeek failed");
267 }
268
269 for (i = 0; i <= 7; ++i) {
270 cal.setMinimalDaysInFirstWeek(i);
271 if (cal.getMinimalDaysInFirstWeek() != i) errln("FAIL: set/getFirstDayOfWeek failed");
272 }
273
274 for (i = 0; i < Calendar.FIELD_COUNT; ++i) {
275 if (cal.getMinimum(i) != cal.getGreatestMinimum(i))
276 errln("FAIL: getMinimum doesn't match getGreatestMinimum for field " + i);
277 if (cal.getLeastMaximum(i) > cal.getMaximum(i))
278 errln("FAIL: getLeastMaximum larger than getMaximum for field " + i);
279 if (cal.getMinimum(i) >= cal.getMaximum(i))
280 errln("FAIL: getMinimum not less than getMaximum for field " + i);
281 }
282
283 cal.setTimeZone(TimeZone.getDefault());
284 cal.clear();
285 cal.set(1984, 5, 24);
286 if (cal.getTime().getTime() != new Date(84, 5, 24).getTime()) {
287 errln("FAIL: Calendar.set(3 args) failed");
288 logln(" Got: " + cal.getTime() + " Expected: " + new Date(84, 5, 24));
289 }
290
291 cal.clear();
292 cal.set(1985, 3, 2, 11, 49);
293 if (cal.getTime().getTime() != new Date(85, 3, 2, 11, 49).getTime()) {
294 errln("FAIL: Calendar.set(5 args) failed");
295 logln(" Got: " + cal.getTime() + " Expected: " + new Date(85, 3, 2, 11, 49));
296 }
297
298 cal.clear();
299 cal.set(1995, 9, 12, 1, 39, 55);
300 if (cal.getTime().getTime() != new Date(95, 9, 12, 1, 39, 55).getTime()) {
301 errln("FAIL: Calendar.set(6 args) failed");
302 logln(" Got: " + cal.getTime() + " Expected: " + new Date(95, 9, 12, 1, 39, 55));
303 }
304
305 cal.getTime();
306 for (i = 0; i < Calendar.FIELD_COUNT; ++i) {
307 switch(i) {
308 case Calendar.YEAR: case Calendar.MONTH: case Calendar.DATE:
309 case Calendar.HOUR_OF_DAY: case Calendar.MINUTE: case Calendar.SECOND:
310 if (!cal.isSet(i))
311 errln("FAIL: !Calendar.isSet test failed: " + calendarFieldNames[i]);
312 break;
313 default:
314 if (cal.isSet(i))
315 errln("FAIL: Calendar.isSet test failed: " + calendarFieldNames[i]);
316 }
317 cal.clear(i);
318 if (cal.isSet(i)) errln("FAIL: Calendar.clear/isSet failed");
319 }
320
321 // delete cal;
322 // delete cal2;
323
324 Locale[] loc = Calendar.getAvailableLocales();
325 long count = loc.length;
326 if (count < 1 || loc == null) {
327 errln("FAIL: getAvailableLocales failed");
328 }
329 else {
330 for (i = 0; i < count; ++i) {
331 cal = Calendar.getInstance(loc[i]);
332 // delete cal;
333 }
334 }
335
336 cal = Calendar.getInstance(TimeZone.getDefault(), Locale.ENGLISH);
337 // delete cal;
338
339 cal = Calendar.getInstance(zone, Locale.ENGLISH);
340 // delete cal;
341
342 GregorianCalendar gc = new GregorianCalendar(zone);
343 // delete gc;
344
345 gc = new GregorianCalendar(Locale.ENGLISH);
346 // delete gc;
347
348 gc = new GregorianCalendar(Locale.ENGLISH);
349 // delete gc;
350
351 gc = new GregorianCalendar(zone, Locale.ENGLISH);
352 // delete gc;
353
354 gc = new GregorianCalendar(zone);
355 // delete gc;
356
357 gc = new GregorianCalendar(1998, 10, 14, 21, 43);
358 if (gc.getTime().getTime() != new Date(98, 10, 14, 21, 43).getTime())
359 errln("FAIL: new GregorianCalendar(ymdhm) failed");
360 // delete gc;
361
362 gc = new GregorianCalendar(1998, 10, 14, 21, 43, 55);
363 if (gc.getTime().getTime() != new Date(98, 10, 14, 21, 43, 55).getTime())
364 errln("FAIL: new GregorianCalendar(ymdhms) failed");
365
366 // C++ only:
367 // GregorianCalendar gc2 = new GregorianCalendar(Locale.ENGLISH);
368 // gc2 = gc;
369 // if (gc2 != gc || !(gc2 == gc)) errln("FAIL: GregorianCalendar assignment/operator==/operator!= failed");
370 // delete gc;
371 // delete z;
372 }
373
374 // Verify Roger Webster's bug
375 public void TestRog() {
376 GregorianCalendar gc = new GregorianCalendar();
377
378 int year = 1997, month = Calendar.APRIL, date = 1;
379 gc.set(year, month, date); // April 1, 1997
380
381 gc.set(Calendar.HOUR_OF_DAY, 23);
382 gc.set(Calendar.MINUTE, 0);
383 gc.set(Calendar.SECOND, 0);
384 gc.set(Calendar.MILLISECOND, 0);
385
386 for (int i = 0; i < 9; i++, gc.add(Calendar.DATE, 1)) {
387 if (gc.get(Calendar.YEAR) != year ||
388 gc.get(Calendar.MONTH) != month ||
389 gc.get(Calendar.DATE) != (date + i))
390 errln("FAIL: Date " + gc.getTime() + " wrong");
391 }
392 }
393
394 // Verify DAY_OF_WEEK
395 public void TestDOW943() {
396 dowTest(false);
397 dowTest(true);
398 }
399
400 void dowTest(boolean lenient) {
401 GregorianCalendar cal = new GregorianCalendar();
402 cal.set(1997, Calendar.AUGUST, 12); // Wednesday
403 cal.getTime(); // Force update
404 cal.setLenient(lenient);
405 cal.set(1996, Calendar.DECEMBER, 1); // Set the date to be December 1, 1996
406 int dow = cal.get(Calendar.DAY_OF_WEEK);
407 int min = cal.getMinimum(Calendar.DAY_OF_WEEK);
408 int max = cal.getMaximum(Calendar.DAY_OF_WEEK);
409 if (dow < min || dow > max) errln("FAIL: Day of week " + dow + " out of range");
410 if (dow != Calendar.SUNDAY) {
411 errln("FAIL2: Day of week should be SUNDAY; is " + dow + ": " + cal.getTime());
412 }
413 if (min != Calendar.SUNDAY || max != Calendar.SATURDAY) errln("FAIL: Min/max bad");
414 }
415
416 // Verify that the clone method produces distinct objects with no
417 // unintentionally shared fields.
418 public void TestClonesUnique908() {
419 Calendar c = Calendar.getInstance();
420 Calendar d = (Calendar)c.clone();
421 c.set(Calendar.MILLISECOND, 123);
422 d.set(Calendar.MILLISECOND, 456);
423 if (c.get(Calendar.MILLISECOND) != 123 ||
424 d.get(Calendar.MILLISECOND) != 456) {
425 errln("FAIL: Clones share fields");
426 }
427 }
428
429 // Verify effect of Gregorian cutoff value
430 public void TestGregorianChange768() {
431 boolean b;
432 GregorianCalendar c = new GregorianCalendar();
433 logln("With cutoff " + c.getGregorianChange());
434 logln(" isLeapYear(1800) = " + (b=c.isLeapYear(1800)));
435 logln(" (should be FALSE)");
436 if (b != false) errln("FAIL");
437 c.setGregorianChange(new Date(0, 0, 1)); // Jan 1 1900
438 logln("With cutoff " + c.getGregorianChange());
439 logln(" isLeapYear(1800) = " + (b=c.isLeapYear(1800)));
440 logln(" (should be TRUE)");
441 if (b != true) errln("FAIL");
442 }
443
444 // Test the correct behavior of the disambiguation algorithm.
445 public void TestDisambiguation765() throws Exception {
446 Locale savedLocale = Locale.getDefault();
447 try {
448 Locale.setDefault(Locale.US);
449 Calendar c = Calendar.getInstance();
450 c.setLenient(false);
451
452 c.clear();
453 c.set(Calendar.YEAR, 1997);
454 c.set(Calendar.MONTH, Calendar.JUNE);
455 c.set(Calendar.DATE, 3);
456
457 verify765("1997 third day of June = ", c, 1997, Calendar.JUNE, 3);
458
459 c.clear();
460 c.set(Calendar.YEAR, 1997);
461 c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
462 c.set(Calendar.MONTH, Calendar.JUNE);
463 c.set(Calendar.DAY_OF_WEEK_IN_MONTH, 1);
464 verify765("1997 first Tuesday in June = ", c, 1997, Calendar.JUNE, 3);
465
466 c.setLenient(true); // for 4944795
467 c.clear();
468 c.set(Calendar.YEAR, 1997);
469 c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
470 c.set(Calendar.MONTH, Calendar.JUNE);
471 c.set(Calendar.DAY_OF_WEEK_IN_MONTH, -1);
472 verify765("1997 last Tuesday in June = ", c, 1997, Calendar.JUNE, 24);
473
474 c.setLenient(false);
475 IllegalArgumentException e = null;
476 try {
477 c.clear();
478 c.set(Calendar.YEAR, 1997);
479 c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
480 c.set(Calendar.MONTH, Calendar.JUNE);
481 c.set(Calendar.DAY_OF_WEEK_IN_MONTH, 0);
482 c.getTime();
483 }
484 catch (IllegalArgumentException ex) {
485 e = ex;
486 }
487 verify765("1997 zero-th Tuesday in June = ", e);
488
489 c.clear();
490 c.set(Calendar.YEAR, 1997);
491 c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
492 c.set(Calendar.MONTH, Calendar.JUNE);
493 c.set(Calendar.WEEK_OF_MONTH, 1);
494 verify765("1997 Tuesday in week 1 of June = ", c, 1997, Calendar.JUNE, 3);
495
496 c.clear();
497 c.set(Calendar.YEAR, 1997);
498 c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
499 c.set(Calendar.MONTH, Calendar.JUNE);
500 c.set(Calendar.WEEK_OF_MONTH, 4);
501 verify765("1997 Tuesday in week 4 of June = ", c, 1997, Calendar.JUNE, 24);
502
503 try {
504 c.clear();
505 c.set(Calendar.YEAR, 1997);
506 c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
507 c.set(Calendar.MONTH, Calendar.JUNE);
508 c.set(Calendar.WEEK_OF_MONTH, 1);
509 verify765("1997 Tuesday in week 0 of June = ", c, 1997, Calendar.JUNE, 3);
510 }
511 catch (IllegalArgumentException ex) {
512 errln("FAIL: Exception seen: " + ex.getMessage());
513 // ex.printStackTrace(log);
514 }
515
516 c.clear();
517 c.set(Calendar.YEAR, 1997);
518 c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
519 c.set(Calendar.WEEK_OF_YEAR, 2);
520 verify765("1997 Tuesday in week 2 of year = ", c, 1997, Calendar.JANUARY, 7);
521
522 c.clear();
523 c.set(Calendar.YEAR, 1997);
524 c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
525 c.set(Calendar.WEEK_OF_YEAR, 10);
526 verify765("1997 Tuesday in week 10 of year = ", c, 1997, Calendar.MARCH, 4);
527
528 try {
529 c.clear();
530 c.set(Calendar.YEAR, 1997);
531 c.set(Calendar.DAY_OF_WEEK, Calendar.TUESDAY);
532 c.set(Calendar.WEEK_OF_YEAR, 0);
533 verify765("1997 Tuesday in week 0 of year = ", c, 1996, Calendar.DECEMBER, 24);
534 throw new Exception("Fail: WEEK_OF_YEAR 0 should be illegal");
535 }
536 catch (IllegalArgumentException ex) {}
537 }
538 finally {
539 Locale.setDefault(savedLocale);
540 }
541 }
542 void verify765(String msg, Calendar c, int year, int month, int day) {
543 if (c.get(Calendar.YEAR) == year &&
544 c.get(Calendar.MONTH) == month &&
545 c.get(Calendar.DATE) == day) {
546 logln("PASS: " + msg + c.getTime());
547 }
548 else {
549 errln("FAIL: " + msg + c.getTime() +
550 "; expected " +
551 year + "/" + (month+1) + "/" + day);
552 }
553 }
554 // Called when e expected to be non-null
555 void verify765(String msg, IllegalArgumentException e) {
556 if (e == null) errln("FAIL: No IllegalArgumentException for " + msg);
557 else logln("PASS: " + msg + "IllegalArgument as expected");
558 }
559
560 // Test the behavior of GMT vs. local time
561 public void TestGMTvsLocal4064654() {
562 if (Locale.getDefault().equals(new Locale("th", "TH"))) {
563 return;
564 }
565
566 // Sample output 1:
567 // % /usr/local/java/jdk1.1.3/solaris/bin/java test 1997 1 1 12 0 0
568 // date = Wed Jan 01 04:00:00 PST 1997
569 // offset for Wed Jan 01 04:00:00 PST 1997= -8hr
570 test4064654(1997, 1, 1, 12, 0, 0);
571
572 // Sample output 2:
573 // % /usr/local/java/jdk1.1.3/solaris/bin/java test 1997 4 16 18 30 0
574 // date = Wed Apr 16 10:30:00 PDT 1997
575 // offset for Wed Apr 16 10:30:00 PDT 1997= -7hr
576
577 // Note that in sample output 2 according to the offset, the gmt time
578 // of the result would be 1997 4 16 17 30 0 which is different from the
579 // input of 1997 4 16 18 30 0.
580 test4064654(1997, 4, 16, 18, 30, 0);
581 }
582 void test4064654(int yr, int mo, int dt, int hr, int mn, int sc) {
583 Date date;
584 Calendar gmtcal = Calendar.getInstance();
585 gmtcal.setTimeZone(TimeZone.getTimeZone("Africa/Casablanca"));
586 gmtcal.set(yr, mo-1, dt, hr, mn, sc);
587 gmtcal.set(Calendar.MILLISECOND, 0);
588
589 date = gmtcal.getTime();
590 logln("date = "+date);
591
592 Calendar cal = Calendar.getInstance();
593 cal.setTimeZone(TimeZone.getTimeZone("America/Los_Angeles"));
594 cal.setTime(date);
595
596 int offset = cal.getTimeZone().getOffset(cal.get(Calendar.ERA),
597 cal.get(Calendar.YEAR),
598 cal.get(Calendar.MONTH),
599 cal.get(Calendar.DATE),
600 cal.get(Calendar.DAY_OF_WEEK),
601 cal.get(Calendar.MILLISECOND));
602
603 logln("offset for "+date+"= "+(offset/1000/60/60.0) + "hr");
604
605 int utc = ((cal.get(Calendar.HOUR_OF_DAY) * 60 +
606 cal.get(Calendar.MINUTE)) * 60 +
607 cal.get(Calendar.SECOND)) * 1000 +
608 cal.get(Calendar.MILLISECOND) - offset;
609
610 int expected = ((hr * 60 + mn) * 60 + sc) * 1000;
611
612 if (utc != expected)
613 errln("FAIL: Discrepancy of " +
614 (utc - expected) + " millis = " +
615 ((utc-expected)/1000/60/60.0) + " hr");
616 }
617
618 // Verify that add and set work regardless of the order in which
619 // they are called.
620 public void TestAddSetOrder621() {
621 Date d = new Date(97, 4, 14, 13, 23, 45);
622
623 Calendar cal = Calendar.getInstance ();
624 cal.setTime (d);
625 cal.add (Calendar.DATE, -5);
626 cal.set (Calendar.HOUR_OF_DAY, 0);
627 cal.set (Calendar.MINUTE, 0);
628 cal.set (Calendar.SECOND, 0);
629 // ma feb 03 00:00:00 GMT+00:00 1997
630 String s = cal.getTime ().toString ();
631
632 cal = Calendar.getInstance ();
633 cal.setTime (d);
634 cal.set (Calendar.HOUR_OF_DAY, 0);
635 cal.set (Calendar.MINUTE, 0);
636 cal.set (Calendar.SECOND, 0);
637 cal.add (Calendar.DATE, -5);
638 // ma feb 03 13:11:06 GMT+00:00 1997
639 String s2 = cal.getTime ().toString ();
640
641 if (s.equals(s2))
642 logln("Pass: " + s + " == " + s2);
643 else
644 errln("FAIL: " + s + " != " + s2);
645 }
646
647 // Verify that add works.
648 public void TestAdd520() {
649 int y = 1997, m = Calendar.FEBRUARY, d = 1;
650 GregorianCalendar temp = new GregorianCalendar( y, m, d );
651 check520(temp, y, m, d);
652
653 temp.add( temp.YEAR, 1 );
654 y++;
655 check520(temp, y, m, d);
656
657 temp.add( temp.MONTH, 1 );
658 m++;
659 check520(temp, y, m, d);
660
661 temp.add( temp.DATE, 1 );
662 d++;
663 check520(temp, y, m, d);
664
665 temp.add( temp.DATE, 2 );
666 d += 2;
667 check520(temp, y, m, d);
668
669 temp.add( temp.DATE, 28 );
670 d = 1; ++m;
671 check520(temp, y, m, d);
672 }
673 void check520(Calendar c, int y, int m, int d) {
674 if (c.get(Calendar.YEAR) != y ||
675 c.get(Calendar.MONTH) != m ||
676 c.get(Calendar.DATE) != d) {
677 errln("FAILURE: Expected YEAR/MONTH/DATE of " +
678 y + "/" + (m+1) + "/" + d +
679 "; got " +
680 c.get(Calendar.YEAR) + "/" +
681 (c.get(Calendar.MONTH)+1) + "/" +
682 c.get(Calendar.DATE));
683 }
684 else logln("Confirmed: " +
685 y + "/" + (m+1) + "/" + d);
686 }
687
688 // Verify that setting fields works. This test fails when an exception is thrown.
689 public void TestFieldSet4781() {
690 try {
691 GregorianCalendar g = new GregorianCalendar();
692 GregorianCalendar g2 = new GregorianCalendar();
693 // At this point UTC value is set, various fields are not.
694 // Now set to noon.
695 g2.set(Calendar.HOUR, 12);
696 g2.set(Calendar.MINUTE, 0);
697 g2.set(Calendar.SECOND, 0);
698 // At this point the object thinks UTC is NOT set, but fields are set.
699 // The following line will result in IllegalArgumentException because
700 // it thinks the YEAR is set and it is NOT.
701 if (g2.equals(g))
702 logln("Same");
703 else
704 logln("Different");
705 }
706 catch (IllegalArgumentException e) {
707 errln("Unexpected exception seen: " + e);
708 }
709 }
710
711 // Test serialization of a Calendar object
712 public void TestSerialize337() {
713 Calendar cal = Calendar.getInstance();
714
715 boolean ok = false;
716
717 try {
718 FileOutputStream f = new FileOutputStream(FILENAME);
719 ObjectOutput s = new ObjectOutputStream(f);
720 s.writeObject(PREFIX);
721 s.writeObject(cal);
722 s.writeObject(POSTFIX);
723 f.close();
724
725 FileInputStream in = new FileInputStream(FILENAME);
726 ObjectInputStream t = new ObjectInputStream(in);
727 String pre = (String)t.readObject();
728 Calendar c = (Calendar)t.readObject();
729 String post = (String)t.readObject();
730 in.close();
731
732 ok = pre.equals(PREFIX) &&
733 post.equals(POSTFIX) &&
734 cal.equals(c);
735
736 File fl = new File(FILENAME);
737 fl.delete();
738 }
739 catch (IOException e) {
740 errln("FAIL: Exception received:");
741 // e.printStackTrace(log);
742 }
743 catch (ClassNotFoundException e) {
744 errln("FAIL: Exception received:");
745 // e.printStackTrace(log);
746 }
747
748 if (!ok) errln("Serialization of Calendar object failed.");
749 }
750 static final String PREFIX = "abc";
751 static final String POSTFIX = "def";
752 static final String FILENAME = "tmp337.bin";
753
754 // Try to zero out the seconds field
755 public void TestSecondsZero121() {
756 Calendar cal = new GregorianCalendar();
757 // Initialize with current date/time
758 cal.setTime(new Date());
759 // Round down to minute
760 cal.set(Calendar.SECOND, 0);
761 Date d = cal.getTime();
762 String s = d.toString();
763 if (s.indexOf(":00 ") < 0) errln("Expected to see :00 in " + s);
764 }
765
766 // Try various sequences of add, set, and get method calls.
767 public void TestAddSetGet0610() {
768 //
769 // Error case 1:
770 // - Upon initialization calendar fields, millis = System.currentTime
771 // - After set is called fields are initialized, time is not
772 // - Addition uses millis which are still *now*
773 //
774 {
775 Calendar calendar = new GregorianCalendar( ) ;
776 calendar.set( 1993, Calendar.JANUARY, 4 ) ;
777 logln( "1A) " + value( calendar ) ) ;
778 calendar.add( Calendar.DATE, 1 ) ;
779 String v = value(calendar);
780 logln( "1B) " + v );
781 logln( "--) 1993/0/5" ) ;
782 if (!v.equals(EXPECTED_0610)) errln("Expected " + EXPECTED_0610 +
783 "; saw " + v);
784 }
785
786 //
787 // Error case 2:
788 // - Upon initialization calendar fields set, millis = 0
789 // - Addition uses millis which are still 1970, 0, 1
790 //
791
792 {
793 Calendar calendar = new GregorianCalendar( 1993, Calendar.JANUARY, 4 ) ;
794 logln( "2A) " + value( calendar ) ) ;
795 calendar.add( Calendar.DATE, 1 ) ;
796 String v = value(calendar);
797 logln( "2B) " + v );
798 logln( "--) 1993/0/5" ) ;
799 if (!v.equals(EXPECTED_0610)) errln("Expected " + EXPECTED_0610 +
800 "; saw " + v);
801 }
802
803 //
804 // Error case 3:
805 // - Upon initialization calendar fields, millis = 0
806 // - getTime( ) is called which forces the millis to be set
807 // - Addition uses millis which are correct
808 //
809
810 {
811 Calendar calendar = new GregorianCalendar( 1993, Calendar.JANUARY, 4 ) ;
812 logln( "3A) " + value( calendar ) ) ;
813 calendar.getTime( ) ;
814 calendar.add( Calendar.DATE, 1 ) ;
815 String v = value(calendar);
816 logln( "3B) " + v ) ;
817 logln( "--) 1993/0/5" ) ;
818 if (!v.equals(EXPECTED_0610)) errln("Expected " + EXPECTED_0610 +
819 "; saw " + v);
820 }
821 }
822 static String value( Calendar calendar ) {
823 return( calendar.get( Calendar.YEAR ) + "/" +
824 calendar.get( Calendar.MONTH ) + "/" +
825 calendar.get( Calendar.DATE ) ) ;
826 }
827 static String EXPECTED_0610 = "1993/0/5";
828
829 // Test that certain fields on a certain date are as expected.
830 public void TestFields060() {
831 int year = 1997;
832 int month = java.util.Calendar.OCTOBER; //october
833 int dDate = 22; //DAYOFWEEK should return 3 for Wednesday
834 GregorianCalendar calendar = null;
835
836 calendar = new GregorianCalendar( year, month, dDate);
837 for (int i = 0; i < EXPECTED_FIELDS.length; ) {
838 int field = EXPECTED_FIELDS[i++];
839 int expected = EXPECTED_FIELDS[i++];
840 if (calendar.get(field) != expected) {
841 errln("Expected field " + field + " to have value " + expected +
842 "; received " + calendar.get(field) + " instead");
843 }
844 }
845 }
846 static int EXPECTED_FIELDS[] = {
847 Calendar.YEAR, 1997,
848 Calendar.MONTH, Calendar.OCTOBER,
849 Calendar.DAY_OF_MONTH, 22,
850 Calendar.DAY_OF_WEEK, Calendar.WEDNESDAY,
851 Calendar.DAY_OF_WEEK_IN_MONTH, 4,
852 Calendar.DAY_OF_YEAR, 295
853 };
854
855 static final String[] calendarFieldNames = {
856 /* 0 */ "ERA",
857 /* 1 */ "YEAR",
858 /* 2 */ "MONTH",
859 /* 3 */ "WEEK_OF_YEAR",
860 /* 4 */ "WEEK_OF_MONTH",
861 /* 5 */ "DAY_OF_MONTH",
862 /* 6 */ "DAY_OF_YEAR",
863 /* 7 */ "DAY_OF_WEEK",
864 /* 8 */ "DAY_OF_WEEK_IN_MONTH",
865 /* 9 */ "AM_PM",
866 /* 10 */ "HOUR",
867 /* 11 */ "HOUR_OF_DAY",
868 /* 12 */ "MINUTE",
869 /* 13 */ "SECOND",
870 /* 14 */ "MILLISECOND",
871 /* 15 */ "ZONE_OFFSET",
872 /* 16 */ "DST_OFFSET"
873 };
874
875 // Verify that the fields are as expected (mostly zero) at the epoch start.
876 // Note that we adjust for the default timezone to get most things to zero.
877 public void TestEpochStartFields() {
878 if (Locale.getDefault().equals(new Locale("th", "TH"))) {
879 return;
880 }
881
882 String[][] lt = {
883 {"en", "US", "US/Pacific"}, /* First day = 1, Minimum day = 1 */
884 {"en", "US", "America/Anchorage"}, /* First day = 1, Minimum day = 1 */
885 {"en", "TO", "Pacific/Tongatapu"}, /* First day = 1, Minimum day = 1 */
886 {"en", "MH", "Pacific/Majuro"}, /* First day = 1, Minimum day = 1 */
887 {"ja", "JP", "Asia/Tokyo"}, /* First day = 1, Minimum day = 1 */
888 {"iw", "IL", "Asia/Jerusalem"}, /* First day = 1, Minimum day = 1 */
889 {"hi", "IN", "Asia/Jakarta"}, /* First day = 1, Minimum day = 1 */
890 {"en", "GB", "Europe/London"}, /* First day = 2, Minimum day = 1 */
891 {"en", "GB", "GMT"}, /* First day = 2, Minimum day = 1 */
892 {"de", "DE", "Europe/Berlin"}, /* First day = 2, Minimum day = 4 */
893 {"ar", "EG", "Africa/Cairo"}, /* First day = 7, Minimum day = 1 */
894 };
895
896 int[][] goldenData = {
897 {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, -28800000, 0},
898 {1, 1969, 11, 1, 5, 31, 365, 4, 5, 1, 11, 23, 0, 0, 0, -36000000, 0},
899 {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 46800000, 0},
900 {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 43200000, 0},
901 {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 32400000, 0},
902 {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 7200000, 0},
903 {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 25200000, 0},
904 {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 1, 1, 0, 0, 0, 3600000, 0},
905 {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 0, 0},
906 {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 3600000, 0},
907 {1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 7200000, 0},
908 };
909
910 Locale savedLocale = Locale.getDefault();
911 TimeZone savedTimeZone = TimeZone.getDefault();
912
913 try {
914 for (int j = 0; j < lt.length; j++) {
915 Locale l = new Locale(lt[j][0], lt[j][1]);
916 TimeZone z = TimeZone.getTimeZone(lt[j][2]);
917 Locale.setDefault(l);
918 TimeZone.setDefault(z);
919 Calendar c = Calendar.getInstance();
920 Date d = new Date(-z.getRawOffset());
921
922 int val;
923 int[] EPOCH_FIELDS = goldenData[j];
924 c.setTime(d);
925
926 boolean err = false;
927 for (int i = 0; i < calendarFieldNames.length; ++i) {
928 if ((val = c.get(i)) != EPOCH_FIELDS[i]) {
929 errln("Wrong value: " + val +
930 " for field(" + calendarFieldNames[i] +
931 "), expected: " + EPOCH_FIELDS[i]);
932 err = true;
933 }
934 }
935 if (err) {
936 errln("Failed: \n\tDate=" + d + "\n\tTimeZone=" + z +
937 "\n\tLocale=" + l + "\n\tCalendar=" + c);
938 }
939 }
940 }
941 finally {
942 Locale.setDefault(savedLocale);
943 TimeZone.setDefault(savedTimeZone);
944 }
945 }
946
947 // Verify that as you add days to the calendar (e.g., 24 day periods),
948 // the day of the week shifts in the expected pattern.
949 public void TestDOWProgression() {
950 Calendar cal =
951 new GregorianCalendar(1972, Calendar.OCTOBER, 26);
952 marchByDelta(cal, 24); // Last parameter must be != 0 modulo 7
953 }
954
955 // Supply a delta which is not a multiple of 7.
956 void marchByDelta(Calendar cal, int delta) {
957 Calendar cur = (Calendar)cal.clone();
958 int initialDOW = cur.get(Calendar.DAY_OF_WEEK);
959 int DOW, newDOW = initialDOW;
960 do {
961 DOW = newDOW;
962 logln("DOW = " + DOW + " " + cur.getTime());
963
964 cur.add(Calendar.DAY_OF_WEEK, delta);
965 newDOW = cur.get(Calendar.DAY_OF_WEEK);
966 int expectedDOW = 1 + (DOW + delta - 1) % 7;
967 if (newDOW != expectedDOW) {
968 errln("Day of week should be " + expectedDOW +
969 " instead of " + newDOW + " on " + cur.getTime());
970 return;
971 }
972 }
973 while (newDOW != initialDOW);
974 }
975
976 public void TestActualMinMax() {
977 Calendar cal = new GregorianCalendar(1967, Calendar.MARCH, 10);
978 cal.setFirstDayOfWeek(Calendar.SUNDAY);
979 cal.setMinimalDaysInFirstWeek(3);
980
981 if (cal.getActualMinimum(Calendar.DAY_OF_MONTH) != 1)
982 errln("Actual minimum date for 3/10/1967 should have been 1; got " +
983 cal.getActualMinimum(Calendar.DAY_OF_MONTH));
984 if (cal.getActualMaximum(Calendar.DAY_OF_MONTH) != 31)
985 errln("Actual maximum date for 3/10/1967 should have been 31; got " +
986 cal.getActualMaximum(Calendar.DAY_OF_MONTH));
987
988 cal.set(Calendar.MONTH, Calendar.FEBRUARY);
989 if (cal.getActualMaximum(Calendar.DAY_OF_MONTH) != 28)
990 errln("Actual maximum date for 2/10/1967 should have been 28; got " +
991 cal.getActualMaximum(Calendar.DAY_OF_MONTH));
992 if (cal.getActualMaximum(Calendar.DAY_OF_YEAR) != 365)
993 errln("Number of days in 1967 should have been 365; got " +
994 cal.getActualMaximum(Calendar.DAY_OF_YEAR));
995
996 cal.set(Calendar.YEAR, 1968);
997 if (cal.getActualMaximum(Calendar.DAY_OF_MONTH) != 29)
998 errln("Actual maximum date for 2/10/1968 should have been 29; got " +
999 cal.getActualMaximum(Calendar.DAY_OF_MONTH));
1000 if (cal.getActualMaximum(Calendar.DAY_OF_YEAR) != 366)
1001 errln("Number of days in 1968 should have been 366; got " +
1002 cal.getActualMaximum(Calendar.DAY_OF_YEAR));
1003 // Using week settings of SUNDAY/3 (see above)
1004 if (cal.getActualMaximum(Calendar.WEEK_OF_YEAR) != 52)
1005 errln("Number of weeks in 1968 should have been 52; got " +
1006 cal.getActualMaximum(Calendar.WEEK_OF_YEAR));
1007
1008 cal.set(Calendar.YEAR, 1976);
1009 // Using week settings of SUNDAY/3 (see above)
1010 if (cal.getActualMaximum(Calendar.WEEK_OF_YEAR) != 53)
1011 errln("Number of weeks in 1976 should have been 53; got " +
1012 cal.getActualMaximum(Calendar.WEEK_OF_YEAR));
1013 }
1014
1015 public void TestRoll() {
1016 Calendar cal = new GregorianCalendar(1997, Calendar.JANUARY, 31);
1017
1018 int[] dayValues = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 31 };
1019
1020 for (int i = 0; i < dayValues.length; i++) {
1021 Calendar cal2 = (Calendar)cal.clone();
1022 cal2.roll(Calendar.MONTH, i);
1023 if (cal2.get(Calendar.DAY_OF_MONTH) != dayValues[i])
1024 errln("Rolling the month in 1/31/1997 up by " + i + " should have yielded "
1025 + ((i + 1) % 12) + "/" + dayValues[i] + "/1997, but actually yielded "
1026 + ((i + 1) % 12) + "/" + cal2.get(Calendar.DAY_OF_MONTH) + "/1997.");
1027 }
1028
1029 cal.set(1996, Calendar.FEBRUARY, 29);
1030
1031 int[] monthValues = { 1, 2, 2, 2, 1, 2, 2, 2, 1, 2 };
1032 int[] dayValues2 = { 29, 1, 1, 1, 29, 1, 1, 1, 29, 1 };
1033
1034 for (int i = 0; i < dayValues2.length; i++) {
1035 Calendar cal2 = (Calendar)cal.clone();
1036 cal2.roll(Calendar.YEAR, i);
1037 if (cal2.get(Calendar.DAY_OF_MONTH) != dayValues2[i] || cal2.get(Calendar.MONTH)
1038 != monthValues[i])
1039 errln("Rolling the year in 2/29/1996 up by " + i + " should have yielded "
1040 + (monthValues[i] + 1) + "/" + dayValues2[i] + "/"
1041 + (1996 + i) + ", but actually yielded "
1042 + (cal2.get(Calendar.MONTH) + 1) + "/" +
1043 cal2.get(Calendar.DAY_OF_MONTH) + "/" + (1996 + i) + ".");
1044 }
1045
1046 // Test rolling hour of day
1047 cal.set(Calendar.HOUR_OF_DAY, 0);
1048 cal.roll(Calendar.HOUR_OF_DAY, -2);
1049 int f = cal.get(Calendar.HOUR_OF_DAY);
1050 if (f != 22) errln("Rolling HOUR_OF_DAY=0 delta=-2 gave " + f + " Wanted 22");
1051 cal.roll(Calendar.HOUR_OF_DAY, 5);
1052 f = cal.get(Calendar.HOUR_OF_DAY);
1053 if (f != 3) errln("Rolling HOUR_OF_DAY=22 delta=5 gave " + f + " Wanted 3");
1054 cal.roll(Calendar.HOUR_OF_DAY, 21);
1055 f = cal.get(Calendar.HOUR_OF_DAY);
1056 if (f != 0) errln("Rolling HOUR_OF_DAY=3 delta=21 gave " + f + " Wanted 0");
1057
1058 // Test rolling hour
1059 cal.set(Calendar.HOUR_OF_DAY, 0);
1060 cal.roll(Calendar.HOUR, -2);
1061 f = cal.get(Calendar.HOUR);
1062 if (f != 10) errln("Rolling HOUR=0 delta=-2 gave " + f + " Wanted 10");
1063 cal.roll(Calendar.HOUR, 5);
1064 f = cal.get(Calendar.HOUR);
1065 if (f != 3) errln("Rolling HOUR=10 delta=5 gave " + f + " Wanted 3");
1066 cal.roll(Calendar.HOUR, 9);
1067 f = cal.get(Calendar.HOUR);
1068 if (f != 0) errln("Rolling HOUR=3 delta=9 gave " + f + " Wanted 0");
1069 }
1070
1071 /*
1072 * Confirm that multiple calls to Calendar.set() works correctly.
1073 */
1074 public void Test4374886() {
1075 Locale savedLocale = Locale.getDefault();
1076 TimeZone savedTimeZone = TimeZone.getDefault();
1077
1078 try {
1079 Locale.setDefault(Locale.US);
1080 TimeZone.setDefault(TimeZone.getTimeZone("PST"));
1081
1082 Calendar cal = Calendar.getInstance();
1083 cal.set(Calendar.YEAR, 2001);
1084 cal.set(Calendar.MONTH, Calendar.OCTOBER);
1085 cal.set(Calendar.WEEK_OF_YEAR, 4);
1086 cal.set(Calendar.DAY_OF_WEEK, 2);
1087
1088 if (cal.get(Calendar.YEAR) != 2001 ||
1089 cal.get(Calendar.MONTH) != Calendar.JANUARY ||
1090 cal.get(Calendar.DATE) != 22 ||
1091 cal.get(Calendar.DAY_OF_WEEK) != Calendar.MONDAY) {
1092 errln("Failed : got " + cal.getTime() + ", expected Mon Jan 22, 2001");
1093 }
1094 }
1095 finally {
1096 Locale.setDefault(savedLocale);
1097 TimeZone.setDefault(savedTimeZone);
1098 }
1099 }
1100 }
1101
1102 //eof