]> git.saurik.com Git - apple/icu.git/blob - icuSources/test/intltest/calregts.cpp
projects / apple / icu.git / blob
? search:


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