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