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