]> git.saurik.com Git - apple/icu.git/blob - icuSources/test/intltest/calregts.cpp
projects / apple / icu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ICU-400.37.tar.gz
[apple/icu.git] / icuSources / test / intltest / calregts.cpp
1 /********************************************************************
2 * COPYRIGHT:
3 * Copyright (c) 1997-2009, International Business Machines Corporation
4 * and others. All Rights Reserved.
5 ********************************************************************/
6
7 #include "unicode/utypes.h"
8
9 #if !UCONFIG_NO_FORMATTING
10
11 #include "calregts.h"
12
13 #include "unicode/gregocal.h"
14 #include "unicode/simpletz.h"
15 #include "unicode/smpdtfmt.h"
16 #include "unicode/strenum.h"
17 #include "cmemory.h"
18 #include "caltest.h"
19
20 #include <float.h>
21
22 // *****************************************************************************
23 // class CalendarRegressionTest
24 // *****************************************************************************
25
26 // these numbers correspond to using LONG_MIN and LONG_MAX in Java
27 // this is 2^52 - 1, the largest allowable mantissa with a 0 exponent in a 64-bit double
28 const UDate CalendarRegressionTest::EARLIEST_SUPPORTED_MILLIS = - 4503599627370495.0;
29 const UDate CalendarRegressionTest::LATEST_SUPPORTED_MILLIS = 4503599627370495.0;
30
31 #define CASE(id,test) case id: name = #test; if (exec) { logln(#test "---"); logln((UnicodeString)""); test(); } break
32
33 void
34 CalendarRegressionTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
35 {
36 // if (exec) logln((UnicodeString)"TestSuite NumberFormatRegressionTest");
37 switch (index) {
38 CASE(0,test4100311);
39 CASE(1,test4074758);
40 CASE(2,test4028518);
41 CASE(3,test4031502);
42 CASE(4,test4035301);
43 CASE(5,test4040996);
44 CASE(6,test4051765);
45 CASE(7,test4061476);
46 CASE(8,test4070502);
47 CASE(9,test4071197);
48 CASE(10,test4071385);
49 CASE(11,test4073929);
50 CASE(12,test4083167);
51 CASE(13,test4086724);
52 CASE(14,test4095407);
53 CASE(15,test4096231);
54 CASE(16,test4096539);
55 CASE(17,test41003112);
56 CASE(18,test4103271);
57 CASE(19,test4106136);
58 CASE(20,test4108764);
59 CASE(21,test4114578);
60 CASE(22,test4118384);
61 CASE(23,test4125881);
62 CASE(24,test4125892);
63 CASE(25,test4141665);
64 CASE(26,test4142933);
65 CASE(27,test4145158);
66 CASE(28,test4145983);
67 CASE(29,test4147269);
68
69 CASE(30,Test4149677);
70 CASE(31,Test4162587);
71 CASE(32,Test4165343);
72 CASE(33,Test4166109);
73 CASE(34,Test4167060);
74 CASE(35,Test4197699);
75 CASE(36,TestJ81);
76 CASE(37,TestJ438);
77 CASE(38,TestLeapFieldDifference);
78 CASE(39,TestMalaysianInstance);
79 CASE(40,test4059654);
80 CASE(41,test4092362);
81 CASE(42,TestWeekShift);
82 CASE(43,TestTimeZoneTransitionAdd);
83 CASE(44,TestDeprecates);
84 CASE(45,TestT5555);
85 CASE(46,TestT6745);
86 default: name = ""; break;
87 }
88 }
89
90 const char* CalendarRegressionTest::FIELD_NAME [] = {
91 "ERA",
92 "YEAR",
93 "MONTH",
94 "WEEK_OF_YEAR",
95 "WEEK_OF_MONTH",
96 "DAY_OF_MONTH",
97 "DAY_OF_YEAR",
98 "DAY_OF_WEEK",
99 "DAY_OF_WEEK_IN_MONTH",
100 "AM_PM",
101 "HOUR",
102 "HOUR_OF_DAY",
103 "MINUTE",
104 "SECOND",
105 "MILLISECOND",
106 "ZONE_OFFSET",
107 "DST_OFFSET",
108 "YEAR_WOY",
109 "DOW_LOCAL"
110 };
111
112 UBool
113 CalendarRegressionTest::failure(UErrorCode status, const char* msg)
114 {
115 if(U_FAILURE(status)) {
116 errln(UnicodeString("FAIL: ") + msg + " failed, error " + u_errorName(status));
117 return TRUE;
118 }
119
120 return FALSE;
121 }
122
123 /*
124 * bug 4100311
125 */
126 void
127 CalendarRegressionTest::test4100311()
128 {
129 UErrorCode status = U_ZERO_ERROR;
130 GregorianCalendar *cal = (GregorianCalendar*)Calendar::createInstance(status);
131 if(U_FAILURE(status)) {
132 errln("Error creating Calendar: %s", u_errorName(status));
133 delete cal;
134 return;
135 }
136 failure(status, "Calendar::createInstance(status)");
137 cal->set(UCAL_YEAR, 1997);
138 cal->set(UCAL_DAY_OF_YEAR, 1);
139 UDate d = cal->getTime(status); // Should be Jan 1
140 failure(status, "cal->getTime");
141 logln(UnicodeString("") + d);
142 delete cal;
143 }
144
145
146 /**
147 * @bug 4074758
148 */
149 void
150 CalendarRegressionTest::test4074758()
151 { //Set system time to between 12-1 (am or pm) and then run
152 UErrorCode status = U_ZERO_ERROR;
153 GregorianCalendar *cal = new GregorianCalendar(status);
154 if(U_FAILURE(status)) {
155 errln("Error creating Calendar: %s", u_errorName(status));
156 delete cal;
157 return;
158 }
159 failure(status, "new GregorianCalendar");
160 for (int32_t h=0; h<25; ++h) {
161 cal->set(97, UCAL_JANUARY, 1, h, 34);
162 //System.out.print(d);
163 logln(UnicodeString("HOUR=") + cal->get(UCAL_HOUR, status)); //prints 0
164 failure(status, "cal->get");
165 logln(UnicodeString("HOUR_OF_DAY=") + cal->get(UCAL_HOUR_OF_DAY, status));
166 failure(status, "cal->get");
167 }
168
169 delete cal;
170 }
171
172 void
173 CalendarRegressionTest::test4028518()
174 {
175 UErrorCode status = U_ZERO_ERROR;
176 GregorianCalendar *cal1 = new GregorianCalendar(status) ;
177 if(U_FAILURE(status)) {
178 errln("Error creating Calendar: %s", u_errorName(status));
179 delete cal1;
180 return;
181 }
182 failure(status, "new GregorianCalendar");
183 GregorianCalendar *cal2 = (GregorianCalendar*) cal1->clone() ;
184
185 printdate(cal1, "cal1: ") ;
186 printdate(cal2, "cal2 - cloned(): ") ;
187 cal1->add(UCAL_DATE, 1, status) ;
188 failure(status, "cal1->add");
189 printdate(cal1, "cal1 after adding 1 day:") ;
190 printdate(cal2, "cal2 should be unmodified:") ;
191 delete cal1;
192 delete cal2;
193 }
194
195 void
196 CalendarRegressionTest::printdate(GregorianCalendar *cal, const char *string)
197 {
198 UErrorCode status = U_ZERO_ERROR;
199 logln(UnicodeString(string, ""));
200 log(UnicodeString("") + cal->get(UCAL_MONTH, status)) ;
201 failure(status, "cal->get");
202 int32_t date = cal->get(UCAL_DATE, status) + 1 ;
203 failure(status, "cal->get");
204 log(UnicodeString("/") + date) ;
205 logln(UnicodeString("/") + cal->get(UCAL_YEAR, status)) ;
206 failure(status, "cal->get");
207 }
208
209 /**
210 * @bug 4031502
211 */
212 void
213 CalendarRegressionTest::test4031502()
214 {
215 // This bug actually occurs on Windows NT as well, and doesn't
216 // require the host zone to be set; it can be set in Java.
217 UErrorCode status = U_ZERO_ERROR;
218 StringEnumeration* ids = TimeZone::createEnumeration();
219 UBool bad = FALSE;
220 TimeZone* tz =TimeZone::createTimeZone("Asia/Riyadh87");
221 failure(status, "new TimeZone");
222 GregorianCalendar *cl = new GregorianCalendar(tz, status);
223 failure(status, "new GregorianCalendar");
224 cl->clear();
225 cl->set(1900, 15, 5, 5, 8, 13);
226 cl->get(UCAL_HOUR, status);
227 failure(status, "cl->get(UCAL_HOUR, status)");
228 status = U_ZERO_ERROR;
229 delete cl;
230 for (int32_t i=0; i<ids->count(status); ++i) {
231 TimeZone *zone = TimeZone::createTimeZone(*ids->snext(status));
232 GregorianCalendar *cal = new GregorianCalendar(zone, status);
233 failure(status, "new GregorianCalendar");
234 cal->clear();
235 cal->set(1900, 15, 5, 5, 8, 13);
236 if (cal->get(UCAL_HOUR, status) != 5 || U_FAILURE(status)) {
237 UnicodeString temp;
238 logln(zone->getID(temp) + " " +
239 //zone.useDaylightTime() + " " +
240 cal->get(UCAL_DST_OFFSET,status) / (60*60*1000) + " " +
241 zone->getRawOffset() / (60*60*1000) +
242 ": HOUR = " + cal->get(UCAL_HOUR,status));
243 bad = TRUE;
244 }
245 delete cal;
246 }
247 if (bad)
248 errln("TimeZone problems with GC");
249 // delete [] ids; // TODO: bad APIs
250 delete ids;
251 }
252
253 /**
254 * @bug 4035301
255 */
256 void CalendarRegressionTest::test4035301()
257 {
258 UErrorCode status = U_ZERO_ERROR;
259 GregorianCalendar *c = new GregorianCalendar(98, 8, 7,status);
260 GregorianCalendar *d = new GregorianCalendar(98, 8, 7,status);
261 if (c->after(*d,status) ||
262 c->after(*c,status) ||
263 c->before(*d,status) ||
264 c->before(*c,status) ||
265 *c != *c ||
266 *c != *d)
267 errln("Fail");
268 delete c;
269 delete d;
270 }
271
272 /**
273 * @bug 4040996
274 */
275 void CalendarRegressionTest::test4040996()
276 {
277 int32_t count = 0;
278 StringEnumeration* ids = TimeZone::createEnumeration(-8 * 60 * 60 * 1000);
279 UErrorCode status = U_ZERO_ERROR;
280 count = ids->count(status);
281 SimpleTimeZone *pdt = new SimpleTimeZone(-8 * 60 * 60 * 1000, *ids->snext(status));
282 pdt->setStartRule(UCAL_APRIL, 1, UCAL_SUNDAY, 2 * 60 * 60 * 1000, status);
283 pdt->setEndRule(UCAL_OCTOBER, -1, UCAL_SUNDAY, 2 * 60 * 60 * 1000, status);
284 Calendar *calendar = new GregorianCalendar(pdt, status);
285
286 calendar->set(UCAL_MONTH,3);
287 calendar->set(UCAL_DATE,18);
288 calendar->set(UCAL_SECOND, 30);
289
290 logln(UnicodeString("MONTH: ") + calendar->get(UCAL_MONTH, status));
291 logln(UnicodeString("DAY_OF_MONTH: ") +
292 calendar->get(UCAL_DATE, status));
293 logln(UnicodeString("MINUTE: ") + calendar->get(UCAL_MINUTE, status));
294 logln(UnicodeString("SECOND: ") + calendar->get(UCAL_SECOND, status));
295
296 calendar->add(UCAL_SECOND,6, status);
297 //This will print out todays date for MONTH and DAY_OF_MONTH
298 //instead of the date it was set to.
299 //This happens when adding MILLISECOND or MINUTE also
300 logln(UnicodeString("MONTH: ") + calendar->get(UCAL_MONTH, status));
301 logln(UnicodeString("DAY_OF_MONTH: ") +
302 calendar->get(UCAL_DATE, status));
303 logln(UnicodeString("MINUTE: ") + calendar->get(UCAL_MINUTE, status));
304 logln(UnicodeString("SECOND: ") + calendar->get(UCAL_SECOND, status));
305 if (calendar->get(UCAL_MONTH, status) != 3 ||
306 calendar->get(UCAL_DATE, status) != 18 ||
307 calendar->get(UCAL_SECOND, status) != 36)
308 errln(UnicodeString("Fail: Calendar::add misbehaves"));
309
310 delete calendar;
311 delete ids;
312 // delete ids; // TODO: BAD API
313 }
314
315 /**
316 * @bug 4051765
317 */
318 void CalendarRegressionTest::test4051765()
319 {
320 UErrorCode status = U_ZERO_ERROR;
321 Calendar *cal = Calendar::createInstance(status);
322 if(U_FAILURE(status)) {
323 errln("Error creating Calendar: %s", u_errorName(status));
324 delete cal;
325 return;
326 }
327 cal->setLenient(FALSE);
328 cal->set(UCAL_DAY_OF_WEEK, 0);
329 //try {
330 cal->getTime(status);
331 if( ! U_FAILURE(status))
332 errln("Fail: DAY_OF_WEEK 0 should be disallowed");
333 /*}
334 catch (IllegalArgumentException e) {
335 return;
336 }*/
337
338 delete cal;
339 }
340
341 /* User error - no bug here
342 void CalendarRegressionTest::test4059524() {
343 // Create calendar for April 10, 1997
344 GregorianCalendar calendar = new GregorianCalendar(status);
345 // print out a bunch of interesting things
346 logln("ERA: " + Calendar::get(Calendar::ERA));
347 logln("YEAR: " + Calendar::get(Calendar::YEAR));
348 logln("MONTH: " + Calendar::get(Calendar::MONTH));
349 logln("WEEK_OF_YEAR: " +
350 Calendar::get(Calendar::WEEK_OF_YEAR));
351 logln("WEEK_OF_MONTH: " +
352 Calendar::get(Calendar::WEEK_OF_MONTH));
353 logln("DATE: " + Calendar::get(Calendar::DATE));
354 logln("DAY_OF_MONTH: " +
355 Calendar::get(Calendar::DAY_OF_MONTH));
356 logln("DAY_OF_YEAR: " + Calendar::get(Calendar::DAY_OF_YEAR));
357 logln("DAY_OF_WEEK: " + Calendar::get(Calendar::DAY_OF_WEEK));
358 logln("DAY_OF_WEEK_IN_MONTH: " +
359 Calendar::get(Calendar::DAY_OF_WEEK_IN_MONTH));
360 logln("AM_PM: " + Calendar::get(Calendar::AM_PM));
361 logln("HOUR: " + Calendar::get(Calendar::HOUR));
362 logln("HOUR_OF_DAY: " + Calendar::get(Calendar::HOUR_OF_DAY));
363 logln("MINUTE: " + Calendar::get(Calendar::MINUTE));
364 logln("SECOND: " + Calendar::get(Calendar::SECOND));
365 logln("MILLISECOND: " + Calendar::get(Calendar::MILLISECOND));
366 logln("ZONE_OFFSET: "
367 + (Calendar::get(Calendar::ZONE_OFFSET)/(60*60*1000)));
368 logln("DST_OFFSET: "
369 + (Calendar::get(Calendar::DST_OFFSET)/(60*60*1000)));
370 calendar = new GregorianCalendar(1997,3,10);
371 Calendar::getTime();
372 logln("April 10, 1997");
373 logln("ERA: " + Calendar::get(Calendar::ERA));
374 logln("YEAR: " + Calendar::get(Calendar::YEAR));
375 logln("MONTH: " + Calendar::get(Calendar::MONTH));
376 logln("WEEK_OF_YEAR: " +
377 Calendar::get(Calendar::WEEK_OF_YEAR));
378 logln("WEEK_OF_MONTH: " +
379 Calendar::get(Calendar::WEEK_OF_MONTH));
380 logln("DATE: " + Calendar::get(Calendar::DATE));
381 logln("DAY_OF_MONTH: " +
382 Calendar::get(Calendar::DAY_OF_MONTH));
383 logln("DAY_OF_YEAR: " + Calendar::get(Calendar::DAY_OF_YEAR));
384 logln("DAY_OF_WEEK: " + Calendar::get(Calendar::DAY_OF_WEEK));
385 logln("DAY_OF_WEEK_IN_MONTH: " + Calendar::get(Calendar::DAY_OF_WEEK_IN_MONTH));
386 logln("AM_PM: " + Calendar::get(Calendar::AM_PM));
387 logln("HOUR: " + Calendar::get(Calendar::HOUR));
388 logln("HOUR_OF_DAY: " + Calendar::get(Calendar::HOUR_OF_DAY));
389 logln("MINUTE: " + Calendar::get(Calendar::MINUTE));
390 logln("SECOND: " + Calendar::get(Calendar::SECOND));
391 logln("MILLISECOND: " + Calendar::get(Calendar::MILLISECOND));
392 logln("ZONE_OFFSET: "
393 + (Calendar::get(Calendar::ZONE_OFFSET)/(60*60*1000))); // in hours
394 logln("DST_OFFSET: "
395 + (Calendar::get(Calendar::DST_OFFSET)/(60*60*1000))); // in hours
396 }
397 */
398
399 /**
400 * @bug 4059654
401 */
402 void CalendarRegressionTest::test4059654() {
403 UErrorCode status = U_ZERO_ERROR;
404 GregorianCalendar *gc = new GregorianCalendar(status);
405 if(U_FAILURE(status)) {
406 errln("Error creating Calendar: %s", u_errorName(status));
407 delete gc;
408 return;
409 }
410
411 gc->set(1997, 3, 1, 15, 16, 17); // April 1, 1997
412
413 gc->set(UCAL_HOUR, 0);
414 gc->set(UCAL_AM_PM, UCAL_AM);
415 gc->set(UCAL_MINUTE, 0);
416 gc->set(UCAL_SECOND, 0);
417 gc->set(UCAL_MILLISECOND, 0);
418
419 UDate cd = gc->getTime(status);
420 GregorianCalendar *exp = new GregorianCalendar(1997, 3, 1, 0, 0, 0, status);
421 if (cd != exp->getTime(status))
422 errln(UnicodeString("Fail: Calendar::set broken. Got ") + cd + " Want " + exp->getTime(status));
423
424 delete gc;
425 delete exp;
426 }
427
428 /**
429 * @bug 4061476
430 */
431 void CalendarRegressionTest::test4061476()
432 {
433 UErrorCode status = U_ZERO_ERROR;
434 SimpleDateFormat *fmt = new SimpleDateFormat(UnicodeString("ddMMMyy"), Locale::getUK(),status);
435 Calendar *cal = Calendar::createInstance(TimeZone::createTimeZone("GMT"),
436 Locale::getUK(),status);
437 if(U_FAILURE(status)) {
438 errln("Error creating Calendar: %s", u_errorName(status));
439 delete cal;
440 delete fmt;
441 return;
442 }
443 fmt->adoptCalendar(cal);
444 // try {
445 UDate date = fmt->parse("29MAY97", status);
446 failure(status, "fmt->parse");
447 cal->setTime(date, status);
448 failure(status, "cal->setTime");
449 // }
450 //catch (Exception e) {;}
451 cal->set(UCAL_HOUR_OF_DAY, 13);
452 logln(UnicodeString("Hour: ")+cal->get(UCAL_HOUR_OF_DAY, status));
453 cal->add(UCAL_HOUR_OF_DAY, 6,status);
454 logln(UnicodeString("Hour: ")+cal->get(UCAL_HOUR_OF_DAY, status));
455 if (cal->get(UCAL_HOUR_OF_DAY, status) != 19)
456 errln(UnicodeString("Fail: Want 19 Got ") + cal->get(UCAL_HOUR_OF_DAY, status));
457
458 delete fmt;
459 }
460
461 /**
462 * @bug 4070502
463 */
464 void CalendarRegressionTest::test4070502()
465 {
466 UErrorCode status = U_ZERO_ERROR;
467 Calendar *cal = new GregorianCalendar(status);
468 if(status == U_USING_FALLBACK_WARNING) {
469 errln("Error creating Calendar: %s", u_errorName(status));
470 delete cal;
471 return;
472 }
473 UDate d = getAssociatedDate(makeDate(1998,0,30), status);
474 cal->setTime(d,status);
475 if (cal->get(UCAL_DAY_OF_WEEK,status) == UCAL_SATURDAY ||
476 cal->get(UCAL_DAY_OF_WEEK,status) == UCAL_SUNDAY)
477 errln(UnicodeString("Fail: Want weekday Got ") + d);
478
479 delete cal;
480 }
481
482 /**
483 * Get the associated date starting from a specified date
484 * NOTE: the unnecessary "getTime()'s" below are a work-around for a
485 * bug in jdk 1.1.3 (and probably earlier versions also)
486 * <p>
487 * @param date The date to start from
488 */
489 UDate
490 CalendarRegressionTest::getAssociatedDate(UDate d, UErrorCode& status)
491 {
492 GregorianCalendar *cal = new GregorianCalendar(status);
493 cal->setTime(d,status);
494 //cal.add(field, amount); //<-- PROBLEM SEEN WITH field = DATE,MONTH
495 // cal.getTime(); // <--- REMOVE THIS TO SEE BUG
496 for (;;) {
497 int32_t wd = cal->get(UCAL_DAY_OF_WEEK, status);
498 if (wd == UCAL_SATURDAY || wd == UCAL_SUNDAY) {
499 cal->add(UCAL_DATE, 1, status);
500 // cal.getTime();
501 }
502 else
503 break;
504 }
505
506 UDate dd = cal->getTime(status);
507 delete cal;
508 return dd;
509 }
510
511 /**
512 * @bug 4071197
513 */
514 void CalendarRegressionTest::test4071197()
515 {
516 dowTest(FALSE);
517 dowTest(TRUE);
518 }
519
520 void CalendarRegressionTest::dowTest(UBool lenient)
521 {
522 UErrorCode status = U_ZERO_ERROR;
523 GregorianCalendar *cal = new GregorianCalendar(status);
524 if(U_FAILURE(status)) {
525 errln("Error creating Calendar: %s", u_errorName(status));
526 delete cal;
527 return;
528 }
529 cal->set(1997, UCAL_AUGUST, 12); // Wednesday
530 // cal.getTime(); // Force update
531 cal->setLenient(lenient);
532 cal->set(1996, UCAL_DECEMBER, 1); // Set the date to be December 1, 1996
533 int32_t dow = cal->get(UCAL_DAY_OF_WEEK, status);
534 int32_t min = cal->getMinimum(UCAL_DAY_OF_WEEK);
535 int32_t max = cal->getMaximum(UCAL_DAY_OF_WEEK);
536 //logln(cal.getTime().toString());
537 if (min != UCAL_SUNDAY || max != UCAL_SATURDAY)
538 errln("FAIL: Min/max bad");
539 if (dow < min || dow > max)
540 errln("FAIL: Day of week %d out of range [%d,%d]\n", dow, min, max);
541 if (dow != UCAL_SUNDAY)
542 errln("FAIL: Day of week should be SUNDAY Got " + dow);
543
544 if(U_FAILURE(status)) {
545 errln("Error checking Calendar: %s", u_errorName(status));
546 delete cal;
547 return;
548 }
549
550 if(cal->getActualMinimum(UCAL_DAY_OF_WEEK, status) != min) {
551 errln("FAIL: actual minimum differs from minimum");
552 }
553 if(cal->getActualMinimum(Calendar::DAY_OF_WEEK, status) != min) {
554 errln("FAIL: actual minimum (Calendar::DAY_OF_WEEK, status) differs from minimum");
555 }
556 if(cal->getActualMinimum(Calendar::DAY_OF_WEEK) != min) {
557 errln("FAIL: actual minimum (Calendar::DAY_OF_WEEK) differs from minimum");
558 }
559 if(((Calendar*)cal)->getActualMinimum(UCAL_DAY_OF_WEEK, status) != min) {
560 errln("FAIL: actual minimum (UCAL_DAY_OF_WEEK, status) differs from minimum");
561 }
562 // NOTE: This function does not exist! jitterbug #3016
563 // if(((Calendar*)cal)->getActualMinimum(Calendar::DAY_OF_WEEK, status) != min) {
564 // errln("FAIL: actual minimum (Calendar::DAY_OF_WEEK, status) differs from minimum");
565 // }
566 if(U_FAILURE(status)) {
567 errln("Error getting actual minimum: %s", u_errorName(status));
568 return;
569 }
570
571 delete cal;
572 }
573
574 /**
575 * @bug 4071385
576 */
577 void CalendarRegressionTest::test4071385()
578 {
579 UErrorCode status = U_ZERO_ERROR;
580 Calendar *cal = Calendar::createInstance(status);
581 if(U_FAILURE(status)) {
582 errln("Error creating Calendar: %s", u_errorName(status));
583 delete cal;
584 return;
585 }
586 cal->setTime(makeDate(1998, UCAL_JUNE, 24),status);
587 cal->set(UCAL_MONTH, UCAL_NOVEMBER); // change a field
588 //logln(cal.getTime().toString());
589 if (cal->getTime(status) != makeDate(1998, UCAL_NOVEMBER, 24))
590 errln("Fail");
591
592 delete cal;
593 }
594
595 /**
596 * @bug 4073929
597 */
598 void CalendarRegressionTest::test4073929()
599 {
600 UErrorCode status = U_ZERO_ERROR;
601 GregorianCalendar *foo1 = new GregorianCalendar(1997, 8, 27,status);
602 if(U_FAILURE(status)) {
603 errln("Error creating Calendar: %s", u_errorName(status));
604 delete foo1;
605 return;
606 }
607 logln("foo1@%.0f - %d-%d-%d %d:%d:%d.%ds\n", foo1->getTime(status),
608 foo1->get(UCAL_YEAR, status),
609 foo1->get(UCAL_MONTH, status),
610 foo1->get(UCAL_DATE, status),
611 foo1->get(UCAL_HOUR, status),
612 foo1->get(UCAL_MINUTE, status),
613 foo1->get(UCAL_SECOND, status),
614 foo1->get(UCAL_MILLISECOND,status));
615 foo1->add(UCAL_DATE, + 1, status);
616 logln("foo1@%.0f - %d-%d-%d %d:%d:%d.%ds after +\n", foo1->getTime(status),
617 foo1->get(UCAL_YEAR, status),
618 foo1->get(UCAL_MONTH, status),
619 foo1->get(UCAL_DATE, status),
620 foo1->get(UCAL_HOUR, status),
621 foo1->get(UCAL_MINUTE, status),
622 foo1->get(UCAL_SECOND, status),
623 foo1->get(UCAL_MILLISECOND ,status));
624 foo1->add(UCAL_DATE, - 1, status);
625 logln("foo1@%.0f - %d-%d-%d %d:%d:%d.%ds after -\n", foo1->getTime(status),
626 foo1->get(UCAL_YEAR, status),
627 foo1->get(UCAL_MONTH, status),
628 foo1->get(UCAL_DATE, status),
629 foo1->get(UCAL_HOUR, status),
630 foo1->get(UCAL_MINUTE, status),
631 foo1->get(UCAL_SECOND, status),
632 foo1->get(UCAL_MILLISECOND, status));
633
634 foo1->add(UCAL_DATE, + 1, status);
635 int32_t testyear = foo1->get(UCAL_YEAR, status);
636 int32_t testmonth = foo1->get(UCAL_MONTH, status);
637 int32_t testday = foo1->get(UCAL_DATE, status);
638 if (testyear != 1997 ||
639 testmonth != 8 ||
640 testday != 28)
641 errln("Fail: Calendar not initialized");
642
643 delete foo1;
644 }
645
646 /**
647 * @bug 4083167
648 */
649 void CalendarRegressionTest::test4083167()
650 {
651 UErrorCode status = U_ZERO_ERROR;
652 TimeZone *saveZone = TimeZone::createDefault();
653 //try {
654 TimeZone *newZone = TimeZone::createTimeZone("UTC");
655 TimeZone::setDefault(*newZone);
656 UDate firstDate = Calendar::getNow();
657 Calendar *cal = new GregorianCalendar(status);
658 if(U_FAILURE(status)) {
659 errln("Error creating Calendar: %s", u_errorName(status));
660 delete cal;
661 return;
662 }
663 cal->setTime(firstDate,status);
664 int32_t hr = cal->get(UCAL_HOUR_OF_DAY, status);
665 int32_t min = cal->get(UCAL_MINUTE, status);
666 int32_t sec = cal->get(UCAL_SECOND, status);
667 int32_t msec = cal->get(UCAL_MILLISECOND, status);
668 double firstMillisInDay = hr * 3600000 + min * 60000 + sec * 1000 + msec;
669
670 //logln("Current time: " + firstDate.toString());
671
672 for (int32_t validity=0; validity<30; validity++) {
673 UDate lastDate = firstDate + validity*1000*24*60*60.0;
674 cal->setTime(lastDate, status);
675 hr = cal->get(UCAL_HOUR_OF_DAY, status);
676 min = cal->get(UCAL_MINUTE, status);
677 sec = cal->get(UCAL_SECOND, status);
678 msec = cal->get(UCAL_MILLISECOND, status);
679 double millisInDay = hr * 3600000.0 + min * 60000.0 + sec * 1000.0 + msec;
680 if (firstMillisInDay != millisInDay)
681 errln(UnicodeString("Day has shifted ") + lastDate);
682 }
683 //}
684 //finally {
685 TimeZone::setDefault(*saveZone);
686 //}
687
688 delete saveZone;
689 delete newZone;
690 delete cal;
691 }
692
693 /**
694 * @bug 4086724
695 */
696 void CalendarRegressionTest::test4086724()
697 {
698 UErrorCode status = U_ZERO_ERROR;
699 SimpleDateFormat *date;
700 TimeZone *saveZone = TimeZone::createDefault();
701 Locale saveLocale = Locale::getDefault();
702 //try {
703 Locale::setDefault(Locale::getUK(),status);
704 TimeZone *newZone = TimeZone::createTimeZone("GMT");
705 TimeZone::setDefault(*newZone);
706 date = new SimpleDateFormat(UnicodeString("dd MMM yyy (zzzz) 'is in week' ww"),status);
707 Calendar *cal = Calendar::createInstance(status);
708 if(U_FAILURE(status)) {
709 errln("Error creating Calendar: %s", u_errorName(status));
710 delete cal;
711 delete newZone;
712 delete date;
713 return;
714 }
715 cal->set(1997,UCAL_SEPTEMBER,30);
716 UDate now = cal->getTime(status);
717 UnicodeString temp;
718 FieldPosition pos(FieldPosition::DONT_CARE);
719 logln(date->format(now, temp, pos));
720 cal->set(1997,UCAL_JANUARY,1);
721 now=cal->getTime(status);
722 logln(date->format(now,temp, pos));
723 cal->set(1997,UCAL_JANUARY,8);
724 now=cal->getTime(status);
725 logln(date->format(now,temp, pos));
726 cal->set(1996,UCAL_DECEMBER,31);
727 now=cal->getTime(status);
728 logln(date->format(now,temp, pos));
729 //}
730 //finally {
731 Locale::setDefault(saveLocale,status);
732 TimeZone::setDefault(*saveZone);
733 //}
734 logln("*** THE RESULTS OF THIS TEST MUST BE VERIFIED MANUALLY ***");
735
736 delete newZone;
737 delete cal;
738 delete date;
739 delete saveZone;
740 }
741
742 /**
743 * @bug 4092362
744 */
745 void CalendarRegressionTest::test4092362() {
746 UErrorCode status = U_ZERO_ERROR;
747 GregorianCalendar *cal1 = new GregorianCalendar(1997, 10, 11, 10, 20, 40,status);
748 /*cal1.set( Calendar::YEAR, 1997 );
749 cal1.set( Calendar::MONTH, 10 );
750 cal1.set( Calendar::DATE, 11 );
751 cal1.set( Calendar::HOUR, 10 );
752 cal1.set( Calendar::MINUTE, 20 );
753 cal1.set( Calendar::SECOND, 40 ); */
754
755 logln( UnicodeString(" Cal1 = ") + cal1->getTime(status) );
756 logln( UnicodeString(" Cal1 time in ms = ") + cal1->get(UCAL_MILLISECOND,status) );
757 for( int32_t k = 0; k < 100 ; k++ );
758
759 GregorianCalendar *cal2 = new GregorianCalendar(1997, 10, 11, 10, 20, 40,status);
760 /*cal2.set( Calendar::YEAR, 1997 );
761 cal2.set( Calendar::MONTH, 10 );
762 cal2.set( Calendar::DATE, 11 );
763 cal2.set( Calendar::HOUR, 10 );
764 cal2.set( Calendar::MINUTE, 20 );
765 cal2.set( Calendar::SECOND, 40 ); */
766
767 logln( UnicodeString(" Cal2 = ") + cal2->getTime(status) );
768 logln( UnicodeString(" Cal2 time in ms = ") + cal2->get(UCAL_MILLISECOND,status) );
769 if( *cal1 != *cal2 )
770 errln("Fail: Milliseconds randomized");
771
772 delete cal1;
773 delete cal2;
774 }
775
776 /**
777 * @bug 4095407
778 */
779 void CalendarRegressionTest::test4095407()
780 {
781 UErrorCode status = U_ZERO_ERROR;
782 GregorianCalendar *a = new GregorianCalendar(1997,UCAL_NOVEMBER, 13,status);
783 int32_t dow = a->get(UCAL_DAY_OF_WEEK, status);
784 if (dow != UCAL_THURSDAY)
785 errln("Fail: Want THURSDAY Got " + dow);
786
787 delete a;
788 }
789
790 /**
791 * @bug 4096231
792 */
793 void CalendarRegressionTest::test4096231()
794 {
795 UErrorCode status = U_ZERO_ERROR;
796 TimeZone *GMT = TimeZone::createTimeZone("GMT");
797 TimeZone *PST = TimeZone::createTimeZone("PST");
798 int32_t sec = 0, min = 0, hr = 0, day = 1, month = 10, year = 1997;
799
800 Calendar *cal1 = new GregorianCalendar(*PST,status);
801 cal1->setTime(880698639000.0,status);
802 // Issue 1: Changing the timezone doesn't change the
803 // represented time. The old API, pre 1.2.2a requires
804 // setTime to be called in order to update the time fields after the time
805 // zone has been set.
806 int32_t h1,h2;
807 logln(UnicodeString("PST 1 is: ") + (h1=cal1->get(UCAL_HOUR_OF_DAY, status)));
808 cal1->setTimeZone(*GMT);
809 logln(UnicodeString("GMT 2 is: ") + (h2=cal1->get(UCAL_HOUR_OF_DAY, status)));
810 if ((*GMT != *PST) && (h1 == h2))
811 errln("Fail: Hour same in different zones");
812
813 Calendar *cal2 = new GregorianCalendar(*GMT,status);
814 Calendar *cal3 = new GregorianCalendar(*PST,status);
815 cal2->set(UCAL_MILLISECOND, 0);
816 cal3->set(UCAL_MILLISECOND, 0);
817
818 cal2->set(cal1->get(UCAL_YEAR,status),
819 cal1->get(UCAL_MONTH,status),
820 cal1->get(UCAL_DATE,status),
821 cal1->get(UCAL_HOUR_OF_DAY,status),
822 cal1->get(UCAL_MINUTE,status),
823 cal1->get(UCAL_SECOND,status));
824
825 double t1,t2,t3,t4;
826 logln(UnicodeString("RGMT 1 is: ") + (t1=cal2->getTime(status)));
827 cal3->set(year, month, day, hr, min, sec);
828 logln(UnicodeString("RPST 1 is: ") + (t2=cal3->getTime(status)));
829 cal3->setTimeZone(*GMT);
830 logln(UnicodeString("RGMT 2 is: ") + (t3=cal3->getTime(status)));
831 cal3->set(cal1->get(UCAL_YEAR,status),
832 cal1->get(UCAL_MONTH,status),
833 cal1->get(UCAL_DATE,status),
834 cal1->get(UCAL_HOUR_OF_DAY,status),
835 cal1->get(UCAL_MINUTE,status),
836 cal1->get(UCAL_SECOND,status));
837 // Issue 2: Calendar continues to use the timezone in its
838 // constructor for set() conversions, regardless
839 // of calls to setTimeZone()
840 logln(UnicodeString("RGMT 3 is: ") + (t4=cal3->getTime(status)));
841 if (t1 == t2 ||
842 t1 != t4 ||
843 t2 != t3)
844 errln("Fail: Calendar zone behavior faulty");
845
846 delete cal1;
847 delete cal2;
848 delete cal3;
849 delete GMT;
850 delete PST;
851 }
852
853 /**
854 * @bug 4096539
855 */
856 void CalendarRegressionTest::test4096539()
857 {
858 UErrorCode status = U_ZERO_ERROR;
859 int32_t y [] = {31,28,31,30,31,30,31,31,30,31,30,31};
860
861 for (int32_t x=0;x<12;x++) {
862 GregorianCalendar *gc = new
863 GregorianCalendar(1997,x,y[x], status);
864 int32_t m1,m2;
865 log(UnicodeString("") + (m1=gc->get(UCAL_MONTH,status)+1)+UnicodeString("/")+
866 gc->get(UCAL_DATE,status)+"/"+gc->get(UCAL_YEAR,status)+
867 " + 1mo = ");
868
869 gc->add(UCAL_MONTH, 1,status);
870 logln(UnicodeString("") + (m2=gc->get(UCAL_MONTH,status)+1)+UnicodeString("/")+
871 gc->get(UCAL_DATE,status)+"/"+gc->get(UCAL_YEAR,status)
872 );
873 int32_t m = (m1 % 12) + 1;
874 if (m2 != m)
875 errln(UnicodeString("Fail: Want ") + m + " Got " + m2);
876 delete gc;
877 }
878
879 }
880
881 /**
882 * @bug 4100311
883 */
884 void CalendarRegressionTest::test41003112()
885 {
886 UErrorCode status = U_ZERO_ERROR;
887 GregorianCalendar *cal = (GregorianCalendar*)Calendar::createInstance(status);
888 if(U_FAILURE(status)) {
889 errln("Error creating calendar: %s", u_errorName(status));
890 delete cal;
891 return;
892 }
893 cal->set(UCAL_YEAR, 1997);
894 cal->set(UCAL_DAY_OF_YEAR, 1);
895 //UDate d = cal->getTime(status); // Should be Jan 1
896 //logln(d.toString());
897 if (cal->get(UCAL_DAY_OF_YEAR, status) != 1)
898 errln("Fail: DAY_OF_YEAR not set");
899 delete cal;
900 }
901
902 /**
903 * @bug 4103271
904 */
905 void CalendarRegressionTest::test4103271()
906 {
907 UErrorCode status = U_ZERO_ERROR;
908 SimpleDateFormat sdf(status);
909 int32_t numYears=40, startYear=1997, numDays=15;
910 UnicodeString output, testDesc, str, str2;
911 GregorianCalendar *testCal = (GregorianCalendar*)Calendar::createInstance(status);
912 if(U_FAILURE(status)) {
913 errln("Error creating calendar: %s", u_errorName(status));
914 delete testCal;
915 return;
916 }
917 testCal->clear();
918 sdf.adoptCalendar(testCal);
919 sdf.applyPattern("EEE dd MMM yyyy 'WOY'ww'-'YYYY 'DOY'DDD");
920 UBool fail = FALSE;
921 for (int32_t firstDay=1; firstDay<=2; firstDay++) {
922 for (int32_t minDays=1; minDays<=7; minDays++) {
923 testCal->setMinimalDaysInFirstWeek((uint8_t)minDays);
924 testCal->setFirstDayOfWeek((UCalendarDaysOfWeek)firstDay);
925 testDesc = (UnicodeString("Test") + firstDay + minDays);
926 logln(testDesc + " => 1st day of week=" +
927 firstDay +
928 ", minimum days in first week=" +
929 minDays);
930 for (int32_t j=startYear; j<=startYear+numYears; j++) {
931 testCal->set(j,11,25);
932 for(int32_t i=0; i<numDays; i++) {
933 testCal->add(UCAL_DATE,1,status);
934 UnicodeString calWOY;
935 int32_t actWOY = testCal->get(UCAL_WEEK_OF_YEAR,status);
936 if (actWOY < 1 || actWOY > 53) {
937 UDate d = testCal->getTime(status);
938 //calWOY = String.valueOf(actWOY);
939 UnicodeString temp;
940 FieldPosition pos(FieldPosition::DONT_CARE);
941 output = testDesc + " - " + sdf.format(d,temp,pos) + "\t";
942 output = output + "\t" + actWOY;
943 logln(output);
944 fail = TRUE;
945 }
946 }
947 }
948 }
949 }
950
951 int32_t DATA [] = {
952 3, 52, 52, 52, 52, 52, 52, 52,
953 1, 1, 1, 1, 1, 1, 1,
954 2, 2, 2, 2, 2, 2, 2,
955 4, 52, 52, 52, 52, 52, 52, 52,
956 53, 53, 53, 53, 53, 53, 53,
957 1, 1, 1, 1, 1, 1, 1,
958 };
959 testCal->setFirstDayOfWeek(UCAL_SUNDAY);
960 for (int32_t j=0; j<44; j+=22) {
961 logln(UnicodeString("Minimal days in first week = ") + DATA[j] +
962 " Week starts on Sunday");
963 testCal->setMinimalDaysInFirstWeek((uint8_t)DATA[j]);
964 testCal->set(1997, UCAL_DECEMBER, 21);
965 for (int32_t i=0; i<21; ++i) {
966 int32_t woy = testCal->get(UCAL_WEEK_OF_YEAR,status);
967 str.remove();
968 log(UnicodeString("") + sdf.format(testCal->getTime(status), str) +
969 UnicodeString(" ") + woy);
970 if (woy != DATA[j + 1 + i]) {
971 log(" ERROR");
972 fail = TRUE;
973 }
974 logln("");
975
976 // Now compute the time from the fields, and make sure we
977 // get the same answer back. This is a round-trip test.
978 UDate save = testCal->getTime(status);
979 testCal->clear();
980 testCal->set(UCAL_YEAR_WOY, DATA[j+1+i] < 25 ? 1998 : 1997);
981 testCal->set(UCAL_WEEK_OF_YEAR, DATA[j+1+i]);
982 testCal->set(UCAL_DAY_OF_WEEK, (i%7) + UCAL_SUNDAY);
983 if (testCal->getTime(status) != save) {
984 str.remove();
985 logln(UnicodeString(" Parse failed: ") +
986 sdf.format(testCal->getTime(status), str));
987 fail= TRUE;
988 }
989
990 testCal->setTime(save,status);
991 testCal->add(UCAL_DATE, 1,status);
992 }
993 }
994 // Test field disambiguation with a few special hard-coded cases.
995 // This shouldn't fail if the above cases aren't failing.
996 int32_t DISAM_int [] = {
997 // y y_woy woy dow
998 1997, 1998, 1, UCAL_SUNDAY,
999 (1998), (1998), (2), (UCAL_SATURDAY),
1000 (1998), (1998), (53), (UCAL_THURSDAY),
1001 (1999), (1998), (53), (UCAL_FRIDAY)
1002 };
1003
1004 UDate DISAM_date [] = {
1005 makeDate(1997, UCAL_DECEMBER, 28),
1006 makeDate(1998, UCAL_JANUARY, 10),
1007 makeDate(1998, UCAL_DECEMBER, 31),
1008 makeDate(1999, UCAL_JANUARY, 1)
1009 };
1010
1011 testCal->setMinimalDaysInFirstWeek(3);
1012 testCal->setFirstDayOfWeek(UCAL_SUNDAY);
1013 int32_t i = 0;
1014
1015 /* Enable this code to display various WOY values
1016 testCal->clear();
1017 for (i=25; i<38; ++i) {
1018 testCal->set(1996, Calendar::DECEMBER, i);
1019 UDate got = testCal->getTime(status);
1020 str.remove();
1021 logln(UnicodeString("") + sdf.format(got, str));
1022 }
1023 for (i=25; i<38; ++i) {
1024 testCal->set(1997, Calendar::DECEMBER, i);
1025 UDate got = testCal->getTime(status);
1026 str.remove();
1027 logln(UnicodeString("") + sdf.format(got, str));
1028 }
1029 for (i=25; i<38; ++i) {
1030 testCal->set(1998, UCAL_DECEMBER, i);
1031 UDate got = testCal->getTime(status);
1032 str.remove();
1033 logln(UnicodeString("") + sdf.format(got, str));
1034 }
1035 */
1036
1037 for (i=0; i < 16; i += 4) {
1038 int32_t y = DISAM_int[i];
1039 int32_t ywoy = DISAM_int[i+1];
1040 int32_t woy = DISAM_int[i+2];
1041 int32_t dow = DISAM_int[i+3];
1042 UDate exp = DISAM_date[i/4];
1043 testCal->clear();
1044 testCal->set(UCAL_YEAR, y);
1045 testCal->set(UCAL_WEEK_OF_YEAR, woy);
1046 testCal->set(UCAL_DAY_OF_WEEK, dow);
1047 UDate got = testCal->getTime(status);
1048 str.remove();
1049 str2.remove();
1050 log(UnicodeString("Y") + y + "-W" + woy +
1051 "-DOW" + dow + " expect:" + sdf.format(exp, str) +
1052 " got:" + sdf.format(got, str2));
1053 if (got != exp) {
1054 log(" FAIL (%s:%d, i=%d)", __FILE__, __LINE__, i);
1055 logln(CalendarTest::calToStr(*testCal));
1056 testCal->setTime(exp, status);
1057 logln(CalendarTest::calToStr(*testCal) + UnicodeString( " <<< expected "));
1058 fail = TRUE;
1059 }
1060 logln("");
1061
1062 testCal->clear();
1063 testCal->set(UCAL_YEAR_WOY, ywoy);
1064 testCal->set(UCAL_WEEK_OF_YEAR, woy);
1065 testCal->set(UCAL_DAY_OF_WEEK, dow);
1066 got = testCal->getTime(status);
1067 str.remove();
1068 str2.remove();
1069 log(UnicodeString("YWOY") + ywoy + "-W" + woy +
1070 "-DOW" + dow + " expect:" + sdf.format(exp, str) +
1071 " got:" + sdf.format(got, str2));
1072 if (got != exp) {
1073 log(" FAIL");
1074 fail = TRUE;
1075 }
1076 logln("");
1077 }
1078 // Now try adding and rolling
1079 UDate ADDROLL_date [] = {
1080 makeDate(1998, UCAL_DECEMBER, 25), makeDate(1999, UCAL_JANUARY, 1),
1081 makeDate(1997, UCAL_DECEMBER, 28), makeDate(1998, UCAL_JANUARY, 4),
1082 makeDate(1998, UCAL_DECEMBER, 27), makeDate(1997, UCAL_DECEMBER, 28),
1083 makeDate(1999, UCAL_JANUARY, 2), makeDate(1998, UCAL_JANUARY, 3),
1084 };
1085
1086 int32_t ADDROLL_int []= {
1087 (1),
1088 (1),
1089 (1),
1090 (1)
1091 };
1092
1093
1094 UBool ADDROLL_bool [] = {
1095 TRUE,//ADD,
1096 TRUE,
1097 FALSE,
1098 FALSE
1099 };
1100
1101 testCal->setMinimalDaysInFirstWeek(3);
1102 testCal->setFirstDayOfWeek(UCAL_SUNDAY);
1103 for (i=0; i<8; i += 2) {
1104 int32_t amount = ADDROLL_int[i/2];
1105 UDate before = ADDROLL_date[i];
1106 UDate after = ADDROLL_date[i+1];
1107
1108 testCal->setTime(before,status);
1109 if (ADDROLL_bool[i/2])
1110 testCal->add(UCAL_WEEK_OF_YEAR, amount,status);
1111 else
1112 testCal->roll(UCAL_WEEK_OF_YEAR, amount,status);
1113 UDate got = testCal->getTime(status);
1114 str.remove();
1115 str2.remove();
1116 UnicodeString opTypeStr;
1117 if (ADDROLL_bool[i/2]) {
1118 opTypeStr = UnicodeString("add(WOY,", "");
1119 } else {
1120 opTypeStr = UnicodeString("roll(WOY,", "");
1121 }
1122 log(opTypeStr + amount + ") " + sdf.format(before, str) + " => " +
1123 sdf.format(got, str2));
1124 if (after != got) {
1125 str.remove();
1126 logln(UnicodeString(" exp:") + sdf.format(after, str) + " FAIL");
1127 fail = TRUE;
1128 }
1129 else logln(" ok");
1130
1131 testCal->setTime(after,status);
1132 if (ADDROLL_bool[i/2])
1133 testCal->add(UCAL_WEEK_OF_YEAR, -amount,status);
1134 else
1135 testCal->roll(UCAL_WEEK_OF_YEAR, -amount,status);
1136 got = testCal->getTime(status);
1137 str.remove();
1138 str2.remove();
1139 log(opTypeStr + (-amount) + ") " + sdf.format(after, str) + " => " +
1140 sdf.format(got, str2));
1141 if (before != got) {
1142 str.remove();
1143 logln(UnicodeString(" exp:") + sdf.format(before, str) + " FAIL");
1144 fail = TRUE;
1145 }
1146 else logln(" ok");
1147 }
1148 if (fail)
1149 errln("Fail: Week of year misbehaving");
1150 }
1151
1152 /**
1153 * @bug 4106136
1154 */
1155 void CalendarRegressionTest::test4106136()
1156 {
1157 UErrorCode status = U_ZERO_ERROR;
1158 Locale saveLocale = Locale::getDefault();
1159 //try {
1160 Locale locales [] = { Locale::getChinese(), Locale::getChina() };
1161 for (int32_t i=0; i<2; ++i) {
1162 Locale::setDefault(locales[i], status);
1163 failure(status, "Locale::setDefault");
1164 int32_t count1, count2, count3;
1165 Calendar::getAvailableLocales(count1);
1166 DateFormat::getAvailableLocales(count2);
1167 NumberFormat::getAvailableLocales(count3);
1168 int32_t n [] = {
1169 count1, count2, count3
1170 };
1171 for (int32_t j=0; j<3; ++j) {
1172 UnicodeString temp;
1173 if (n[j] == 0)
1174 errln(UnicodeString("Fail: No locales for ") + locales[i].getName());
1175 }
1176 }
1177 //}
1178 //finally {
1179 Locale::setDefault(saveLocale,status);
1180 //}
1181 }
1182
1183 /**
1184 * @bug 4108764
1185 */
1186 void CalendarRegressionTest::test4108764()
1187 {
1188 UErrorCode status = U_ZERO_ERROR;
1189 Calendar *cal = Calendar::createInstance(status);
1190 if(U_FAILURE(status)) {
1191 errln("Error creating calendar %s", u_errorName(status));
1192 delete cal;
1193 return;
1194 }
1195 UDate d00 = makeDate(1997, UCAL_MARCH, 15, 12, 00, 00);
1196 UDate d01 = makeDate(1997, UCAL_MARCH, 15, 12, 00, 56);
1197 UDate d10 = makeDate(1997, UCAL_MARCH, 15, 12, 34, 00);
1198 UDate d11 = makeDate(1997, UCAL_MARCH, 15, 12, 34, 56);
1199 UDate epoch = makeDate(1970, UCAL_JANUARY, 1);
1200
1201 cal->setTime(d11,status);
1202
1203 cal->clear( UCAL_MINUTE );
1204 logln(UnicodeString("") + cal->getTime(status));
1205 if (cal->getTime(status) != d01)
1206 errln("Fail: clear(MINUTE) broken");
1207
1208 cal->set( UCAL_SECOND, 0 );
1209 logln(UnicodeString("") + cal->getTime(status));
1210 if (cal->getTime(status) != d00)
1211 errln("Fail: set(SECOND, 0) broken");
1212
1213 cal->setTime(d11,status);
1214 cal->set( UCAL_SECOND, 0 );
1215 logln(UnicodeString("") + cal->getTime(status));
1216 if (cal->getTime(status) != d10)
1217 errln("Fail: set(SECOND, 0) broken #2");
1218
1219 cal->clear( UCAL_MINUTE );
1220 logln(UnicodeString("") + cal->getTime(status));
1221 if (cal->getTime(status) != d00)
1222 errln("Fail: clear(MINUTE) broken #2");
1223
1224 cal->clear();
1225 logln(UnicodeString("") + cal->getTime(status));
1226 if (cal->getTime(status) != epoch)
1227 errln(UnicodeString("Fail: clear() broken Want ") + epoch);
1228
1229 delete cal;
1230 }
1231
1232 /**
1233 * @bug 4114578
1234 */
1235 void CalendarRegressionTest::test4114578()
1236 {
1237 UErrorCode status = U_ZERO_ERROR;
1238 int32_t ONE_HOUR = 60*60*1000;
1239 Calendar *cal = Calendar::createInstance(status);
1240 if(U_FAILURE(status)) {
1241 errln("Error creating calendar %s", u_errorName(status));
1242 delete cal;
1243 return;
1244 }
1245 cal->adoptTimeZone(TimeZone::createTimeZone("PST"));
1246 UDate onset = makeDate(1998, UCAL_APRIL, 5, 1, 0) + ONE_HOUR;
1247 UDate cease = makeDate(1998, UCAL_OCTOBER, 25, 0, 0) + 2*ONE_HOUR;
1248
1249 UBool fail = FALSE;
1250
1251 const int32_t ADD = 1;
1252 const int32_t ROLL = 2;
1253
1254 double DATA []= {
1255 // Start Action Amt Expected_change
1256 onset - ONE_HOUR, ADD, 1, ONE_HOUR,
1257 onset, ADD, -1, -ONE_HOUR,
1258 onset - ONE_HOUR, ROLL, 1, ONE_HOUR,
1259 onset, ROLL, -1, -ONE_HOUR,
1260 cease - ONE_HOUR, ADD, 1, ONE_HOUR,
1261 cease, ADD, -1, -ONE_HOUR,
1262 cease - ONE_HOUR, ROLL, 1, ONE_HOUR,
1263 cease, ROLL, -1, -ONE_HOUR,
1264 };
1265
1266 for (int32_t i=0; i<32; i+=4) {
1267 UDate date = DATA[i];
1268 int32_t amt = (int32_t) DATA[i+2];
1269 double expectedChange = DATA[i+3];
1270
1271 log(UnicodeString("") + date);
1272 cal->setTime(date,status);
1273
1274 switch ((int32_t) DATA[i+1]) {
1275 case ADD:
1276 log(UnicodeString(" add (HOUR,") + (amt<0?"":"+")+amt + ")= ");
1277 cal->add(UCAL_HOUR, amt,status);
1278 break;
1279 case ROLL:
1280 log(UnicodeString(" roll(HOUR,") + (amt<0?"":"+")+amt + ")= ");
1281 cal->roll(UCAL_HOUR, amt,status);
1282 break;
1283 }
1284
1285 log(UnicodeString("") + cal->getTime(status));
1286
1287 double change = cal->getTime(status) - date;
1288 if (change != expectedChange) {
1289 fail = TRUE;
1290 logln(" FAIL");
1291 }
1292 else logln(" OK");
1293 }
1294
1295 if (fail) errln("Fail: roll/add misbehaves around DST onset/cease");
1296
1297 delete cal;
1298 }
1299
1300 /**
1301 * @bug 4118384
1302 * Make sure maximum for HOUR field is 11, not 12.
1303 */
1304 void CalendarRegressionTest::test4118384()
1305 {
1306 UErrorCode status = U_ZERO_ERROR;
1307 Calendar *cal = Calendar::createInstance(status);
1308 if(U_FAILURE(status)) {
1309 errln("Error creating calendar %s", u_errorName(status));
1310 delete cal;
1311 return;
1312 }
1313 if (cal->getMaximum(UCAL_HOUR) != 11 ||
1314 cal->getLeastMaximum(UCAL_HOUR) != 11 ||
1315 cal->getActualMaximum(UCAL_HOUR,status) != 11)
1316 errln("Fail: maximum of HOUR field should be 11");
1317
1318 // test deprecated functions
1319 if (cal->getLeastMaximum(Calendar::HOUR) != 11 ||
1320 cal->getMaximum(Calendar::HOUR) != 11) {
1321 errln("Fail: [deprecated functions] maximum of HOUR field should be 11\n");
1322 }
1323
1324 if (cal->getGreatestMinimum(Calendar::HOUR) != 0 ||
1325 cal->getMinimum(Calendar::HOUR) != 0) {
1326 errln("Fail: [deprecated functions] minimum of HOUR field should be 1\n");
1327 }
1328
1329 delete cal;
1330 cal = Calendar::createInstance(Locale("th_TH@calendar=buddhist"),status);
1331 // test deprecated functions
1332 if (cal->getLeastMaximum(Calendar::HOUR) != 11 ||
1333 cal->getMaximum(Calendar::HOUR) != 11) {
1334 errln("Fail: Buddhist:[deprecated functions] maximum of HOUR field should be 11\n");
1335 }
1336
1337 if (cal->getGreatestMinimum(Calendar::HOUR) != 0 ||
1338 cal->getMinimum(Calendar::HOUR) != 0) {
1339 errln("Fail: Buddhist:[deprecated functions] minimum of HOUR field should be 1\n");
1340 }
1341
1342 delete cal;
1343 // test deprecated functions
1344 cal = Calendar::createInstance(Locale("ja_JP@calendar=japanese"),status);
1345 if (cal->getLeastMaximum(Calendar::HOUR) != 11 ||
1346 cal->getMaximum(Calendar::HOUR) != 11) {
1347 errln("Fail: Japanese:[deprecated functions] maximum of HOUR field should be 11\n");
1348 }
1349
1350 if (cal->getGreatestMinimum(Calendar::HOUR) != 0 ||
1351 cal->getMinimum(Calendar::HOUR) != 0) {
1352 errln("Fail: Japanese:[deprecated functions] minimum of HOUR field should be 1\n");
1353 }
1354
1355 delete cal;
1356 }
1357
1358 /**
1359 * @bug 4125881
1360 * Check isLeapYear for BC years.
1361 */
1362 void CalendarRegressionTest::test4125881()
1363 {
1364 UErrorCode status = U_ZERO_ERROR;
1365 GregorianCalendar *cal = (GregorianCalendar*) Calendar::createInstance(status);
1366 if(U_FAILURE(status)) {
1367 errln("Error creating calendar %s", u_errorName(status));
1368 delete cal;
1369 return;
1370 }
1371 DateFormat *fmt = new SimpleDateFormat(UnicodeString("MMMM d, yyyy G"),status);
1372 if(!assertSuccess("trying to construct", status))return;
1373 cal->clear();
1374 for (int32_t y=-20; y<=10; ++y) {
1375 cal->set(UCAL_ERA, y < 1 ? GregorianCalendar::BC : GregorianCalendar::AD);
1376 cal->set(UCAL_YEAR, y < 1 ? 1 - y : y);
1377 UnicodeString temp;
1378 logln(UnicodeString("") + y + UnicodeString(" = ") + fmt->format(cal->getTime(status), temp) + " " +
1379 cal->isLeapYear(y));
1380 if (cal->isLeapYear(y) != ((y+40)%4 == 0))
1381 errln("Leap years broken");
1382 }
1383
1384 delete cal;
1385 delete fmt;
1386 }
1387
1388 /**
1389 * @bug 4125892
1390 * Prove that GregorianCalendar is proleptic (it used to cut off
1391 * at 45 BC, and not have leap years before then).
1392 */
1393 void CalendarRegressionTest::test4125892() {
1394 UErrorCode status = U_ZERO_ERROR;
1395 GregorianCalendar *cal = (GregorianCalendar*) Calendar::createInstance(status);
1396 if(U_FAILURE(status)) {
1397 errln("Error creating calendar %s", u_errorName(status));
1398 delete cal;
1399 return;
1400 }
1401 DateFormat *fmt = new SimpleDateFormat(UnicodeString("MMMM d, yyyy G"),status);
1402 if(!assertSuccess("trying to construct", status))return;
1403 cal->clear();
1404 cal->set(UCAL_ERA, GregorianCalendar::BC);
1405 cal->set(UCAL_YEAR, 81); // 81 BC is a leap year (proleptically)
1406 cal->set(UCAL_MONTH, UCAL_FEBRUARY);
1407 cal->set(UCAL_DATE, 28);
1408 cal->add(UCAL_DATE, 1,status);
1409 if(U_FAILURE(status))
1410 errln("add(DATE,1) failed");
1411 if (cal->get(UCAL_DATE,status) != 29 ||
1412 !cal->isLeapYear(-80)) // -80 == 81 BC
1413 errln("Calendar not proleptic");
1414
1415 delete cal;
1416 delete fmt;
1417 }
1418
1419 /**
1420 * @bug 4141665
1421 * GregorianCalendar::equals() ignores cutover date
1422 */
1423 void CalendarRegressionTest::test4141665()
1424 {
1425 UErrorCode status = U_ZERO_ERROR;
1426 GregorianCalendar *cal = new GregorianCalendar(status);
1427 if(U_FAILURE(status)) {
1428 errln("Error creating calendar %s", u_errorName(status));
1429 delete cal;
1430 return;
1431 }
1432 GregorianCalendar *cal2 = (GregorianCalendar*)cal->clone();
1433 UDate cut = cal->getGregorianChange();
1434 UDate cut2 = cut + 100*24*60*60*1000.0; // 100 days later
1435 if (*cal != *cal2) {
1436 errln("Cloned GregorianCalendars not equal");
1437 }
1438 cal2->setGregorianChange(cut2,status);
1439 if ( *cal == *cal2) {
1440 errln("GregorianCalendar::equals() ignores cutover");
1441 }
1442
1443 delete cal;
1444 delete cal2;
1445 }
1446
1447 /**
1448 * @bug 4142933
1449 * Bug states that ArrayIndexOutOfBoundsException is thrown by GregorianCalendar::roll()
1450 * when IllegalArgumentException should be.
1451 */
1452 void CalendarRegressionTest::test4142933()
1453 {
1454 UErrorCode status = U_ZERO_ERROR;
1455 GregorianCalendar *calendar = new GregorianCalendar(status);
1456 if(U_FAILURE(status)) {
1457 errln("Error creating calendar %s", u_errorName(status));
1458 delete calendar;
1459 return;
1460 }
1461 //try {
1462 calendar->roll((UCalendarDateFields)-1, TRUE, status);
1463 if(U_SUCCESS(status))
1464 errln("Test failed, no exception thrown");
1465 //}
1466 //catch (IllegalArgumentException e) {
1467 // OK: Do nothing
1468 // logln("Test passed");
1469 //}
1470 //catch (Exception e) {
1471 //errln("Test failed. Unexpected exception is thrown: " + e);
1472 //e.printStackTrace();
1473 //}
1474
1475 delete calendar;
1476 }
1477
1478 /**
1479 * @bug 4145158
1480 * GregorianCalendar handling of Dates Long.MIN_VALUE and Long.MAX_VALUE is
1481 * confusing; unless the time zone has a raw offset of zero, one or the
1482 * other of these will wrap. We've modified the test given in the bug
1483 * report to therefore only check the behavior of a calendar with a zero raw
1484 * offset zone.
1485 */
1486 void CalendarRegressionTest::test4145158()
1487 {
1488 UErrorCode status = U_ZERO_ERROR;
1489 GregorianCalendar *calendar = new GregorianCalendar(status);
1490 if(status == U_USING_FALLBACK_WARNING || U_FAILURE(status)) {
1491 errln("Error creating calendar %s", u_errorName(status));
1492 delete calendar;
1493 return;
1494 }
1495
1496 calendar->adoptTimeZone(TimeZone::createTimeZone("GMT"));
1497
1498 calendar->setTime(makeDate(INT32_MIN),status);
1499 int32_t year1 = calendar->get(UCAL_YEAR,status);
1500 int32_t era1 = calendar->get(UCAL_ERA,status);
1501
1502 calendar->setTime(makeDate(INT32_MAX),status);
1503 int32_t year2 = calendar->get(UCAL_YEAR,status);
1504 int32_t era2 = calendar->get(UCAL_ERA,status);
1505
1506 if (year1 == year2 && era1 == era2) {
1507 errln("Fail: Long.MIN_VALUE or Long.MAX_VALUE wrapping around");
1508 }
1509
1510 delete calendar;
1511 }
1512
1513 /**
1514 * @bug 4145983
1515 * Maximum value for YEAR field wrong.
1516 */
1517 // {sfb} this is not directly applicable in C++, since all
1518 // possible doubles are not representable by our Calendar.
1519 // In Java, all longs are representable.
1520 // We can determine limits programmatically
1521 // Using DBL_MAX is a bit of a hack, since for large doubles
1522 // Calendar gets squirrely and doesn't behave in any sort
1523 // of linear fashion (ie years jump around, up/down, etc) for a
1524 // small change in millis.
1525 void CalendarRegressionTest::test4145983()
1526 {
1527 UErrorCode status = U_ZERO_ERROR;
1528 GregorianCalendar *calendar = new GregorianCalendar(status);
1529 if(U_FAILURE(status)) {
1530 errln("Error creating calendar %s", u_errorName(status));
1531 delete calendar;
1532 return;
1533 }
1534 calendar->adoptTimeZone(TimeZone::createTimeZone("GMT"));
1535 UDate DATES [] = { LATEST_SUPPORTED_MILLIS, EARLIEST_SUPPORTED_MILLIS };
1536 for (int32_t i=0; i<2; ++i) {
1537 calendar->setTime(DATES[i], status);
1538 int32_t year = calendar->get(UCAL_YEAR,status);
1539 int32_t maxYear = calendar->getMaximum(UCAL_YEAR);
1540 if (year > maxYear) {
1541 errln(UnicodeString("Failed for ")+DATES[i]+" ms: year=" +
1542 year + ", maxYear=" + maxYear);
1543 }
1544 }
1545
1546 delete calendar;
1547 }
1548
1549 /**
1550 * @bug 4147269
1551 * This is a bug in the validation code of GregorianCalendar:: As reported,
1552 * the bug seems worse than it really is, due to a bug in the way the bug
1553 * report test was written. In reality the bug is restricted to the DAY_OF_YEAR
1554 * field. - liu 6/29/98
1555 */
1556 void CalendarRegressionTest::test4147269()
1557 {
1558 UErrorCode status = U_ZERO_ERROR;
1559 GregorianCalendar *calendar = new GregorianCalendar(status);
1560 if(status == U_USING_FALLBACK_WARNING || U_FAILURE(status)) {
1561 errln("Error creating calendar %s", u_errorName(status));
1562 delete calendar;
1563 return;
1564 }
1565 calendar->setLenient(FALSE);
1566 UDate date = makeDate(1996, UCAL_JANUARY, 3); // Arbitrary date
1567 for (int32_t field = 0; field < UCAL_FIELD_COUNT; field++) {
1568 calendar->setTime(date,status);
1569 // Note: In the bug report, getActualMaximum() was called instead
1570 // of getMaximum() -- this was an error. The validation code doesn't
1571 // use getActualMaximum(), since that's too costly.
1572 int32_t max = calendar->getMaximum((UCalendarDateFields)field);
1573 int32_t value = max+1;
1574 calendar->set((UCalendarDateFields)field, value);
1575 //try {
1576 calendar->getTime(status); // Force time computation
1577 // We expect an exception to be thrown. If we fall through
1578 // to the next line, then we have a bug.
1579 if(U_SUCCESS(status))
1580 errln(UnicodeString("Test failed with field ") + FIELD_NAME[field] +
1581 ", date before: " + date +
1582 ", date after: " + calendar->getTime(status) +
1583 ", value: " + value + " (max = " + max +")");
1584 //} catch (IllegalArgumentException e) {}
1585 }
1586
1587 delete calendar;
1588 }
1589
1590 /**
1591 * @bug 4149677
1592 * Reported bug is that a GregorianCalendar with a cutover of Date(Long.MAX_VALUE)
1593 * doesn't behave as a pure Julian calendar.
1594 * CANNOT REPRODUCE THIS BUG
1595 */
1596 void
1597 CalendarRegressionTest::Test4149677()
1598 {
1599 UErrorCode status = U_ZERO_ERROR;
1600
1601 TimeZone *zones [] = {
1602 TimeZone::createTimeZone("GMT"),
1603 TimeZone::createTimeZone("PST"),
1604 TimeZone::createTimeZone("EAT")
1605 };
1606 if(U_FAILURE(status)) {
1607 errln("Couldn't create zones");
1608 return;
1609 // could leak memory
1610 }
1611
1612 for (int32_t i=0; i < 3; ++i) {
1613 GregorianCalendar *calendar = new GregorianCalendar(zones[i], status);
1614 if(U_FAILURE(status)) {
1615 errln("Couldnt' create calendar.");
1616 return;
1617 }
1618
1619 // Make sure extreme values don't wrap around
1620 calendar->setTime(EARLIEST_SUPPORTED_MILLIS, status);
1621 if(U_FAILURE(status))
1622 errln("setTime failed");
1623 if (calendar->get(UCAL_ERA, status) != GregorianCalendar::BC || U_FAILURE(status)) {
1624 errln("Fail: Date(EARLIEST_SUPPORTED_MILLIS) has an AD year");
1625 }
1626 calendar->setTime(LATEST_SUPPORTED_MILLIS, status);
1627 if(U_FAILURE(status))
1628 errln("setTime failed");
1629 if (calendar->get(UCAL_ERA, status) != GregorianCalendar::AD || U_FAILURE(status)) {
1630 errln("Fail: Date(LATEST_SUPPORTED_MILLIS) has a BC year");
1631 }
1632
1633 calendar->setGregorianChange(LATEST_SUPPORTED_MILLIS, status);
1634 if(U_FAILURE(status))
1635 errln("setGregorianChange failed");
1636 // to obtain a pure Julian calendar
1637
1638 UBool is100Leap = calendar->isLeapYear(100);
1639 if (!is100Leap) {
1640 UnicodeString temp;
1641 errln("test failed with zone " + zones[i]->getID(temp));
1642 errln(" cutover date is Date(Long.MAX_VALUE)");
1643 errln(" isLeapYear(100) returns: " + is100Leap);
1644 }
1645 delete calendar;
1646 }
1647
1648 // no need for cleanup- zones were adopted
1649 }
1650
1651 /**
1652 * @bug 4162587
1653 * Calendar and Date HOUR broken. If HOUR is out-of-range, Calendar
1654 * and Date classes will misbehave.
1655 */
1656 void
1657 CalendarRegressionTest::Test4162587()
1658 {
1659 UErrorCode status = U_ZERO_ERROR;
1660 TimeZone *savedef = TimeZone::createDefault();
1661 TimeZone *tz = TimeZone::createTimeZone("PST");
1662 //TimeZone::adoptDefault(tz);
1663 TimeZone::setDefault(*tz);
1664
1665 GregorianCalendar *cal = new GregorianCalendar(tz, status);
1666 if(U_FAILURE(status)) {
1667 errln("Couldn't create calendar");
1668 return;
1669 }
1670 UDate d0, dPlus, dMinus;
1671
1672 for(int32_t i=0; i<5; ++i) {
1673 if (i>0) logln("---");
1674
1675 cal->clear();
1676 cal->set(1998, UCAL_APRIL, 5, i, 0);
1677 d0 = cal->getTime(status);
1678 if(U_FAILURE(status))
1679 errln("Coudln't get time (1)");
1680 //String s0 = d.toString();
1681 logln(UnicodeString("0 ") + i + ": " + d0/*s0*/);
1682
1683 cal->clear();
1684 cal->set(1998, UCAL_APRIL, 4, i+24, 0);
1685 dPlus = cal->getTime(status);
1686 if(U_FAILURE(status))
1687 errln("Coudln't get time (2)");
1688 //String sPlus = d.toString();
1689 logln(UnicodeString("+ ") + i + ": " + dPlus/*sPlus*/);
1690
1691 cal->clear();
1692 cal->set(1998, UCAL_APRIL, 6, i-24, 0);
1693 dMinus = cal->getTime(status);
1694 if(U_FAILURE(status))
1695 errln("Coudln't get time (3)");
1696 //String sMinus = d.toString();
1697 logln(UnicodeString("- ") + i + ": " + dMinus/*sMinus*/);
1698
1699 if (d0 != dPlus || d0 != dMinus) {
1700 errln("Fail: All three lines must match");
1701 }
1702 }
1703 TimeZone::setDefault(*savedef);
1704 //delete tz;
1705 delete cal;
1706 delete savedef;
1707 }
1708
1709 /**
1710 * @bug 4165343
1711 * Adding 12 months behaves differently from adding 1 year
1712 */
1713 void
1714 CalendarRegressionTest::Test4165343()
1715 {
1716 UErrorCode status = U_ZERO_ERROR;
1717 GregorianCalendar *calendar = new GregorianCalendar(1996, UCAL_FEBRUARY, 29, status);
1718 if(U_FAILURE(status)) {
1719 errln("Couldn't create calendar");
1720 return;
1721 }
1722 UDate start = calendar->getTime(status);
1723 if(U_FAILURE(status))
1724 errln("Couldn't getTime (1)");
1725 logln(UnicodeString("init date: ") + start);
1726 calendar->add(UCAL_MONTH, 12, status);
1727 if(U_FAILURE(status))
1728 errln("Couldn't add(MONTH, 12)");
1729 UDate date1 = calendar->getTime(status);
1730 if(U_FAILURE(status))
1731 errln("Couldn't getTime (2)");
1732 logln(UnicodeString("after adding 12 months: ") + date1);
1733 calendar->setTime(start, status);
1734 if(U_FAILURE(status))
1735 errln("Couldn't setTime");
1736 calendar->add(UCAL_YEAR, 1, status);
1737 if(U_FAILURE(status))
1738 errln("Couldn't add(YEAR, 1)");
1739 UDate date2 = calendar->getTime(status);
1740 if(U_FAILURE(status))
1741 errln("Couldn't getTime (3)");
1742 logln(UnicodeString("after adding one year : ") + date2);
1743 if (date1 == date2) {
1744 logln("Test passed");
1745 } else {
1746 errln("Test failed");
1747 }
1748 delete calendar;
1749 }
1750
1751 /**
1752 * @bug 4166109
1753 * GregorianCalendar.getActualMaximum() does not account for first day of week.
1754 */
1755 void
1756 CalendarRegressionTest::Test4166109()
1757 {
1758 /* Test month:
1759 *
1760 * March 1998
1761 * Su Mo Tu We Th Fr Sa
1762 * 1 2 3 4 5 6 7
1763 * 8 9 10 11 12 13 14
1764 * 15 16 17 18 19 20 21
1765 * 22 23 24 25 26 27 28
1766 * 29 30 31
1767 */
1768 UBool passed = TRUE;
1769 UErrorCode status = U_ZERO_ERROR;
1770 UCalendarDateFields field = UCAL_WEEK_OF_MONTH;
1771
1772 GregorianCalendar *calendar = new GregorianCalendar(Locale::getUS(), status);
1773 if(U_FAILURE(status)) {
1774 errln("Couldn't create calendar");
1775 return;
1776 }
1777 calendar->set(1998, UCAL_MARCH, 1);
1778 calendar->setMinimalDaysInFirstWeek(1);
1779 logln(UnicodeString("Date: ") + calendar->getTime(status)); // 888817448000
1780
1781 int32_t firstInMonth = calendar->get(UCAL_DATE, status);
1782 if(U_FAILURE(status))
1783 errln("get(D_O_M) failed");
1784
1785 for(int32_t firstInWeek = UCAL_SUNDAY; firstInWeek <= UCAL_SATURDAY; firstInWeek++) {
1786 calendar->setFirstDayOfWeek((UCalendarDaysOfWeek)firstInWeek);
1787 int32_t returned = calendar->getActualMaximum(field, status);
1788 int32_t expected = (31 + ((firstInMonth - firstInWeek + 7)% 7) + 6) / 7;
1789
1790 logln(UnicodeString("First day of week = ") + firstInWeek +
1791 " getActualMaximum(WEEK_OF_MONTH, status) = " + returned +
1792 " expected = " + expected +
1793 ((returned == expected) ? " ok" : " FAIL"));
1794
1795 if (returned != expected) {
1796 passed = FALSE;
1797 }
1798 }
1799 if (!passed) {
1800 errln("Test failed");
1801 }
1802
1803 delete calendar;
1804 }
1805
1806 /**
1807 * @bug 4167060
1808 * Calendar.getActualMaximum(YEAR) works wrong.
1809 */
1810 void
1811 CalendarRegressionTest::Test4167060()
1812 {
1813 UErrorCode status = U_ZERO_ERROR;
1814 UCalendarDateFields field = UCAL_YEAR;
1815 DateFormat *format = new SimpleDateFormat(UnicodeString("EEE MMM dd HH:mm:ss zzz yyyy G"),
1816 Locale::getUS(), status);
1817 if(U_FAILURE(status)) {
1818 errln("Couldn't create SimpleDateFormat");
1819 return;
1820 }
1821
1822 GregorianCalendar *calendars [] = {
1823 new GregorianCalendar(100, UCAL_NOVEMBER, 1, status),
1824 new GregorianCalendar(-99 /*100BC*/, UCAL_JANUARY, 1, status),
1825 new GregorianCalendar(1996, UCAL_FEBRUARY, 29, status),
1826 };
1827 if(U_FAILURE(status)) {
1828 errln("Couldn't create GregorianCalendars");
1829 return;
1830 // could leak
1831 }
1832
1833 UnicodeString id [] = { "Hybrid", "Gregorian", "Julian" };
1834
1835 for (int32_t k=0; k<3; ++k) {
1836 logln("--- " + id[k] + " ---");
1837
1838 for (int32_t j=0; j < 3; ++j) {
1839 GregorianCalendar *calendar = calendars[j];
1840 if (k == 1) {
1841 calendar->setGregorianChange(EARLIEST_SUPPORTED_MILLIS, status);
1842 }
1843 else if (k == 2) {
1844 calendar->setGregorianChange(LATEST_SUPPORTED_MILLIS, status);
1845 }
1846
1847 if(U_FAILURE(status))
1848 errln("setGregorianChange() failed");
1849 format->adoptCalendar((Calendar*)calendar->clone());
1850
1851 UDate dateBefore = calendar->getTime(status);
1852 if(U_FAILURE(status))
1853 errln("getTime() failed");
1854
1855 int32_t maxYear = calendar->getActualMaximum(field, status);
1856 UnicodeString temp;
1857 logln(UnicodeString("maxYear: ") + maxYear + " for " + format->format(calendar->getTime(status), temp));
1858 temp.remove();
1859 logln("date before: " + format->format(dateBefore, temp));
1860
1861 int32_t years[] = {2000, maxYear-1, maxYear, maxYear+1};
1862
1863 for (int32_t i = 0; i < 4; i++) {
1864 UBool valid = years[i] <= maxYear;
1865 calendar->set(field, years[i]);
1866 UDate dateAfter = calendar->getTime(status);
1867 if(U_FAILURE(status))
1868 errln("getTime() failed");
1869 int32_t newYear = calendar->get(field, status);
1870 if(U_FAILURE(status))
1871 errln(UnicodeString("get(") + (int32_t)field + ") failed");
1872 calendar->setTime(dateBefore, status); // restore calendar for next use
1873 if(U_FAILURE(status))
1874 errln("setTime() failed");
1875
1876 temp.remove();
1877 logln(UnicodeString(" Year ") + years[i] + (valid? " ok " : " bad") +
1878 " => " + format->format(dateAfter, temp));
1879 if (valid && newYear != years[i]) {
1880 errln(UnicodeString(" FAIL: ") + newYear + " should be valid; date, month and time shouldn't change");
1881 }
1882 // {sfb} this next line is a hack, but it should work since if a
1883 // double has an exponent, adding 1 should not yield the same double
1884 else if (!valid && /*newYear == years[i]*/ dateAfter + 1.0 == dateAfter) {
1885 errln(UnicodeString(" FAIL: ") + newYear + " should be invalid");
1886 }
1887 }
1888 }
1889 }
1890
1891 delete format;
1892 delete calendars[0];
1893 delete calendars[1];
1894 delete calendars[2];
1895 }
1896
1897 /**
1898 * Week of year is wrong at the start and end of the year.
1899 */
1900 void CalendarRegressionTest::Test4197699() {
1901 UErrorCode status = U_ZERO_ERROR;
1902 GregorianCalendar cal(status);
1903 cal.setFirstDayOfWeek(UCAL_MONDAY);
1904 cal.setMinimalDaysInFirstWeek(4);
1905 SimpleDateFormat fmt("E dd MMM yyyy 'DOY='D 'WOY='w",
1906 Locale::getUS(), status);
1907 fmt.setCalendar(cal);
1908 if (U_FAILURE(status)) {
1909 errln("Couldn't initialize test");
1910 return;
1911 }
1912
1913 int32_t DATA[] = {
1914 2000, UCAL_JANUARY, 1, 52,
1915 2001, UCAL_DECEMBER, 31, 1,
1916 };
1917 int32_t DATA_length = (int32_t)(sizeof(DATA) / sizeof(DATA[0]));
1918
1919 UnicodeString str;
1920 DateFormat& dfmt = *(DateFormat*)&fmt;
1921 for (int32_t i=0; i<DATA_length; ) {
1922 cal.clear();
1923 cal.set(DATA[i], DATA[i+1], DATA[i+2]);
1924 i += 3;
1925 int32_t expWOY = DATA[i++];
1926 int32_t actWOY = cal.get(UCAL_WEEK_OF_YEAR, status);
1927 if (expWOY == actWOY) {
1928 logln(UnicodeString("Ok: ") + dfmt.format(cal.getTime(status), str.remove()));
1929 } else {
1930 errln(UnicodeString("FAIL: ") + dfmt.format(cal.getTime(status), str.remove())
1931 + ", expected WOY=" + expWOY);
1932 cal.add(UCAL_DATE, -8, status);
1933 for (int j=0; j<14; ++j) {
1934 cal.add(UCAL_DATE, 1, status);
1935 logln(dfmt.format(cal.getTime(status), str.remove()));
1936 }
1937 }
1938 if (U_FAILURE(status)) {
1939 errln("FAIL: Unexpected error from Calendar");
1940 return;
1941 }
1942 }
1943 }
1944
1945 enum Action { ADD=1, ROLL=2 };
1946 enum Sign { PLUS=1, MINUS=2 };
1947
1948 #define ONE_HOUR (60*60*1000)
1949 #define ONE_DAY (24*ONE_HOUR)
1950
1951 typedef struct {
1952 UCalendarDateFields field;
1953 int8_t actionMask; // ADD or ROLL or both
1954 int8_t signMask; // PLUS or MINUS or both
1955 int32_t amount;
1956 int32_t before; // ms before cutover
1957 int32_t after; // ms after cutover
1958 } J81_DATA;
1959
1960 /**
1961 * Rolling and adding across the Gregorian cutover should work as expected.
1962 * Jitterbug 81.
1963 */
1964 void CalendarRegressionTest::TestJ81() {
1965 UErrorCode status = U_ZERO_ERROR;
1966 UnicodeString temp, temp2, temp3;
1967 int32_t i;
1968 GregorianCalendar cal(TimeZone::createTimeZone("GMT"), Locale::getUS(), status);
1969 SimpleDateFormat fmt("HH:mm 'w'w 'd'D E d MMM yyyy", Locale::getUS(), status);
1970 if (U_FAILURE(status)) {
1971 errln("Error: Cannot create calendar or format");
1972 return;
1973 }
1974 fmt.setCalendar(cal);
1975 // Get the Gregorian cutover
1976 UDate cutover = cal.getGregorianChange();
1977 UDate days = ONE_DAY;
1978 days = cutover/days;
1979 logln(UnicodeString("Cutover: {") +
1980 fmt.format(cutover, temp) + "}(epoch days-" + (int)days + ", jd" + (2440588 + days) +")");
1981
1982 // Check woy and doy handling. Reference data:
1983 /* w40 d274 Mon 1 Oct 1582
1984 w40 d275 Tue 2 Oct 1582
1985 w40 d276 Wed 3 Oct 1582
1986 w40 d277 Thu 4 Oct 1582
1987 w40 d278 Fri 15 Oct 1582
1988 w40 d279 Sat 16 Oct 1582
1989 w41 d280 Sun 17 Oct 1582
1990 w41 d281 Mon 18 Oct 1582
1991 w41 d282 Tue 19 Oct 1582
1992 w41 d283 Wed 20 Oct 1582
1993 w41 d284 Thu 21 Oct 1582
1994 w41 d285 Fri 22 Oct 1582
1995 w41 d286 Sat 23 Oct 1582
1996 w42 d287 Sun 24 Oct 1582
1997 w42 d288 Mon 25 Oct 1582
1998 w42 d289 Tue 26 Oct 1582
1999 w42 d290 Wed 27 Oct 1582
2000 w42 d291 Thu 28 Oct 1582
2001 w42 d292 Fri 29 Oct 1582
2002 w42 d293 Sat 30 Oct 1582
2003 w43 d294 Sun 31 Oct 1582
2004 w43 d295 Mon 1 Nov 1582 */
2005 int32_t DOY_DATA[] = {
2006 // dom, woy, doy
2007 1, 40, 274, UCAL_MONDAY,
2008 4, 40, 277, UCAL_THURSDAY,
2009 15, 40, 278, UCAL_FRIDAY,
2010 17, 41, 280, UCAL_SUNDAY,
2011 24, 42, 287, UCAL_SUNDAY,
2012 25, 42, 288, UCAL_MONDAY,
2013 26, 42, 289, UCAL_TUESDAY,
2014 27, 42, 290, UCAL_WEDNESDAY,
2015 28, 42, 291, UCAL_THURSDAY,
2016 29, 42, 292, UCAL_FRIDAY,
2017 30, 42, 293, UCAL_SATURDAY,
2018 31, 43, 294, UCAL_SUNDAY
2019 };
2020 int32_t DOY_DATA_length = (int32_t)(sizeof(DOY_DATA) / sizeof(DOY_DATA[0]));
2021
2022 for (i=0; i<DOY_DATA_length; i+=4) {
2023 // Test time->fields
2024 cal.set(1582, UCAL_OCTOBER, DOY_DATA[i]);
2025 int32_t woy = cal.get(UCAL_WEEK_OF_YEAR, status);
2026 int32_t doy = cal.get(UCAL_DAY_OF_YEAR, status);
2027 int32_t dow = cal.get(UCAL_DAY_OF_WEEK, status);
2028 if (U_FAILURE(status)) {
2029 errln("Error: get() failed");
2030 break;
2031 }
2032 if (woy != DOY_DATA[i+1] || doy != DOY_DATA[i+2] || dow != DOY_DATA[i+3]) {
2033 errln((UnicodeString)"Fail: expect woy=" + DOY_DATA[i+1] +
2034 ", doy=" + DOY_DATA[i+2] + ", dow=" + DOY_DATA[i+3] + " on " +
2035 fmt.format(cal.getTime(status), temp.remove()) +
2036 " set(1582,OCTOBER, " + DOY_DATA[i] + ")");
2037 logln(CalendarTest::calToStr(cal));
2038 status = U_ZERO_ERROR;
2039 } else {
2040 logln((UnicodeString)"PASS: expect woy=" + DOY_DATA[i+1] +
2041 ", doy=" + DOY_DATA[i+2] + ", dow=" + DOY_DATA[i+3] + " on " +
2042 fmt.format(cal.getTime(status), temp.remove()));
2043 logln(CalendarTest::calToStr(cal));
2044 status = U_ZERO_ERROR;
2045 }
2046 // Test fields->time for WOY
2047 cal.clear();
2048 cal.set(UCAL_YEAR, 1582);
2049 cal.set(UCAL_WEEK_OF_YEAR, DOY_DATA[i+1]);
2050 cal.set(UCAL_DAY_OF_WEEK, DOY_DATA[i+3]);
2051 int32_t dom = cal.get(UCAL_DATE, status);
2052 if (U_FAILURE(status)) {
2053 errln("Error: get() failed");
2054 break;
2055 }
2056 if (dom != DOY_DATA[i]) {
2057 errln((UnicodeString)"Fail: set woy=" + DOY_DATA[i+1] +
2058 " dow=" + DOY_DATA[i+3] + " => " +
2059 fmt.format(cal.getTime(status), temp.remove()) +
2060 ", expected 1582 Oct " + DOY_DATA[i]);
2061 logln(CalendarTest::calToStr(cal));
2062 status = U_ZERO_ERROR;
2063 }
2064
2065 // Test fields->time for DOY
2066 cal.clear();
2067 cal.set(UCAL_YEAR, 1582);
2068 cal.set(UCAL_DAY_OF_YEAR, DOY_DATA[i+2]);
2069 dom = cal.get(UCAL_DATE, status);
2070 if (U_FAILURE(status)) {
2071 errln("Error: get() failed");
2072 break;
2073 }
2074 if (dom != DOY_DATA[i]) {
2075 errln((UnicodeString)"Fail: set doy=" + DOY_DATA[i+2] +
2076 " => " +
2077 fmt.format(cal.getTime(status), temp.remove()) +
2078 ", expected 1582 Oct " + DOY_DATA[i]);
2079 status = U_ZERO_ERROR;
2080 }
2081 }
2082 status = U_ZERO_ERROR;
2083
2084 #define ADD_ROLL ADD|ROLL
2085 #define PLUS_MINUS PLUS|MINUS
2086 // Test cases
2087 J81_DATA DATA[] = {
2088 { UCAL_WEEK_OF_YEAR, ADD_ROLL, PLUS_MINUS, 1, -ONE_DAY, +6*ONE_DAY },
2089 { UCAL_WEEK_OF_YEAR, ADD_ROLL, PLUS_MINUS, 1, -ONE_DAY, +6*ONE_DAY },
2090 { UCAL_WEEK_OF_MONTH, ADD|ROLL, PLUS|MINUS, 1, -ONE_DAY, +6*ONE_DAY },
2091 { UCAL_DATE, ADD|ROLL, PLUS|MINUS, 2, -ONE_DAY, +1*ONE_DAY },
2092 { UCAL_DATE, ROLL, PLUS, -6, -ONE_DAY, +14*ONE_DAY },
2093 { UCAL_DATE, ROLL, PLUS, -7, 0, +14*ONE_DAY },
2094 { UCAL_DATE, ROLL, PLUS, -7, +ONE_DAY, +15*ONE_DAY },
2095 { UCAL_DATE, ROLL, PLUS, +18, -ONE_DAY, -4*ONE_DAY },
2096 { UCAL_DAY_OF_YEAR, ADD|ROLL, PLUS|MINUS, 2, -ONE_DAY, +1*ONE_DAY },
2097 { UCAL_DAY_OF_WEEK, ADD|ROLL, PLUS|MINUS, 2, -ONE_DAY, +1*ONE_DAY },
2098 { UCAL_DAY_OF_WEEK_IN_MONTH, ADD|ROLL, PLUS|MINUS, 1, -ONE_DAY, +6*ONE_DAY },
2099 { UCAL_AM_PM, ADD, PLUS|MINUS, 4, -12*ONE_HOUR, +36*ONE_HOUR },
2100 { UCAL_HOUR, ADD, PLUS|MINUS, 48, -12*ONE_HOUR, +36*ONE_HOUR },
2101 { UCAL_HOUR_OF_DAY, ADD, PLUS|MINUS, 48, -12*ONE_HOUR, +36*ONE_HOUR },
2102 { UCAL_MINUTE, ADD, PLUS|MINUS, 48*60, -12*ONE_HOUR, +36*ONE_HOUR },
2103 { UCAL_SECOND, ADD, PLUS|MINUS, 48*60*60, -12*ONE_HOUR, +36*ONE_HOUR },
2104 { UCAL_MILLISECOND, ADD, PLUS|MINUS, 48*ONE_HOUR, -12*ONE_HOUR, +36*ONE_HOUR },
2105 // NOTE: These are not supported yet. See jitterbug 180.
2106 // Uncomment these lines when add/roll supported on these fields.
2107 // { Calendar::YEAR_WOY, ADD|ROLL, 1, -ONE_DAY, +6*ONE_DAY },
2108 // { Calendar::DOW_LOCAL, ADD|ROLL, 2, -ONE_DAY, +1*ONE_DAY }
2109 };
2110 int32_t DATA_length = (int32_t)(sizeof(DATA) / sizeof(DATA[0]));
2111
2112 // Now run the tests
2113 for (i=0; i<DATA_length; ++i) {
2114 for (Action action=ADD; action<=ROLL; action=(Action)(action+1)) {
2115 if (!(DATA[i].actionMask & action)) {
2116 continue;
2117 }
2118 for (Sign sign=PLUS; sign<=MINUS; sign=(Sign)(sign+1)) {
2119 if (!(DATA[i].signMask & sign)) {
2120 continue;
2121 }
2122 status = U_ZERO_ERROR;
2123 int32_t amount = DATA[i].amount * (sign==MINUS?-1:1);
2124 UDate date = cutover +
2125 (sign==PLUS ? DATA[i].before : DATA[i].after);
2126 UDate expected = cutover +
2127 (sign==PLUS ? DATA[i].after : DATA[i].before);
2128 cal.setTime(date, status);
2129 if (U_FAILURE(status)) {
2130 errln((UnicodeString)"FAIL: setTime returned error code " + u_errorName(status));
2131 continue;
2132 }
2133 if (action == ADD) {
2134 cal.add(DATA[i].field, amount, status);
2135 } else {
2136 cal.roll(DATA[i].field, amount, status);
2137 }
2138 if (U_FAILURE(status)) {
2139 errln((UnicodeString)"FAIL: " +
2140 (action==ADD?"add ":"roll ") + FIELD_NAME[DATA[i].field] +
2141 " returned error code " + u_errorName(status));
2142 continue;
2143 }
2144 UDate result = cal.getTime(status);
2145 if (U_FAILURE(status)) {
2146 errln((UnicodeString)"FAIL: getTime returned error code " + u_errorName(status));
2147 continue;
2148 }
2149 if (result == expected) {
2150 logln((UnicodeString)"Ok: {" +
2151 fmt.format(date, temp.remove()) +
2152 "}(" + date/ONE_DAY +
2153 (action==ADD?") add ":") roll ") +
2154 amount + " " + FIELD_NAME[DATA[i].field] + " -> {" +
2155 fmt.format(result, temp2.remove()) +
2156 "}(" + result/ONE_DAY + ")");
2157 } else {
2158 errln((UnicodeString)"FAIL: {" +
2159 fmt.format(date, temp.remove()) +
2160 "}(" + date/ONE_DAY +
2161 (action==ADD?") add ":") roll ") +
2162 amount + " " + FIELD_NAME[DATA[i].field] + " -> {" +
2163 fmt.format(result, temp2.remove()) +
2164 "}(" + result/ONE_DAY + "), expect {" +
2165 fmt.format(expected, temp3.remove()) +
2166 "}(" + expected/ONE_DAY + ")");
2167 }
2168 }
2169 }
2170 }
2171 }
2172
2173 /**
2174 * Test fieldDifference().
2175 */
2176 void CalendarRegressionTest::TestJ438(void) {
2177 UErrorCode ec = U_ZERO_ERROR;
2178 int32_t DATA[] = {
2179 2000, UCAL_JANUARY, 20, 2010, UCAL_JUNE, 15,
2180 2010, UCAL_JUNE, 15, 2000, UCAL_JANUARY, 20,
2181 1964, UCAL_SEPTEMBER, 7, 1999, UCAL_JUNE, 4,
2182 1999, UCAL_JUNE, 4, 1964, UCAL_SEPTEMBER, 7,
2183 };
2184 int32_t DATA_length = (int32_t)(sizeof(DATA)/sizeof(DATA[0]));
2185 Calendar* pcal = Calendar::createInstance(Locale::getUS(), ec);
2186 if(U_FAILURE(ec)) {
2187 errln("Error creating calendar %s", u_errorName(ec));
2188 delete pcal;
2189 return;
2190 }
2191 Calendar& cal = *pcal;
2192 int32_t i;
2193 SimpleDateFormat fmt(UnicodeString("MMM dd yyyy",""), ec);
2194 fmt.setCalendar(cal);
2195 UnicodeString s, t, u;
2196 if (!failure(ec, "setup")) {
2197 for (i=0; i<DATA_length; i+=6) {
2198 int32_t y1 = DATA[i];
2199 int32_t m1 = DATA[i+1];
2200 int32_t d1 = DATA[i+2];
2201 int32_t y2 = DATA[i+3];
2202 int32_t m2 = DATA[i+4];
2203 int32_t d2 = DATA[i+5];
2204
2205 cal.clear();
2206 cal.set(y1, m1, d1);
2207 UDate date1 = cal.getTime(ec);
2208 if (failure(ec, "getTime"))
2209 break;
2210 cal.set(y2, m2, d2);
2211 UDate date2 = cal.getTime(ec);
2212 if (failure(ec, "getTime"))
2213 break;
2214
2215 cal.setTime(date1, ec);
2216 if (failure(ec, "setTime"))
2217 break;
2218 int32_t dy = cal.fieldDifference(date2, UCAL_YEAR, ec);
2219 int32_t dm = cal.fieldDifference(date2, UCAL_MONTH, ec);
2220 int32_t dd = cal.fieldDifference(date2, UCAL_DATE, ec);
2221 if (failure(ec, "fieldDifference"))
2222 break;
2223
2224 {
2225 Calendar *cal2 = cal.clone();
2226 UErrorCode ec2 = U_ZERO_ERROR;
2227
2228 cal2->setTime(date1, ec2);
2229
2230 int32_t dy2 = cal2->fieldDifference(date2, Calendar::YEAR, ec2);
2231 int32_t dm2 = cal2->fieldDifference(date2, Calendar::MONTH, ec2);
2232 int32_t dd2 = cal2->fieldDifference(date2, Calendar::DATE, ec2);
2233 if (failure(ec2, "fieldDifference(date, Calendar::DATE, ec)"))
2234 break;
2235 if( (dd2 != dd) ||
2236 (dm2 != dm) ||
2237 (dy2 != dy)){
2238 errln("fieldDifference(UCAL_...) and fieldDifference(Calendar::...) give different results!\n");
2239 }
2240 delete cal2;
2241 }
2242
2243
2244 logln(UnicodeString("") +
2245 fmt.format(date2, s.remove()) + " - " +
2246 fmt.format(date1, t.remove()) + " = " +
2247 dy + "y " + dm + "m " + dd + "d");
2248
2249 cal.setTime(date1, ec);
2250 if (failure(ec, "setTime"))
2251 break;
2252 cal.add(UCAL_YEAR, dy, ec);
2253 cal.add(UCAL_MONTH, dm, ec);
2254 cal.add(UCAL_DATE, dd, ec);
2255 if (failure(ec, "add"))
2256 break;
2257 UDate date22 = cal.getTime(ec);
2258 if (failure(ec, "getTime"))
2259 break;
2260 if (date2 != date22) {
2261 errln(UnicodeString("FAIL: ") +
2262 fmt.format(date1, s.remove()) + " + " +
2263 dy + "y " + dm + "m " + dd + "d = " +
2264 fmt.format(date22, t.remove()) + ", exp " +
2265 fmt.format(date2, u.remove()));
2266 } else {
2267 logln(UnicodeString("Ok: ") +
2268 fmt.format(date1, s.remove()) + " + " +
2269 dy + "y " + dm + "m " + dd + "d = " +
2270 fmt.format(date22, t.remove()));
2271 }
2272 }
2273 }
2274 delete pcal;
2275 }
2276
2277 void CalendarRegressionTest::TestT5555()
2278 {
2279 UErrorCode ec = U_ZERO_ERROR;
2280 Calendar *cal = Calendar::createInstance(ec);
2281
2282 if (cal == NULL || U_FAILURE(ec)) {
2283 errln("FAIL: Calendar::createInstance()");
2284 delete cal;
2285 return;
2286 }
2287
2288 // Set to Wednesday, February 21, 2007
2289 cal->set(2007, UCAL_FEBRUARY, 21);
2290
2291 // Advance three years
2292 cal->add(UCAL_MONTH, 36, ec);
2293
2294 // Set to last Wednesday of the month
2295 cal->set(UCAL_DAY_OF_WEEK_IN_MONTH, -1);
2296
2297 cal->getTime(ec);
2298
2299 int32_t yy, mm, dd, ee;
2300
2301 yy = cal->get(UCAL_YEAR, ec);
2302 mm = cal->get(UCAL_MONTH, ec);
2303 dd = cal->get(UCAL_DATE, ec);
2304 ee = cal->get(UCAL_DAY_OF_WEEK, ec);
2305
2306 // Should be set to Wednesday, February 24, 2010
2307 if (U_FAILURE(ec) || yy != 2010 || mm != UCAL_FEBRUARY || dd != 24 || ee != UCAL_WEDNESDAY) {
2308 errln("FAIL: got date %4d/%02d/%02d, expected 210/02/24: ", yy, mm + 1, dd);
2309 }
2310 delete cal;
2311 }
2312
2313 typedef struct {
2314 int32_t startYear;
2315 int32_t startMonth; // 0-based
2316 int32_t startDay; // 1-based
2317 UCalendarDateFields fieldToChange;
2318 int32_t fieldDelta;
2319 int32_t endYear;
2320 int32_t endMonth; // 0-based
2321 int32_t endDay; // 1-based
2322 } CoptEthCalTestItem;
2323
2324 // year 1724 in coptic calendar =
2325 // year 2000 in ethiopic calendar (276 more than coptic) =
2326 // year 7500 in ethiopic-amete-alem calendar (5776 more than coptic)
2327 // (2007-2008 in gregorian calendar depending on month)
2328 static const CoptEthCalTestItem coptEthCalTestItems[] = {
2329 { 1724, 12, 1, UCAL_MONTH, +1, 1725, 0, 1 },
2330 { 1724, 12, 1, UCAL_MONTH, +9, 1725, 8, 1 },
2331 { 1723, 12, 2, UCAL_MONTH, +1, 1724, 0, 2 }, // 1723 is a leap year
2332 { 1723, 12, 2, UCAL_MONTH, +9, 1724, 8, 2 },
2333 { 1725, 0, 1, UCAL_MONTH, -1, 1724, 12, 1 },
2334 { 1725, 0, 1, UCAL_MONTH, -6, 1724, 7, 1 },
2335 { 1724, 12, 1, UCAL_DATE, +8, 1725, 0, 4 },
2336 { 1723, 12, 1, UCAL_DATE, +8, 1724, 0, 3 }, // 1723 is a leap year
2337 { 1724, 0, 1, UCAL_DATE, -1, 1723, 12, 6 }, // 1723 is a leap year
2338 { 0, 0, 0, (UCalendarDateFields)0, 0, 0, 0, 0 } // terminator
2339 };
2340
2341 typedef struct {
2342 const char * locale;
2343 int32_t yearOffset;
2344 } CoptEthCalLocale;
2345
2346 static const CoptEthCalLocale copEthCalLocales[] = {
2347 { "en@calendar=coptic", 0 },
2348 { "en@calendar=ethiopic", 276 },
2349 { NULL, 0 } // terminator
2350 };
2351
2352 void CalendarRegressionTest::TestT6745()
2353 {
2354 const CoptEthCalLocale * testLocalePtr;
2355 for ( testLocalePtr = copEthCalLocales; testLocalePtr->locale != NULL; ++testLocalePtr) {
2356 UErrorCode status = U_ZERO_ERROR;
2357 Calendar *cal = Calendar::createInstance(Locale(testLocalePtr->locale), status);
2358 if ( U_FAILURE(status) ) {
2359 errln((UnicodeString)"FAIL: Calendar::createInstance, locale " + testLocalePtr->locale + ", status " + u_errorName(status));
2360 continue;
2361 }
2362 const CoptEthCalTestItem * testItemPtr;
2363 for (testItemPtr = coptEthCalTestItems; testItemPtr->fieldDelta != 0; ++testItemPtr) {
2364 status = U_ZERO_ERROR;
2365 cal->set( testItemPtr->startYear + testLocalePtr->yearOffset, testItemPtr->startMonth, testItemPtr->startDay, 9, 0 );
2366 cal->add( testItemPtr->fieldToChange, testItemPtr->fieldDelta, status );
2367 if ( U_FAILURE(status) ) {
2368 errln((UnicodeString)"FAIL: Calendar::add, locale " + testLocalePtr->locale + ", field/delta " +
2369 testItemPtr->fieldToChange + "/" + testItemPtr->fieldDelta + ", status " + u_errorName(status));
2370 continue;
2371 }
2372 int32_t endYear = testItemPtr->endYear + testLocalePtr->yearOffset;
2373 int32_t year = cal->get(UCAL_YEAR, status);
2374 int32_t month = cal->get(UCAL_MONTH, status);
2375 int32_t day = cal->get(UCAL_DATE, status);
2376 if ( U_FAILURE(status) || year != endYear || month != testItemPtr->endMonth || day != testItemPtr->endDay ) {
2377 errln((UnicodeString)"ERROR: Calendar::add, locale " + testLocalePtr->locale + ", field/delta " +
2378 testItemPtr->fieldToChange + "/" + testItemPtr->fieldDelta + ", status " + u_errorName(status) +
2379 ", expected " + endYear + "/" + testItemPtr->endMonth + "/" + testItemPtr->endDay +
2380 ", got " + year + "/" + month + "/" + day );
2381 }
2382 }
2383 delete cal;
2384 }
2385 }
2386
2387 /**
2388 * Test behavior of fieldDifference around leap years. Also test a large
2389 * field difference to check binary search.
2390 */
2391 void CalendarRegressionTest::TestLeapFieldDifference() {
2392 UErrorCode ec = U_ZERO_ERROR;
2393 Calendar* cal = Calendar::createInstance(ec);
2394 if (cal == NULL || U_FAILURE(ec)) {
2395 errln("FAIL: Calendar::createInstance()");
2396 delete cal;
2397 return;
2398 }
2399 cal->set(2004, UCAL_FEBRUARY, 29);
2400 UDate date2004 = cal->getTime(ec);
2401 cal->set(2000, UCAL_FEBRUARY, 29);
2402 UDate date2000 = cal->getTime(ec);
2403 if (U_FAILURE(ec)) {
2404 errln("FAIL: getTime()");
2405 delete cal;
2406 return;
2407 }
2408 int32_t y = cal->fieldDifference(date2004, UCAL_YEAR, ec);
2409 int32_t d = cal->fieldDifference(date2004, UCAL_DAY_OF_YEAR, ec);
2410 if (U_FAILURE(ec)) {
2411 errln("FAIL: fieldDifference()");
2412 delete cal;
2413 return;
2414 }
2415 if (d == 0) {
2416 logln((UnicodeString)"Ok: 2004/Feb/29 - 2000/Feb/29 = " + y + " years, " + d + " days");
2417 } else {
2418 errln((UnicodeString)"FAIL: 2004/Feb/29 - 2000/Feb/29 = " + y + " years, " + d + " days");
2419 }
2420 cal->setTime(date2004, ec);
2421 y = cal->fieldDifference(date2000, UCAL_YEAR, ec);
2422 d = cal->fieldDifference(date2000, UCAL_DAY_OF_YEAR, ec);
2423 if (U_FAILURE(ec)) {
2424 errln("FAIL: setTime() / fieldDifference()");
2425 delete cal;
2426 return;
2427 }
2428 if (d == 0) {
2429 logln((UnicodeString)"Ok: 2000/Feb/29 - 2004/Feb/29 = " + y + " years, " + d + " days");
2430 } else {
2431 errln((UnicodeString)"FAIL: 2000/Feb/29 - 2004/Feb/29 = " + y + " years, " + d + " days");
2432 }
2433 // Test large difference
2434 cal->set(2001, UCAL_APRIL, 5); // 2452005
2435 UDate ayl = cal->getTime(ec);
2436 cal->set(1964, UCAL_SEPTEMBER, 7); // 2438646
2437 UDate asl = cal->getTime(ec);
2438 if (U_FAILURE(ec)) {
2439 errln("FAIL: getTime()");
2440 delete cal;
2441 return;
2442 }
2443 d = cal->fieldDifference(ayl, UCAL_DATE, ec);
2444 cal->setTime(ayl, ec);
2445 int32_t d2 = cal->fieldDifference(asl, UCAL_DATE, ec);
2446 if (U_FAILURE(ec)) {
2447 errln("FAIL: setTime() / fieldDifference()");
2448 delete cal;
2449 return;
2450 }
2451 if (d == -d2 && d == 13359) {
2452 logln((UnicodeString)"Ok: large field difference symmetrical " + d);
2453 } else {
2454 logln((UnicodeString)"FAIL: large field difference incorrect " + d + ", " + d2 +
2455 ", expect +/- 13359");
2456 }
2457 delete cal;
2458 }
2459
2460 /**
2461 * Test ms_MY "Malay (Malaysia)" locale. Bug 1543.
2462 */
2463 void CalendarRegressionTest::TestMalaysianInstance() {
2464 Locale loc("ms", "MY"); // Malay (Malaysia)
2465 UErrorCode ec = U_ZERO_ERROR;
2466 Calendar* cal = Calendar::createInstance(loc, ec);
2467 if (U_FAILURE(ec)) {
2468 errln("FAIL: Can't construct calendar for ms_MY");
2469 }
2470 delete cal;
2471 }
2472
2473 /**
2474 * setFirstDayOfWeek and setMinimalDaysInFirstWeek may change the
2475 * field <=> time mapping, since they affect the interpretation of
2476 * the WEEK_OF_MONTH or WEEK_OF_YEAR fields.
2477 */
2478 void CalendarRegressionTest::TestWeekShift() {
2479 UErrorCode ec = U_ZERO_ERROR;
2480 GregorianCalendar cal(TimeZone::createTimeZone("America/Los_Angeles"),
2481 Locale("en", "US"), ec);
2482 cal.setTime(UDate(997257600000.0), ec); // Wed Aug 08 01:00:00 PDT 2001
2483 // In pass one, change the first day of week so that the weeks
2484 // shift in August 2001. In pass two, change the minimal days
2485 // in the first week so that the weeks shift in August 2001.
2486 // August 2001
2487 // Su Mo Tu We Th Fr Sa
2488 // 1 2 3 4
2489 // 5 6 7 8 9 10 11
2490 // 12 13 14 15 16 17 18
2491 // 19 20 21 22 23 24 25
2492 // 26 27 28 29 30 31
2493 for (int32_t pass=0; pass<2; ++pass) {
2494 if (pass==0) {
2495 cal.setFirstDayOfWeek(UCAL_WEDNESDAY);
2496 cal.setMinimalDaysInFirstWeek(4);
2497 } else {
2498 cal.setFirstDayOfWeek(UCAL_SUNDAY);
2499 cal.setMinimalDaysInFirstWeek(4);
2500 }
2501 cal.add(UCAL_DATE, 1, ec); // Force recalc
2502 cal.add(UCAL_DATE, -1, ec);
2503
2504 UDate time1 = cal.getTime(ec); // Get time -- should not change
2505
2506 // Now change a week parameter and then force a recalc.
2507 // The bug is that the recalc should not be necessary --
2508 // calendar should do so automatically.
2509 if (pass==0) {
2510 cal.setFirstDayOfWeek(UCAL_THURSDAY);
2511 } else {
2512 cal.setMinimalDaysInFirstWeek(5);
2513 }
2514
2515 int32_t woy1 = cal.get(UCAL_WEEK_OF_YEAR, ec);
2516 int32_t wom1 = cal.get(UCAL_WEEK_OF_MONTH, ec);
2517
2518 cal.add(UCAL_DATE, 1, ec); // Force recalc
2519 cal.add(UCAL_DATE, -1, ec);
2520
2521 int32_t woy2 = cal.get(UCAL_WEEK_OF_YEAR, ec);
2522 int32_t wom2 = cal.get(UCAL_WEEK_OF_MONTH, ec);
2523
2524 UDate time2 = cal.getTime(ec);
2525
2526 if (U_FAILURE(ec)) {
2527 errln("FAIL: internal test error");
2528 return;
2529 }
2530
2531 if (time1 != time2) {
2532 errln("FAIL: shifting week should not alter time");
2533 } else {
2534 // logln(time1);
2535 }
2536 if (woy1 == woy2 && wom1 == wom2) {
2537 logln((UnicodeString)"Ok: WEEK_OF_YEAR: " + woy1 +
2538 ", WEEK_OF_MONTH: " + wom1);
2539 } else {
2540 errln((UnicodeString)"FAIL: WEEK_OF_YEAR: " + woy1 + " => " + woy2 +
2541 ", WEEK_OF_MONTH: " + wom1 + " => " + wom2 +
2542 " after week shift");
2543 }
2544 }
2545 }
2546
2547 /**
2548 * Make sure that when adding a day, we actually wind up in a
2549 * different day. The DST adjustments we use to keep the hour
2550 * constant across DST changes can backfire and change the day.
2551 */
2552 void CalendarRegressionTest::TestTimeZoneTransitionAdd() {
2553 UErrorCode ec = U_ZERO_ERROR;
2554 Locale locale(Locale::getUS()); // could also be CHINA
2555 SimpleDateFormat dateFormat("MM/dd/yyyy HH:mm z", locale, ec);
2556
2557 StringEnumeration *tz = TimeZone::createEnumeration();
2558 if (tz == NULL) {
2559 errln("FAIL: TimeZone::createEnumeration");
2560 return;
2561 }
2562
2563 UnicodeString buf1, buf2;
2564
2565 const UChar* id;
2566 while ((id = tz->unext(NULL, ec)) != NULL && U_SUCCESS(ec)) {
2567 if (U_FAILURE(ec)) {
2568 errln("FAIL: StringEnumeration::unext");
2569 break;
2570 }
2571
2572 TimeZone *t = TimeZone::createTimeZone(id);
2573 if (t == NULL) {
2574 errln("FAIL: TimeZone::createTimeZone");
2575 break;
2576 }
2577 dateFormat.setTimeZone(*t);
2578
2579 Calendar *cal = Calendar::createInstance(t, locale, ec);
2580 if (cal == NULL || U_FAILURE(ec)) {
2581 errln("FAIL: Calendar::createTimeZone");
2582 delete cal;
2583 break;
2584 }
2585
2586 cal->clear();
2587 // Scan the year 2003, overlapping the edges of the year
2588 cal->set(UCAL_YEAR, 2002);
2589 cal->set(UCAL_MONTH, UCAL_DECEMBER);
2590 cal->set(UCAL_DATE, 25);
2591
2592 for (int32_t i=0; i<365+10 && U_SUCCESS(ec); ++i) {
2593 UDate yesterday = cal->getTime(ec);
2594 int32_t yesterday_day = cal->get(UCAL_DATE, ec);
2595 cal->add(UCAL_DATE, 1, ec);
2596 if (yesterday_day == cal->get(UCAL_DATE, ec)) {
2597 errln(UnicodeString(id) + " " +
2598 dateFormat.format(yesterday, buf1) + " +1d= " +
2599 dateFormat.format(cal->getTime(ec), buf2));
2600 buf1.truncate(0);
2601 buf2.truncate(0);
2602 }
2603 }
2604 delete cal;
2605 }
2606
2607 if (U_FAILURE(ec)) {
2608 errln("FAIL: %s", u_errorName(ec));
2609 }
2610
2611 delete tz;
2612 }
2613
2614 UDate
2615 CalendarRegressionTest::makeDate(int32_t y, int32_t m, int32_t d,
2616 int32_t hr, int32_t min, int32_t sec)
2617 {
2618 UDate result;
2619
2620 UErrorCode status = U_ZERO_ERROR;
2621 Calendar *cal = Calendar::createInstance(status);
2622 cal->clear();
2623
2624 cal->set(UCAL_YEAR, y);
2625
2626 if(m != 0) cal->set(UCAL_MONTH, m);
2627 if(d != 0) cal->set(UCAL_DATE, d);
2628 if(hr != 0) cal->set(UCAL_HOUR, hr);
2629 if(min != 0) cal->set(UCAL_MINUTE, min);
2630 if(sec != 0) cal->set(UCAL_SECOND, sec);
2631
2632 result = cal->getTime(status);
2633
2634 delete cal;
2635
2636 return result;
2637 }
2638
2639 void CalendarRegressionTest::TestDeprecates(void)
2640 {
2641 UErrorCode status = U_ZERO_ERROR;
2642 Calendar *c1 = Calendar::createInstance("ja_JP@calendar=japanese",status);
2643 Calendar *c2 = Calendar::createInstance("ja_JP_TRADITIONAL",status);
2644
2645 if(!c1 || !c2 || U_FAILURE(status)) {
2646 errln("Couldn't create calendars for roll of HOUR");
2647 return;
2648 }
2649
2650 c2->set(UCAL_HOUR,2);
2651 c1->setTime(c2->getTime(status),status);
2652 // *c1 = *c2;
2653
2654 c1->roll(Calendar::HOUR,(int32_t)3,status);
2655 c2->roll(UCAL_HOUR,(int32_t)3,status);
2656
2657 if(U_FAILURE(status)) {
2658 errln("Error code when trying to roll");
2659 } else if(*c1 != *c2) {
2660 errln("roll(EDateField, int32_t) had different effect than roll(UCalendarField, int32_t)");
2661 }
2662
2663 c1->setTime(c2->getTime(status),status);
2664 c1->roll(Calendar::HOUR,(UBool)FALSE,status);
2665 c2->roll(UCAL_HOUR,(UBool)FALSE,status);
2666
2667 if(U_FAILURE(status)) {
2668 errln("Error code when trying to roll(UBool)");
2669 } else if(*c1 != *c2) {
2670 errln("roll(EDateField, UBool) had different effect than roll(UCalendarField, UBool)");
2671 }
2672
2673 delete c1;
2674 delete c2;
2675
2676 status = U_ZERO_ERROR;
2677
2678 c1 = Calendar::createInstance("th_TH_TRADITIONAL",status);
2679 c2 = Calendar::createInstance("th_TH@calendar=buddhist",status);
2680
2681 if(!c1 || !c2 || U_FAILURE(status)) {
2682 errln("Couldn't create calendars for add of HOUR");
2683 return;
2684 }
2685
2686 c2->set(UCAL_HOUR,2);
2687 c1->setTime(c2->getTime(status),status);
2688 //*c1 = *c2;
2689
2690 c1->add(Calendar::HOUR,(int32_t)1,status);
2691
2692 if(U_FAILURE(status)) {
2693 errln("Error code when trying to add Calendar::HOUR - %s", u_errorName(status));
2694 }
2695
2696 c2->add(UCAL_HOUR,(int32_t)1,status);
2697
2698 if(U_FAILURE(status)) {
2699 errln("Error code when trying to add - UCAL_HOUR %s", u_errorName(status));
2700 } else if(*c1 != *c2) {
2701 errln("add(EDateField) had different effect than add(UCalendarField)");
2702 }
2703
2704 delete c1;
2705 delete c2;
2706
2707 status = U_ZERO_ERROR;
2708
2709 c1 = Calendar::createInstance("es_ES",status);
2710 c2 = Calendar::createInstance("es_ES",status);
2711
2712 if(!c1 || !c2 || U_FAILURE(status)) {
2713 errln("Couldn't create calendars for add of YEAR");
2714 return;
2715 }
2716
2717 c2->set(UCAL_YEAR,1900);
2718 c1->setTime(c2->getTime(status),status);
2719 //*c1 = *c2;
2720
2721 c1->add(Calendar::YEAR,(int32_t)9,status);
2722 c2->add(UCAL_YEAR,(int32_t)9,status);
2723
2724 if(U_FAILURE(status)) {
2725 errln("Error code when trying to add YEARs");
2726 } else if(*c1 != *c2) {
2727 errln("add(EDateField YEAR) had different effect than add(UCalendarField YEAR)");
2728 }
2729
2730 delete c1;
2731 delete c2;
2732 }
2733
2734
2735 #endif /* #if !UCONFIG_NO_FORMATTING */
mirror of ICU