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