Home | History | Annotate | Download | only in intltest
      1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
      2 // License & terms of use: http://www.unicode.org/copyright.html
      3 /************************************************************************
      4  * COPYRIGHT:
      5  * Copyright (c) 1997-2016, International Business Machines Corporation
      6  * and others. All Rights Reserved.
      7  ************************************************************************/
      8 #include "unicode/utypes.h"
      9 
     10 #if !UCONFIG_NO_FORMATTING
     11 
     12 #include "caltest.h"
     13 #include "unicode/dtfmtsym.h"
     14 #include "unicode/gregocal.h"
     15 #include "unicode/localpointer.h"
     16 #include "hebrwcal.h"
     17 #include "unicode/smpdtfmt.h"
     18 #include "unicode/simpletz.h"
     19 #include "dbgutil.h"
     20 #include "unicode/udat.h"
     21 #include "unicode/ustring.h"
     22 #include "cstring.h"
     23 #include "unicode/localpointer.h"
     24 #include "islamcal.h"
     25 
     26 #define mkcstr(U) u_austrcpy(calloc(8, u_strlen(U) + 1), U)
     27 
     28 #define TEST_CHECK_STATUS { \
     29     if (U_FAILURE(status)) { \
     30         if (status == U_MISSING_RESOURCE_ERROR) { \
     31             dataerrln("%s:%d: Test failure.  status=%s", __FILE__, __LINE__, u_errorName(status)); \
     32         } else { \
     33             errln("%s:%d: Test failure.  status=%s", __FILE__, __LINE__, u_errorName(status)); \
     34         } return;}}
     35 
     36 #define TEST_CHECK_STATUS_LOCALE(testlocale) { \
     37     if (U_FAILURE(status)) { \
     38         if (status == U_MISSING_RESOURCE_ERROR) { \
     39             dataerrln("%s:%d: Test failure, locale %s.  status=%s", __FILE__, __LINE__, testlocale, u_errorName(status)); \
     40         } else { \
     41             errln("%s:%d: Test failure, locale %s.  status=%s", __FILE__, __LINE__, testlocale, u_errorName(status)); \
     42         } return;}}
     43 
     44 #define TEST_ASSERT(expr) {if ((expr)==FALSE) {errln("%s:%d: Test failure \n", __FILE__, __LINE__);};}
     45 
     46 // *****************************************************************************
     47 // class CalendarTest
     48 // *****************************************************************************
     49 
     50 UnicodeString CalendarTest::calToStr(const Calendar & cal)
     51 {
     52   UnicodeString out;
     53   UErrorCode status = U_ZERO_ERROR;
     54   int i;
     55   UDate d;
     56   for(i = 0;i<UCAL_FIELD_COUNT;i++) {
     57     out += (UnicodeString("") + fieldName((UCalendarDateFields)i) + "=" +  cal.get((UCalendarDateFields)i, status) + UnicodeString(" "));
     58   }
     59   out += "[" + UnicodeString(cal.getType()) + "]";
     60 
     61   if(cal.inDaylightTime(status)) {
     62     out += UnicodeString(" (in DST), zone=");
     63   }
     64   else {
     65     out += UnicodeString(", zone=");
     66   }
     67 
     68   UnicodeString str2;
     69   out += cal.getTimeZone().getDisplayName(str2);
     70   d = cal.getTime(status);
     71   out += UnicodeString(" :","") + d;
     72 
     73   return out;
     74 }
     75 
     76 void CalendarTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
     77 {
     78     if (exec) logln("TestSuite TestCalendar");
     79     switch (index) {
     80         case 0:
     81             name = "TestDOW943";
     82             if (exec) {
     83                 logln("TestDOW943---"); logln("");
     84                 TestDOW943();
     85             }
     86             break;
     87         case 1:
     88             name = "TestClonesUnique908";
     89             if (exec) {
     90                 logln("TestClonesUnique908---"); logln("");
     91                 TestClonesUnique908();
     92             }
     93             break;
     94         case 2:
     95             name = "TestGregorianChange768";
     96             if (exec) {
     97                 logln("TestGregorianChange768---"); logln("");
     98                 TestGregorianChange768();
     99             }
    100             break;
    101         case 3:
    102             name = "TestDisambiguation765";
    103             if (exec) {
    104                 logln("TestDisambiguation765---"); logln("");
    105                 TestDisambiguation765();
    106             }
    107             break;
    108         case 4:
    109             name = "TestGMTvsLocal4064654";
    110             if (exec) {
    111                 logln("TestGMTvsLocal4064654---"); logln("");
    112                 TestGMTvsLocal4064654();
    113             }
    114             break;
    115         case 5:
    116             name = "TestAddSetOrder621";
    117             if (exec) {
    118                 logln("TestAddSetOrder621---"); logln("");
    119                 TestAddSetOrder621();
    120             }
    121             break;
    122         case 6:
    123             name = "TestAdd520";
    124             if (exec) {
    125                 logln("TestAdd520---"); logln("");
    126                 TestAdd520();
    127             }
    128             break;
    129         case 7:
    130             name = "TestFieldSet4781";
    131             if (exec) {
    132                 logln("TestFieldSet4781---"); logln("");
    133                 TestFieldSet4781();
    134             }
    135             break;
    136         case 8:
    137             name = "TestSerialize337";
    138             if (exec) {
    139                 logln("TestSerialize337---"); logln("");
    140             //  TestSerialize337();
    141             }
    142             break;
    143         case 9:
    144             name = "TestSecondsZero121";
    145             if (exec) {
    146                 logln("TestSecondsZero121---"); logln("");
    147                 TestSecondsZero121();
    148             }
    149             break;
    150         case 10:
    151             name = "TestAddSetGet0610";
    152             if (exec) {
    153                 logln("TestAddSetGet0610---"); logln("");
    154                 TestAddSetGet0610();
    155             }
    156             break;
    157         case 11:
    158             name = "TestFields060";
    159             if (exec) {
    160                 logln("TestFields060---"); logln("");
    161                 TestFields060();
    162             }
    163             break;
    164         case 12:
    165             name = "TestEpochStartFields";
    166             if (exec) {
    167                 logln("TestEpochStartFields---"); logln("");
    168                 TestEpochStartFields();
    169             }
    170             break;
    171         case 13:
    172             name = "TestDOWProgression";
    173             if (exec) {
    174                 logln("TestDOWProgression---"); logln("");
    175                 TestDOWProgression();
    176             }
    177             break;
    178         case 14:
    179             name = "TestGenericAPI";
    180             if (exec) {
    181                 logln("TestGenericAPI---"); logln("");
    182                 TestGenericAPI();
    183             }
    184             break;
    185         case 15:
    186             name = "TestAddRollExtensive";
    187             if (exec) {
    188                 logln("TestAddRollExtensive---"); logln("");
    189                 TestAddRollExtensive();
    190             }
    191             break;
    192         case 16:
    193             name = "TestDOW_LOCALandYEAR_WOY";
    194             if (exec) {
    195                 logln("TestDOW_LOCALandYEAR_WOY---"); logln("");
    196                 TestDOW_LOCALandYEAR_WOY();
    197             }
    198             break;
    199         case 17:
    200             name = "TestWOY";
    201             if (exec) {
    202                 logln("TestWOY---"); logln("");
    203                 TestWOY();
    204             }
    205             break;
    206         case 18:
    207             name = "TestRog";
    208             if (exec) {
    209                 logln("TestRog---"); logln("");
    210                 TestRog();
    211             }
    212             break;
    213         case 19:
    214            name = "TestYWOY";
    215             if (exec) {
    216                 logln("TestYWOY---"); logln("");
    217                 TestYWOY();
    218             }
    219             break;
    220         case 20:
    221           name = "TestJD";
    222           if(exec) {
    223             logln("TestJD---"); logln("");
    224             TestJD();
    225           }
    226           break;
    227         case 21:
    228           name = "TestDebug";
    229           if(exec) {
    230             logln("TestDebug---"); logln("");
    231             TestDebug();
    232           }
    233           break;
    234         case 22:
    235           name = "Test6703";
    236           if(exec) {
    237             logln("Test6703---"); logln("");
    238             Test6703();
    239           }
    240           break;
    241         case 23:
    242           name = "Test3785";
    243           if(exec) {
    244             logln("Test3785---"); logln("");
    245             Test3785();
    246           }
    247           break;
    248         case 24:
    249           name = "Test1624";
    250           if(exec) {
    251             logln("Test1624---"); logln("");
    252             Test1624();
    253           }
    254           break;
    255         case 25:
    256           name = "TestTimeStamp";
    257           if(exec) {
    258             logln("TestTimeStamp---"); logln("");
    259             TestTimeStamp();
    260           }
    261           break;
    262         case 26:
    263           name = "TestISO8601";
    264           if(exec) {
    265             logln("TestISO8601---"); logln("");
    266             TestISO8601();
    267           }
    268           break;
    269         case 27:
    270           name = "TestAmbiguousWallTimeAPIs";
    271           if(exec) {
    272             logln("TestAmbiguousWallTimeAPIs---"); logln("");
    273             TestAmbiguousWallTimeAPIs();
    274           }
    275           break;
    276         case 28:
    277           name = "TestRepeatedWallTime";
    278           if(exec) {
    279             logln("TestRepeatedWallTime---"); logln("");
    280             TestRepeatedWallTime();
    281           }
    282           break;
    283         case 29:
    284           name = "TestSkippedWallTime";
    285           if(exec) {
    286             logln("TestSkippedWallTime---"); logln("");
    287             TestSkippedWallTime();
    288           }
    289           break;
    290         case 30:
    291           name = "TestCloneLocale";
    292           if(exec) {
    293             logln("TestCloneLocale---"); logln("");
    294             TestCloneLocale();
    295           }
    296           break;
    297         case 31:
    298           name = "TestIslamicUmAlQura";
    299           if(exec) {
    300             logln("TestIslamicUmAlQura---"); logln("");
    301             TestIslamicUmAlQura();
    302           }
    303           break;
    304         case 32:
    305           name = "TestIslamicTabularDates";
    306           if(exec) {
    307             logln("TestIslamicTabularDates---"); logln("");
    308             TestIslamicTabularDates();
    309           }
    310           break;
    311         case 33:
    312           name = "TestHebrewMonthValidation";
    313           if(exec) {
    314             logln("TestHebrewMonthValidation---"); logln("");
    315             TestHebrewMonthValidation();
    316           }
    317           break;
    318         case 34:
    319           name = "TestWeekData";
    320           if(exec) {
    321             logln("TestWeekData---"); logln("");
    322             TestWeekData();
    323           }
    324           break;
    325         case 35:
    326           name = "TestAddAcrossZoneTransition";
    327           if(exec) {
    328             logln("TestAddAcrossZoneTransition---"); logln("");
    329             TestAddAcrossZoneTransition();
    330           }
    331           break;
    332         case 36:
    333           name = "TestChineseCalendarMapping";
    334           if(exec) {
    335             logln("TestChineseCalendarMapping---"); logln("");
    336             TestChineseCalendarMapping();
    337           }
    338           break;
    339         default: name = ""; break;
    340     }
    341 }
    342 
    343 // ---------------------------------------------------------------------------------
    344 
    345 UnicodeString CalendarTest::fieldName(UCalendarDateFields f) {
    346     switch (f) {
    347 #define FIELD_NAME_STR(x) case x: return (#x+5)
    348       FIELD_NAME_STR( UCAL_ERA );
    349       FIELD_NAME_STR( UCAL_YEAR );
    350       FIELD_NAME_STR( UCAL_MONTH );
    351       FIELD_NAME_STR( UCAL_WEEK_OF_YEAR );
    352       FIELD_NAME_STR( UCAL_WEEK_OF_MONTH );
    353       FIELD_NAME_STR( UCAL_DATE );
    354       FIELD_NAME_STR( UCAL_DAY_OF_YEAR );
    355       FIELD_NAME_STR( UCAL_DAY_OF_WEEK );
    356       FIELD_NAME_STR( UCAL_DAY_OF_WEEK_IN_MONTH );
    357       FIELD_NAME_STR( UCAL_AM_PM );
    358       FIELD_NAME_STR( UCAL_HOUR );
    359       FIELD_NAME_STR( UCAL_HOUR_OF_DAY );
    360       FIELD_NAME_STR( UCAL_MINUTE );
    361       FIELD_NAME_STR( UCAL_SECOND );
    362       FIELD_NAME_STR( UCAL_MILLISECOND );
    363       FIELD_NAME_STR( UCAL_ZONE_OFFSET );
    364       FIELD_NAME_STR( UCAL_DST_OFFSET );
    365       FIELD_NAME_STR( UCAL_YEAR_WOY );
    366       FIELD_NAME_STR( UCAL_DOW_LOCAL );
    367       FIELD_NAME_STR( UCAL_EXTENDED_YEAR );
    368       FIELD_NAME_STR( UCAL_JULIAN_DAY );
    369       FIELD_NAME_STR( UCAL_MILLISECONDS_IN_DAY );
    370 #undef FIELD_NAME_STR
    371     default:
    372         return UnicodeString("") + ((int32_t)f);
    373     }
    374 }
    375 
    376 /**
    377  * Test various API methods for API completeness.
    378  */
    379 void
    380 CalendarTest::TestGenericAPI()
    381 {
    382     UErrorCode status = U_ZERO_ERROR;
    383     UDate d;
    384     UnicodeString str;
    385     UBool eq = FALSE,b4 = FALSE,af = FALSE;
    386 
    387     UDate when = date(90, UCAL_APRIL, 15);
    388 
    389     UnicodeString tzid("TestZone");
    390     int32_t tzoffset = 123400;
    391 
    392     SimpleTimeZone *zone = new SimpleTimeZone(tzoffset, tzid);
    393     Calendar *cal = Calendar::createInstance(zone->clone(), status);
    394     if (failure(status, "Calendar::createInstance #1", TRUE)) return;
    395 
    396     if (*zone != cal->getTimeZone()) errln("FAIL: Calendar::getTimeZone failed");
    397 
    398     Calendar *cal2 = Calendar::createInstance(cal->getTimeZone(), status);
    399     if (failure(status, "Calendar::createInstance #2")) return;
    400     cal->setTime(when, status);
    401     cal2->setTime(when, status);
    402     if (failure(status, "Calendar::setTime")) return;
    403 
    404     if (!(*cal == *cal2)) errln("FAIL: Calendar::operator== failed");
    405     if ((*cal != *cal2))  errln("FAIL: Calendar::operator!= failed");
    406     if (!cal->equals(*cal2, status) ||
    407         cal->before(*cal2, status) ||
    408         cal->after(*cal2, status) ||
    409         U_FAILURE(status)) errln("FAIL: equals/before/after failed");
    410 
    411     logln(UnicodeString("cal=")  +cal->getTime(status)  + UnicodeString(calToStr(*cal)));
    412     logln(UnicodeString("cal2=")  +cal2->getTime(status)  + UnicodeString(calToStr(*cal2)));
    413     logln("cal2->setTime(when+1000)");
    414     cal2->setTime(when + 1000, status);
    415     logln(UnicodeString("cal2=")  +cal2->getTime(status)  + UnicodeString(calToStr(*cal2)));
    416 
    417     if (failure(status, "Calendar::setTime")) return;
    418     if (cal->equals(*cal2, status) ||
    419         cal2->before(*cal, status) ||
    420         cal->after(*cal2, status) ||
    421         U_FAILURE(status)) errln("FAIL: equals/before/after failed after setTime(+1000)");
    422 
    423     logln("cal->roll(UCAL_SECOND)");
    424     cal->roll(UCAL_SECOND, (UBool) TRUE, status);
    425     logln(UnicodeString("cal=")  +cal->getTime(status)  + UnicodeString(calToStr(*cal)));
    426     cal->roll(UCAL_SECOND, (int32_t)0, status);
    427     logln(UnicodeString("cal=")  +cal->getTime(status)  + UnicodeString(calToStr(*cal)));
    428     if (failure(status, "Calendar::roll")) return;
    429 
    430     if (!(eq=cal->equals(*cal2, status)) ||
    431         (b4=cal->before(*cal2, status)) ||
    432         (af=cal->after(*cal2, status)) ||
    433         U_FAILURE(status)) {
    434       errln("FAIL: equals[%c]/before[%c]/after[%c] failed after roll 1 second [should be T/F/F]",
    435             eq?'T':'F',
    436             b4?'T':'F',
    437             af?'T':'F');
    438       logln(UnicodeString("cal=")  +cal->getTime(status)  + UnicodeString(calToStr(*cal)));
    439       logln(UnicodeString("cal2=")  +cal2->getTime(status)  + UnicodeString(calToStr(*cal2)));
    440     }
    441 
    442     // Roll back to January
    443     cal->roll(UCAL_MONTH, (int32_t)(1 + UCAL_DECEMBER - cal->get(UCAL_MONTH, status)), status);
    444     if (failure(status, "Calendar::roll")) return;
    445     if (cal->equals(*cal2, status) ||
    446         cal2->before(*cal, status) ||
    447         cal->after(*cal2, status) ||
    448         U_FAILURE(status)) errln("FAIL: equals/before/after failed after rollback to January");
    449 
    450     TimeZone *z = cal->orphanTimeZone();
    451     if (z->getID(str) != tzid ||
    452         z->getRawOffset() != tzoffset)
    453         errln("FAIL: orphanTimeZone failed");
    454 
    455     int32_t i;
    456     for (i=0; i<2; ++i)
    457     {
    458         UBool lenient = ( i > 0 );
    459         cal->setLenient(lenient);
    460         if (lenient != cal->isLenient()) errln("FAIL: setLenient/isLenient failed");
    461         // Later: Check for lenient behavior
    462     }
    463 
    464     for (i=UCAL_SUNDAY; i<=UCAL_SATURDAY; ++i)
    465     {
    466         cal->setFirstDayOfWeek((UCalendarDaysOfWeek)i);
    467         if (cal->getFirstDayOfWeek() != i) errln("FAIL: set/getFirstDayOfWeek failed");
    468         UErrorCode aStatus = U_ZERO_ERROR;
    469         if (cal->getFirstDayOfWeek(aStatus) != i || U_FAILURE(aStatus)) errln("FAIL: getFirstDayOfWeek(status) failed");
    470     }
    471 
    472     for (i=1; i<=7; ++i)
    473     {
    474         cal->setMinimalDaysInFirstWeek((uint8_t)i);
    475         if (cal->getMinimalDaysInFirstWeek() != i) errln("FAIL: set/getFirstDayOfWeek failed");
    476     }
    477 
    478     for (i=0; i<UCAL_FIELD_COUNT; ++i)
    479     {
    480         if (cal->getMinimum((UCalendarDateFields)i) > cal->getGreatestMinimum((UCalendarDateFields)i))
    481             errln(UnicodeString("FAIL: getMinimum larger than getGreatestMinimum for field ") + i);
    482         if (cal->getLeastMaximum((UCalendarDateFields)i) > cal->getMaximum((UCalendarDateFields)i))
    483             errln(UnicodeString("FAIL: getLeastMaximum larger than getMaximum for field ") + i);
    484         if (cal->getMinimum((UCalendarDateFields)i) >= cal->getMaximum((UCalendarDateFields)i))
    485             errln(UnicodeString("FAIL: getMinimum not less than getMaximum for field ") + i);
    486     }
    487 
    488     cal->adoptTimeZone(TimeZone::createDefault());
    489     cal->clear();
    490     cal->set(1984, 5, 24);
    491     if (cal->getTime(status) != date(84, 5, 24) || U_FAILURE(status))
    492         errln("FAIL: Calendar::set(3 args) failed");
    493 
    494     cal->clear();
    495     cal->set(1985, 3, 2, 11, 49);
    496     if (cal->getTime(status) != date(85, 3, 2, 11, 49) || U_FAILURE(status))
    497         errln("FAIL: Calendar::set(5 args) failed");
    498 
    499     cal->clear();
    500     cal->set(1995, 9, 12, 1, 39, 55);
    501     if (cal->getTime(status) != date(95, 9, 12, 1, 39, 55) || U_FAILURE(status))
    502         errln("FAIL: Calendar::set(6 args) failed");
    503 
    504     cal->getTime(status);
    505     if (failure(status, "Calendar::getTime")) return;
    506     for (i=0; i<UCAL_FIELD_COUNT; ++i)
    507     {
    508         switch(i) {
    509             case UCAL_YEAR: case UCAL_MONTH: case UCAL_DATE:
    510             case UCAL_HOUR_OF_DAY: case UCAL_MINUTE: case UCAL_SECOND:
    511             case UCAL_EXTENDED_YEAR:
    512               if (!cal->isSet((UCalendarDateFields)i)) errln("FAIL: Calendar::isSet F, should be T " + fieldName((UCalendarDateFields)i));
    513                 break;
    514             default:
    515               if (cal->isSet((UCalendarDateFields)i)) errln("FAIL: Calendar::isSet = T, should be F  " + fieldName((UCalendarDateFields)i));
    516         }
    517         cal->clear((UCalendarDateFields)i);
    518         if (cal->isSet((UCalendarDateFields)i)) errln("FAIL: Calendar::clear/isSet failed " + fieldName((UCalendarDateFields)i));
    519     }
    520 
    521     if(cal->getActualMinimum(Calendar::SECOND, status) != 0){
    522         errln("Calendar is suppose to return 0 for getActualMinimum");
    523     }
    524 
    525     Calendar *cal3 = Calendar::createInstance(status);
    526     cal3->roll(Calendar::SECOND, (int32_t)0, status);
    527     if (failure(status, "Calendar::roll(EDateFields, int32_t, UErrorCode)")) return;
    528 
    529     delete cal;
    530     delete cal2;
    531     delete cal3;
    532 
    533     int32_t count;
    534     const Locale* loc = Calendar::getAvailableLocales(count);
    535     if (count < 1 || loc == 0)
    536     {
    537         dataerrln("FAIL: getAvailableLocales failed");
    538     }
    539     else
    540     {
    541         for (i=0; i<count; ++i)
    542         {
    543             cal = Calendar::createInstance(loc[i], status);
    544             if (U_FAILURE(status)) {
    545                 errcheckln(status, UnicodeString("FAIL: Calendar::createInstance #3, locale ") +  loc[i].getName() + " , error " + u_errorName(status));
    546                 return;
    547             }
    548             delete cal;
    549         }
    550     }
    551 
    552     cal = Calendar::createInstance(TimeZone::createDefault(), Locale::getEnglish(), status);
    553     if (failure(status, "Calendar::createInstance #4")) return;
    554     delete cal;
    555 
    556     cal = Calendar::createInstance(*zone, Locale::getEnglish(), status);
    557     if (failure(status, "Calendar::createInstance #5")) return;
    558     delete cal;
    559 
    560     GregorianCalendar *gc = new GregorianCalendar(*zone, status);
    561     if (failure(status, "new GregorianCalendar")) return;
    562     delete gc;
    563 
    564     gc = new GregorianCalendar(Locale::getEnglish(), status);
    565     if (failure(status, "new GregorianCalendar")) return;
    566     delete gc;
    567 
    568     gc = new GregorianCalendar(Locale::getEnglish(), status);
    569     delete gc;
    570 
    571     gc = new GregorianCalendar(*zone, Locale::getEnglish(), status);
    572     if (failure(status, "new GregorianCalendar")) return;
    573     delete gc;
    574 
    575     gc = new GregorianCalendar(zone, status);
    576     if (failure(status, "new GregorianCalendar")) return;
    577     delete gc;
    578 
    579     gc = new GregorianCalendar(1998, 10, 14, 21, 43, status);
    580     if (gc->getTime(status) != (d =date(98, 10, 14, 21, 43) )|| U_FAILURE(status))
    581       errln("FAIL: new GregorianCalendar(ymdhm) failed with " + UnicodeString(u_errorName(status)) + ",  cal="  + gc->getTime(status)  + UnicodeString(calToStr(*gc)) + ", d=" + d);
    582     else
    583       logln(UnicodeString("GOOD: cal=")  +gc->getTime(status)  + UnicodeString(calToStr(*gc)) + ", d=" + d);
    584     delete gc;
    585 
    586     gc = new GregorianCalendar(1998, 10, 14, 21, 43, 55, status);
    587     if (gc->getTime(status) != (d=date(98, 10, 14, 21, 43, 55)) || U_FAILURE(status))
    588       errln("FAIL: new GregorianCalendar(ymdhms) failed with " + UnicodeString(u_errorName(status)));
    589 
    590     GregorianCalendar gc2(Locale::getEnglish(), status);
    591     if (failure(status, "new GregorianCalendar")) return;
    592     gc2 = *gc;
    593     if (gc2 != *gc || !(gc2 == *gc)) errln("FAIL: GregorianCalendar assignment/operator==/operator!= failed");
    594     delete gc;
    595     delete z;
    596 
    597     /* Code coverage for Calendar class. */
    598     cal = Calendar::createInstance(status);
    599     if (failure(status, "Calendar::createInstance #6")) {
    600         return;
    601     }else {
    602         ((Calendar *)cal)->roll(UCAL_HOUR, (int32_t)100, status);
    603         ((Calendar *)cal)->clear(UCAL_HOUR);
    604 #if !UCONFIG_NO_SERVICE
    605         URegistryKey key = cal->registerFactory(NULL, status);
    606         cal->unregister(key, status);
    607 #endif
    608     }
    609     delete cal;
    610 
    611     status = U_ZERO_ERROR;
    612     cal = Calendar::createInstance(Locale("he_IL@calendar=hebrew"), status);
    613     if (failure(status, "Calendar::createInstance #7")) {
    614         return;
    615     } else {
    616         cal->roll(Calendar::MONTH, (int32_t)100, status);
    617     }
    618 
    619     LocalPointer<StringEnumeration> values(
    620         Calendar::getKeywordValuesForLocale("calendar", Locale("he"), FALSE, status));
    621     if (values.isNull() || U_FAILURE(status)) {
    622         dataerrln("FAIL: Calendar::getKeywordValuesForLocale(he): %s", u_errorName(status));
    623     } else {
    624         UBool containsHebrew = FALSE;
    625         const char *charValue;
    626         int32_t valueLength;
    627         while ((charValue = values->next(&valueLength, status)) != NULL) {
    628             if (valueLength == 6 && strcmp(charValue, "hebrew") == 0) {
    629                 containsHebrew = TRUE;
    630             }
    631         }
    632         if (!containsHebrew) {
    633             errln("Calendar::getKeywordValuesForLocale(he)->next() does not contain \"hebrew\"");
    634         }
    635 
    636         values->reset(status);
    637         containsHebrew = FALSE;
    638         UnicodeString hebrew = UNICODE_STRING_SIMPLE("hebrew");
    639         const UChar *ucharValue;
    640         while ((ucharValue = values->unext(&valueLength, status)) != NULL) {
    641             UnicodeString value(FALSE, ucharValue, valueLength);
    642             if (value == hebrew) {
    643                 containsHebrew = TRUE;
    644             }
    645         }
    646         if (!containsHebrew) {
    647             errln("Calendar::getKeywordValuesForLocale(he)->unext() does not contain \"hebrew\"");
    648         }
    649 
    650         values->reset(status);
    651         containsHebrew = FALSE;
    652         const UnicodeString *stringValue;
    653         while ((stringValue = values->snext(status)) != NULL) {
    654             if (*stringValue == hebrew) {
    655                 containsHebrew = TRUE;
    656             }
    657         }
    658         if (!containsHebrew) {
    659             errln("Calendar::getKeywordValuesForLocale(he)->snext() does not contain \"hebrew\"");
    660         }
    661     }
    662     delete cal;
    663 }
    664 
    665 // -------------------------------------
    666 
    667 /**
    668  * This test confirms the correct behavior of add when incrementing
    669  * through subsequent days.
    670  */
    671 void
    672 CalendarTest::TestRog()
    673 {
    674     UErrorCode status = U_ZERO_ERROR;
    675     GregorianCalendar* gc = new GregorianCalendar(status);
    676     if (failure(status, "new GregorianCalendar", TRUE)) return;
    677     int32_t year = 1997, month = UCAL_APRIL, date = 1;
    678     gc->set(year, month, date);
    679     gc->set(UCAL_HOUR_OF_DAY, 23);
    680     gc->set(UCAL_MINUTE, 0);
    681     gc->set(UCAL_SECOND, 0);
    682     gc->set(UCAL_MILLISECOND, 0);
    683     for (int32_t i = 0; i < 9; i++, gc->add(UCAL_DATE, 1, status)) {
    684         if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
    685         if (gc->get(UCAL_YEAR, status) != year ||
    686             gc->get(UCAL_MONTH, status) != month ||
    687             gc->get(UCAL_DATE, status) != (date + i)) errln("FAIL: Date wrong");
    688         if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
    689     }
    690     delete gc;
    691 }
    692 
    693 // -------------------------------------
    694 
    695 /**
    696  * Test the handling of the day of the week, checking for correctness and
    697  * for correct minimum and maximum values.
    698  */
    699 void
    700 CalendarTest::TestDOW943()
    701 {
    702     dowTest(FALSE);
    703     dowTest(TRUE);
    704 }
    705 
    706 void CalendarTest::dowTest(UBool lenient)
    707 {
    708     UErrorCode status = U_ZERO_ERROR;
    709     GregorianCalendar* cal = new GregorianCalendar(status);
    710     if (failure(status, "new GregorianCalendar", TRUE)) return;
    711     logln("cal - Aug 12, 1997\n");
    712     cal->set(1997, UCAL_AUGUST, 12);
    713     cal->getTime(status);
    714     if (U_FAILURE(status)) { errln("Calendar::getTime failed"); return; }
    715     logln((lenient?UnicodeString("LENIENT0: "):UnicodeString("nonlenient0: ")) + UnicodeString(calToStr(*cal)));
    716     cal->setLenient(lenient);
    717     logln("cal - Dec 1, 1996\n");
    718     cal->set(1996, UCAL_DECEMBER, 1);
    719     logln((lenient?UnicodeString("LENIENT: "):UnicodeString("nonlenient: ")) + UnicodeString(calToStr(*cal)));
    720     int32_t dow = cal->get(UCAL_DAY_OF_WEEK, status);
    721     if (U_FAILURE(status)) { errln("Calendar::get failed [%s]", u_errorName(status)); return; }
    722     int32_t min = cal->getMinimum(UCAL_DAY_OF_WEEK);
    723     int32_t max = cal->getMaximum(UCAL_DAY_OF_WEEK);
    724     if (dow < min ||
    725         dow > max) errln(UnicodeString("FAIL: Day of week ") + (int32_t)dow + " out of range");
    726     if (dow != UCAL_SUNDAY) errln("FAIL: Day of week should be SUNDAY[%d] not %d", UCAL_SUNDAY, dow);
    727     if (min != UCAL_SUNDAY ||
    728         max != UCAL_SATURDAY) errln("FAIL: Min/max bad");
    729     delete cal;
    730 }
    731 
    732 // -------------------------------------
    733 
    734 /**
    735  * Confirm that cloned Calendar objects do not inadvertently share substructures.
    736  */
    737 void
    738 CalendarTest::TestClonesUnique908()
    739 {
    740     UErrorCode status = U_ZERO_ERROR;
    741     Calendar *c = Calendar::createInstance(status);
    742     if (failure(status, "Calendar::createInstance", TRUE)) return;
    743     Calendar *d = (Calendar*) c->clone();
    744     c->set(UCAL_MILLISECOND, 123);
    745     d->set(UCAL_MILLISECOND, 456);
    746     if (c->get(UCAL_MILLISECOND, status) != 123 ||
    747         d->get(UCAL_MILLISECOND, status) != 456) {
    748         errln("FAIL: Clones share fields");
    749     }
    750     if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
    751     delete c;
    752     delete d;
    753 }
    754 
    755 // -------------------------------------
    756 
    757 /**
    758  * Confirm that the Gregorian cutoff value works as advertised.
    759  */
    760 void
    761 CalendarTest::TestGregorianChange768()
    762 {
    763     UBool b;
    764     UErrorCode status = U_ZERO_ERROR;
    765     UnicodeString str;
    766     GregorianCalendar* c = new GregorianCalendar(status);
    767     if (failure(status, "new GregorianCalendar", TRUE)) return;
    768     logln(UnicodeString("With cutoff ") + dateToString(c->getGregorianChange(), str));
    769     b = c->isLeapYear(1800);
    770     logln(UnicodeString(" isLeapYear(1800) = ") + (b ? "true" : "false"));
    771     logln(UnicodeString(" (should be FALSE)"));
    772     if (b) errln("FAIL");
    773     c->setGregorianChange(date(0, 0, 1), status);
    774     if (U_FAILURE(status)) { errln("GregorianCalendar::setGregorianChange failed"); return; }
    775     logln(UnicodeString("With cutoff ") + dateToString(c->getGregorianChange(), str));
    776     b = c->isLeapYear(1800);
    777     logln(UnicodeString(" isLeapYear(1800) = ") + (b ? "true" : "false"));
    778     logln(UnicodeString(" (should be TRUE)"));
    779     if (!b) errln("FAIL");
    780     delete c;
    781 }
    782 
    783 // -------------------------------------
    784 
    785 /**
    786  * Confirm the functioning of the field disambiguation algorithm.
    787  */
    788 void
    789 CalendarTest::TestDisambiguation765()
    790 {
    791     UErrorCode status = U_ZERO_ERROR;
    792     Calendar *c = Calendar::createInstance("en_US", status);
    793     if (failure(status, "Calendar::createInstance", TRUE)) return;
    794     c->setLenient(FALSE);
    795     c->clear();
    796     c->set(UCAL_YEAR, 1997);
    797     c->set(UCAL_MONTH, UCAL_JUNE);
    798     c->set(UCAL_DATE, 3);
    799     verify765("1997 third day of June = ", c, 1997, UCAL_JUNE, 3);
    800     c->clear();
    801     c->set(UCAL_YEAR, 1997);
    802     c->set(UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
    803     c->set(UCAL_MONTH, UCAL_JUNE);
    804     c->set(UCAL_DAY_OF_WEEK_IN_MONTH, 1);
    805     verify765("1997 first Tuesday in June = ", c, 1997, UCAL_JUNE, 3);
    806     c->clear();
    807     c->set(UCAL_YEAR, 1997);
    808     c->set(UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
    809     c->set(UCAL_MONTH, UCAL_JUNE);
    810     c->set(UCAL_DAY_OF_WEEK_IN_MONTH, - 1);
    811     verify765("1997 last Tuesday in June = ", c, 1997, UCAL_JUNE, 24);
    812 
    813     status = U_ZERO_ERROR;
    814     c->clear();
    815     c->set(UCAL_YEAR, 1997);
    816     c->set(UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
    817     c->set(UCAL_MONTH, UCAL_JUNE);
    818     c->set(UCAL_DAY_OF_WEEK_IN_MONTH, 0);
    819     c->getTime(status);
    820     verify765("1997 zero-th Tuesday in June = ", status);
    821 
    822     c->clear();
    823     c->set(UCAL_YEAR, 1997);
    824     c->set(UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
    825     c->set(UCAL_MONTH, UCAL_JUNE);
    826     c->set(UCAL_WEEK_OF_MONTH, 1);
    827     verify765("1997 Tuesday in week 1 of June = ", c, 1997, UCAL_JUNE, 3);
    828     c->clear();
    829     c->set(UCAL_YEAR, 1997);
    830     c->set(UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
    831     c->set(UCAL_MONTH, UCAL_JUNE);
    832     c->set(UCAL_WEEK_OF_MONTH, 5);
    833     verify765("1997 Tuesday in week 5 of June = ", c, 1997, UCAL_JULY, 1);
    834 
    835     status = U_ZERO_ERROR;
    836     c->clear();
    837     c->set(UCAL_YEAR, 1997);
    838     c->set(UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
    839     c->set(UCAL_MONTH, UCAL_JUNE);
    840     c->set(UCAL_WEEK_OF_MONTH, 0);
    841     c->setMinimalDaysInFirstWeek(1);
    842     c->getTime(status);
    843     verify765("1997 Tuesday in week 0 of June = ", status);
    844 
    845     /* Note: The following test used to expect YEAR 1997, WOY 1 to
    846      * resolve to a date in Dec 1996; that is, to behave as if
    847      * YEAR_WOY were 1997.  With the addition of a new explicit
    848      * YEAR_WOY field, YEAR_WOY must itself be set if that is what is
    849      * desired.  Using YEAR in combination with WOY is ambiguous, and
    850      * results in the first WOY/DOW day of the year satisfying the
    851      * given fields (there may be up to two such days). In this case,
    852      * it propertly resolves to Tue Dec 30 1997, which has a WOY value
    853      * of 1 (for YEAR_WOY 1998) and a DOW of Tuesday, and falls in the
    854      * _calendar_ year 1997, as specified. - aliu */
    855     c->clear();
    856     c->set(UCAL_YEAR_WOY, 1997); // aliu
    857     c->set(UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
    858     c->set(UCAL_WEEK_OF_YEAR, 1);
    859     verify765("1997 Tuesday in week 1 of yearWOY = ", c, 1996, UCAL_DECEMBER, 31);
    860     c->clear(); // - add test for YEAR
    861     c->setMinimalDaysInFirstWeek(1);
    862     c->set(UCAL_YEAR, 1997);
    863     c->set(UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
    864     c->set(UCAL_WEEK_OF_YEAR, 1);
    865     verify765("1997 Tuesday in week 1 of year = ", c, 1997, UCAL_DECEMBER, 30);
    866     c->clear();
    867     c->set(UCAL_YEAR, 1997);
    868     c->set(UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
    869     c->set(UCAL_WEEK_OF_YEAR, 10);
    870     verify765("1997 Tuesday in week 10 of year = ", c, 1997, UCAL_MARCH, 4);
    871     //try {
    872 
    873     // {sfb} week 0 is no longer a valid week of year
    874     /*c->clear();
    875     c->set(Calendar::YEAR, 1997);
    876     c->set(Calendar::DAY_OF_WEEK, Calendar::TUESDAY);
    877     //c->set(Calendar::WEEK_OF_YEAR, 0);
    878     c->set(Calendar::WEEK_OF_YEAR, 1);
    879     verify765("1997 Tuesday in week 0 of year = ", c, 1996, Calendar::DECEMBER, 24);*/
    880 
    881     //}
    882     //catch(IllegalArgumentException ex) {
    883     //    errln("FAIL: Exception seen:");
    884     //    ex.printStackTrace(log);
    885     //}
    886     delete c;
    887 }
    888 
    889 // -------------------------------------
    890 
    891 void
    892 CalendarTest::verify765(const UnicodeString& msg, Calendar* c, int32_t year, int32_t month, int32_t day)
    893 {
    894     UnicodeString str;
    895     UErrorCode status = U_ZERO_ERROR;
    896     int32_t y = c->get(UCAL_YEAR, status);
    897     int32_t m = c->get(UCAL_MONTH, status);
    898     int32_t d = c->get(UCAL_DATE, status);
    899     if ( y == year &&
    900          m == month &&
    901          d == day) {
    902         if (U_FAILURE(status)) { errln("FAIL: Calendar::get failed"); return; }
    903         logln("PASS: " + msg + dateToString(c->getTime(status), str));
    904         if (U_FAILURE(status)) { errln("Calendar::getTime failed"); return; }
    905     }
    906     else {
    907         errln("FAIL: " + msg + dateToString(c->getTime(status), str) + "; expected " + (int32_t)year + "/" + (int32_t)(month + 1) + "/" + (int32_t)day +
    908             "; got " + (int32_t)y + "/" + (int32_t)(m + 1) + "/" + (int32_t)d + " for Locale: " + c->getLocaleID(ULOC_ACTUAL_LOCALE,status));
    909         if (U_FAILURE(status)) { errln("Calendar::getTime failed"); return; }
    910     }
    911 }
    912 
    913 // -------------------------------------
    914 
    915 void
    916 CalendarTest::verify765(const UnicodeString& msg/*, IllegalArgumentException e*/, UErrorCode status)
    917 {
    918     if (status != U_ILLEGAL_ARGUMENT_ERROR) errln("FAIL: No IllegalArgumentException for " + msg);
    919     else logln("PASS: " + msg + "IllegalArgument as expected");
    920 }
    921 
    922 // -------------------------------------
    923 
    924 /**
    925  * Confirm that the offset between local time and GMT behaves as expected.
    926  */
    927 void
    928 CalendarTest::TestGMTvsLocal4064654()
    929 {
    930     test4064654(1997, 1, 1, 12, 0, 0);
    931     test4064654(1997, 4, 16, 18, 30, 0);
    932 }
    933 
    934 // -------------------------------------
    935 
    936 void
    937 CalendarTest::test4064654(int32_t yr, int32_t mo, int32_t dt, int32_t hr, int32_t mn, int32_t sc)
    938 {
    939     UDate date;
    940     UErrorCode status = U_ZERO_ERROR;
    941     UnicodeString str;
    942     Calendar *gmtcal = Calendar::createInstance(status);
    943     if (failure(status, "Calendar::createInstance", TRUE)) return;
    944     gmtcal->adoptTimeZone(TimeZone::createTimeZone("Africa/Casablanca"));
    945     gmtcal->set(yr, mo - 1, dt, hr, mn, sc);
    946     gmtcal->set(UCAL_MILLISECOND, 0);
    947     date = gmtcal->getTime(status);
    948     if (U_FAILURE(status)) { errln("Calendar::getTime failed"); return; }
    949     logln("date = " + dateToString(date, str));
    950     Calendar *cal = Calendar::createInstance(status);
    951     if (U_FAILURE(status)) { errln("Calendar::createInstance failed"); return; }
    952     cal->setTime(date, status);
    953     if (U_FAILURE(status)) { errln("Calendar::setTime failed"); return; }
    954     int32_t offset = cal->getTimeZone().getOffset((uint8_t)cal->get(UCAL_ERA, status),
    955                                                   cal->get(UCAL_YEAR, status),
    956                                                   cal->get(UCAL_MONTH, status),
    957                                                   cal->get(UCAL_DATE, status),
    958                                                   (uint8_t)cal->get(UCAL_DAY_OF_WEEK, status),
    959                                                   cal->get(UCAL_MILLISECOND, status), status);
    960     if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
    961     logln("offset for " + dateToString(date, str) + "= " + (offset / 1000 / 60 / 60.0) + "hr");
    962     int32_t utc = ((cal->get(UCAL_HOUR_OF_DAY, status) * 60 +
    963                     cal->get(UCAL_MINUTE, status)) * 60 +
    964                    cal->get(UCAL_SECOND, status)) * 1000 +
    965         cal->get(UCAL_MILLISECOND, status) - offset;
    966     if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
    967     int32_t expected = ((hr * 60 + mn) * 60 + sc) * 1000;
    968     if (utc != expected) errln(UnicodeString("FAIL: Discrepancy of ") + (utc - expected) +
    969                                " millis = " + ((utc - expected) / 1000 / 60 / 60.0) + " hr");
    970     delete gmtcal;
    971     delete cal;
    972 }
    973 
    974 // -------------------------------------
    975 
    976 /**
    977  * The operations of adding and setting should not exhibit pathological
    978  * dependence on the order of operations.  This test checks for this.
    979  */
    980 void
    981 CalendarTest::TestAddSetOrder621()
    982 {
    983     UDate d = date(97, 4, 14, 13, 23, 45);
    984     UErrorCode status = U_ZERO_ERROR;
    985     Calendar *cal = Calendar::createInstance(status);
    986     if (failure(status, "Calendar::createInstance", TRUE)) return;
    987 
    988     cal->setTime(d, status);
    989     if (U_FAILURE(status)) {
    990         errln("Calendar::setTime failed");
    991         delete cal;
    992         return;
    993     }
    994     cal->add(UCAL_DATE, - 5, status);
    995     if (U_FAILURE(status)) {
    996         errln("Calendar::add failed");
    997         delete cal;
    998         return;
    999     }
   1000     cal->set(UCAL_HOUR_OF_DAY, 0);
   1001     cal->set(UCAL_MINUTE, 0);
   1002     cal->set(UCAL_SECOND, 0);
   1003     UnicodeString s;
   1004     dateToString(cal->getTime(status), s);
   1005     if (U_FAILURE(status)) {
   1006         errln("Calendar::getTime failed");
   1007         delete cal;
   1008         return;
   1009     }
   1010     delete cal;
   1011 
   1012     cal = Calendar::createInstance(status);
   1013     if (U_FAILURE(status)) {
   1014         errln("Calendar::createInstance failed");
   1015         delete cal;
   1016         return;
   1017     }
   1018     cal->setTime(d, status);
   1019     if (U_FAILURE(status)) {
   1020         errln("Calendar::setTime failed");
   1021         delete cal;
   1022         return;
   1023     }
   1024     cal->set(UCAL_HOUR_OF_DAY, 0);
   1025     cal->set(UCAL_MINUTE, 0);
   1026     cal->set(UCAL_SECOND, 0);
   1027     cal->add(UCAL_DATE, - 5, status);
   1028     if (U_FAILURE(status)) {
   1029         errln("Calendar::add failed");
   1030         delete cal;
   1031         return;
   1032     }
   1033     UnicodeString s2;
   1034     dateToString(cal->getTime(status), s2);
   1035     if (U_FAILURE(status)) {
   1036         errln("Calendar::getTime failed");
   1037         delete cal;
   1038         return;
   1039     }
   1040     if (s == s2)
   1041         logln("Pass: " + s + " == " + s2);
   1042     else
   1043         errln("FAIL: " + s + " != " + s2);
   1044     delete cal;
   1045 }
   1046 
   1047 // -------------------------------------
   1048 
   1049 /**
   1050  * Confirm that adding to various fields works.
   1051  */
   1052 void
   1053 CalendarTest::TestAdd520()
   1054 {
   1055     int32_t y = 1997, m = UCAL_FEBRUARY, d = 1;
   1056     UErrorCode status = U_ZERO_ERROR;
   1057     GregorianCalendar *temp = new GregorianCalendar(y, m, d, status);
   1058     if (failure(status, "new GregorianCalendar", TRUE)) return;
   1059     check520(temp, y, m, d);
   1060     temp->add(UCAL_YEAR, 1, status);
   1061     if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
   1062     y++;
   1063     check520(temp, y, m, d);
   1064     temp->add(UCAL_MONTH, 1, status);
   1065     if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
   1066     m++;
   1067     check520(temp, y, m, d);
   1068     temp->add(UCAL_DATE, 1, status);
   1069     if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
   1070     d++;
   1071     check520(temp, y, m, d);
   1072     temp->add(UCAL_DATE, 2, status);
   1073     if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
   1074     d += 2;
   1075     check520(temp, y, m, d);
   1076     temp->add(UCAL_DATE, 28, status);
   1077     if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
   1078     d = 1;++m;
   1079     check520(temp, y, m, d);
   1080     delete temp;
   1081 }
   1082 
   1083 // -------------------------------------
   1084 
   1085 /**
   1086  * Execute adding and rolling in GregorianCalendar extensively,
   1087  */
   1088 void
   1089 CalendarTest::TestAddRollExtensive()
   1090 {
   1091     int32_t maxlimit = 40;
   1092     int32_t y = 1997, m = UCAL_FEBRUARY, d = 1, hr = 1, min = 1, sec = 0, ms = 0;
   1093     UErrorCode status = U_ZERO_ERROR;
   1094     GregorianCalendar *temp = new GregorianCalendar(y, m, d, status);
   1095     if (failure(status, "new GregorianCalendar", TRUE)) return;
   1096 
   1097     temp->set(UCAL_HOUR, hr);
   1098     temp->set(UCAL_MINUTE, min);
   1099     temp->set(UCAL_SECOND, sec);
   1100     temp->set(UCAL_MILLISECOND, ms);
   1101     temp->setMinimalDaysInFirstWeek(1);
   1102 
   1103     UCalendarDateFields e;
   1104 
   1105     logln("Testing GregorianCalendar add...");
   1106     e = UCAL_YEAR;
   1107     while (e < UCAL_FIELD_COUNT) {
   1108         int32_t i;
   1109         int32_t limit = maxlimit;
   1110         status = U_ZERO_ERROR;
   1111         for (i = 0; i < limit; i++) {
   1112             temp->add(e, 1, status);
   1113             if (U_FAILURE(status)) { limit = i; status = U_ZERO_ERROR; }
   1114         }
   1115         for (i = 0; i < limit; i++) {
   1116             temp->add(e, -1, status);
   1117             if (U_FAILURE(status)) { errln("GregorianCalendar::add -1 failed"); return; }
   1118         }
   1119         check520(temp, y, m, d, hr, min, sec, ms, e);
   1120 
   1121         e = (UCalendarDateFields) ((int32_t) e + 1);
   1122     }
   1123 
   1124     logln("Testing GregorianCalendar roll...");
   1125     e = UCAL_YEAR;
   1126     while (e < UCAL_FIELD_COUNT) {
   1127         int32_t i;
   1128         int32_t limit = maxlimit;
   1129         status = U_ZERO_ERROR;
   1130         for (i = 0; i < limit; i++) {
   1131             logln(calToStr(*temp) + UnicodeString("  " ) + fieldName(e) + UnicodeString("++") );
   1132             temp->roll(e, 1, status);
   1133             if (U_FAILURE(status)) {
   1134               logln("caltest.cpp:%d e=%d, i=%d - roll(+) err %s\n",  __LINE__, (int) e, (int) i, u_errorName(status));
   1135               logln(calToStr(*temp));
   1136               limit = i; status = U_ZERO_ERROR;
   1137             }
   1138         }
   1139         for (i = 0; i < limit; i++) {
   1140             logln("caltest.cpp:%d e=%d, i=%d\n",  __LINE__, (int) e, (int) i);
   1141             logln(calToStr(*temp) + UnicodeString("  " ) + fieldName(e) + UnicodeString("--") );
   1142             temp->roll(e, -1, status);
   1143             if (U_FAILURE(status)) { errln(UnicodeString("GregorianCalendar::roll ") + CalendarTest::fieldName(e) + " count=" + UnicodeString('@'+i) + " by -1 failed with " + u_errorName(status) ); return; }
   1144         }
   1145         check520(temp, y, m, d, hr, min, sec, ms, e);
   1146 
   1147         e = (UCalendarDateFields) ((int32_t) e + 1);
   1148     }
   1149 
   1150     delete temp;
   1151 }
   1152 
   1153 // -------------------------------------
   1154 void
   1155 CalendarTest::check520(Calendar* c,
   1156                         int32_t y, int32_t m, int32_t d,
   1157                         int32_t hr, int32_t min, int32_t sec,
   1158                         int32_t ms, UCalendarDateFields field)
   1159 
   1160 {
   1161     UErrorCode status = U_ZERO_ERROR;
   1162     if (c->get(UCAL_YEAR, status) != y ||
   1163         c->get(UCAL_MONTH, status) != m ||
   1164         c->get(UCAL_DATE, status) != d ||
   1165         c->get(UCAL_HOUR, status) != hr ||
   1166         c->get(UCAL_MINUTE, status) != min ||
   1167         c->get(UCAL_SECOND, status) != sec ||
   1168         c->get(UCAL_MILLISECOND, status) != ms) {
   1169         errln(UnicodeString("U_FAILURE for field ") + (int32_t)field +
   1170                 ": Expected y/m/d h:m:s:ms of " +
   1171                 y + "/" + (m + 1) + "/" + d + " " +
   1172               hr + ":" + min + ":" + sec + ":" + ms +
   1173               "; got " + c->get(UCAL_YEAR, status) +
   1174               "/" + (c->get(UCAL_MONTH, status) + 1) +
   1175               "/" + c->get(UCAL_DATE, status) +
   1176               " " + c->get(UCAL_HOUR, status) + ":" +
   1177               c->get(UCAL_MINUTE, status) + ":" +
   1178               c->get(UCAL_SECOND, status) + ":" +
   1179               c->get(UCAL_MILLISECOND, status)
   1180               );
   1181 
   1182         if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
   1183     }
   1184     else
   1185         logln(UnicodeString("Confirmed: ") + y + "/" +
   1186                 (m + 1) + "/" + d + " " +
   1187                 hr + ":" + min + ":" + sec + ":" + ms);
   1188 }
   1189 
   1190 // -------------------------------------
   1191 void
   1192 CalendarTest::check520(Calendar* c,
   1193                         int32_t y, int32_t m, int32_t d)
   1194 
   1195 {
   1196     UErrorCode status = U_ZERO_ERROR;
   1197     if (c->get(UCAL_YEAR, status) != y ||
   1198         c->get(UCAL_MONTH, status) != m ||
   1199         c->get(UCAL_DATE, status) != d) {
   1200         errln(UnicodeString("FAILURE: Expected y/m/d of ") +
   1201               y + "/" + (m + 1) + "/" + d + " " +
   1202               "; got " + c->get(UCAL_YEAR, status) +
   1203               "/" + (c->get(UCAL_MONTH, status) + 1) +
   1204               "/" + c->get(UCAL_DATE, status)
   1205               );
   1206 
   1207         if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
   1208     }
   1209     else
   1210         logln(UnicodeString("Confirmed: ") + y + "/" +
   1211                 (m + 1) + "/" + d);
   1212 }
   1213 
   1214 // -------------------------------------
   1215 
   1216 /**
   1217  * Test that setting of fields works.  In particular, make sure that all instances
   1218  * of GregorianCalendar don't share a static instance of the fields array.
   1219  */
   1220 void
   1221 CalendarTest::TestFieldSet4781()
   1222 {
   1223     // try {
   1224         UErrorCode status = U_ZERO_ERROR;
   1225         GregorianCalendar *g = new GregorianCalendar(status);
   1226         if (failure(status, "new GregorianCalendar", TRUE)) return;
   1227         GregorianCalendar *g2 = new GregorianCalendar(status);
   1228         if (U_FAILURE(status)) { errln("Couldn't create GregorianCalendar"); return; }
   1229         g2->set(UCAL_HOUR, 12, status);
   1230         g2->set(UCAL_MINUTE, 0, status);
   1231         g2->set(UCAL_SECOND, 0, status);
   1232         if (U_FAILURE(status)) { errln("Calendar::set failed"); return; }
   1233         if (*g == *g2) logln("Same");
   1234         else logln("Different");
   1235     //}
   1236         //catch(IllegalArgumentException e) {
   1237         //errln("Unexpected exception seen: " + e);
   1238     //}
   1239         delete g;
   1240         delete g2;
   1241 }
   1242 
   1243 // -------------------------------------
   1244 
   1245 /* We don't support serialization on C++
   1246 void
   1247 CalendarTest::TestSerialize337()
   1248 {
   1249     Calendar cal = Calendar::getInstance();
   1250     UBool ok = FALSE;
   1251     try {
   1252         FileOutputStream f = new FileOutputStream(FILENAME);
   1253         ObjectOutput s = new ObjectOutputStream(f);
   1254         s.writeObject(PREFIX);
   1255         s.writeObject(cal);
   1256         s.writeObject(POSTFIX);
   1257         f.close();
   1258         FileInputStream in = new FileInputStream(FILENAME);
   1259         ObjectInputStream t = new ObjectInputStream(in);
   1260         UnicodeString& pre = (UnicodeString&) t.readObject();
   1261         Calendar c = (Calendar) t.readObject();
   1262         UnicodeString& post = (UnicodeString&) t.readObject();
   1263         in.close();
   1264         ok = pre.equals(PREFIX) &&
   1265             post.equals(POSTFIX) &&
   1266             cal->equals(c);
   1267         File fl = new File(FILENAME);
   1268         fl.delete();
   1269     }
   1270     catch(IOException e) {
   1271         errln("FAIL: Exception received:");
   1272         e.printStackTrace(log);
   1273     }
   1274     catch(ClassNotFoundException e) {
   1275         errln("FAIL: Exception received:");
   1276         e.printStackTrace(log);
   1277     }
   1278     if (!ok) errln("Serialization of Calendar object failed.");
   1279 }
   1280 
   1281 UnicodeString& CalendarTest::PREFIX = "abc";
   1282 
   1283 UnicodeString& CalendarTest::POSTFIX = "def";
   1284 
   1285 UnicodeString& CalendarTest::FILENAME = "tmp337.bin";
   1286  */
   1287 
   1288 // -------------------------------------
   1289 
   1290 /**
   1291  * Verify that the seconds of a Calendar can be zeroed out through the
   1292  * expected sequence of operations.
   1293  */
   1294 void
   1295 CalendarTest::TestSecondsZero121()
   1296 {
   1297     UErrorCode status = U_ZERO_ERROR;
   1298     Calendar *cal = new GregorianCalendar(status);
   1299     if (failure(status, "new GregorianCalendar", TRUE)) return;
   1300     cal->setTime(Calendar::getNow(), status);
   1301     if (U_FAILURE(status)) { errln("Calendar::setTime failed"); return; }
   1302     cal->set(UCAL_SECOND, 0);
   1303     if (U_FAILURE(status)) { errln("Calendar::set failed"); return; }
   1304     UDate d = cal->getTime(status);
   1305     if (U_FAILURE(status)) { errln("Calendar::getTime failed"); return; }
   1306     UnicodeString s;
   1307     dateToString(d, s);
   1308     if (s.indexOf("DATE_FORMAT_FAILURE") >= 0) {
   1309         dataerrln("Got: \"DATE_FORMAT_FAILURE\".");
   1310     } else if (s.indexOf(":00 ") < 0) {
   1311         errln("Expected to see :00 in " + s);
   1312     }
   1313     delete cal;
   1314 }
   1315 
   1316 // -------------------------------------
   1317 
   1318 /**
   1319  * Verify that a specific sequence of adding and setting works as expected;
   1320  * it should not vary depending on when and whether the get method is
   1321  * called.
   1322  */
   1323 void
   1324 CalendarTest::TestAddSetGet0610()
   1325 {
   1326     UnicodeString EXPECTED_0610("1993/0/5", "");
   1327     UErrorCode status = U_ZERO_ERROR;
   1328     {
   1329         Calendar *calendar = new GregorianCalendar(status);
   1330         if (failure(status, "new GregorianCalendar", TRUE)) return;
   1331         calendar->set(1993, UCAL_JANUARY, 4);
   1332         logln("1A) " + value(calendar));
   1333         calendar->add(UCAL_DATE, 1, status);
   1334         if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
   1335         UnicodeString v = value(calendar);
   1336         logln("1B) " + v);
   1337         logln("--) 1993/0/5");
   1338         if (!(v == EXPECTED_0610)) errln("Expected " + EXPECTED_0610 + "; saw " + v);
   1339         delete calendar;
   1340     }
   1341     {
   1342         Calendar *calendar = new GregorianCalendar(1993, UCAL_JANUARY, 4, status);
   1343         if (U_FAILURE(status)) { errln("Couldn't create GregorianCalendar"); return; }
   1344         logln("2A) " + value(calendar));
   1345         calendar->add(UCAL_DATE, 1, status);
   1346         if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
   1347         UnicodeString v = value(calendar);
   1348         logln("2B) " + v);
   1349         logln("--) 1993/0/5");
   1350         if (!(v == EXPECTED_0610)) errln("Expected " + EXPECTED_0610 + "; saw " + v);
   1351         delete calendar;
   1352     }
   1353     {
   1354         Calendar *calendar = new GregorianCalendar(1993, UCAL_JANUARY, 4, status);
   1355         if (U_FAILURE(status)) { errln("Couldn't create GregorianCalendar"); return; }
   1356         logln("3A) " + value(calendar));
   1357         calendar->getTime(status);
   1358         if (U_FAILURE(status)) { errln("Calendar::getTime failed"); return; }
   1359         calendar->add(UCAL_DATE, 1, status);
   1360         if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
   1361         UnicodeString v = value(calendar);
   1362         logln("3B) " + v);
   1363         logln("--) 1993/0/5");
   1364         if (!(v == EXPECTED_0610)) errln("Expected " + EXPECTED_0610 + "; saw " + v);
   1365         delete calendar;
   1366     }
   1367 }
   1368 
   1369 // -------------------------------------
   1370 
   1371 UnicodeString
   1372 CalendarTest::value(Calendar* calendar)
   1373 {
   1374     UErrorCode status = U_ZERO_ERROR;
   1375     return UnicodeString("") + (int32_t)calendar->get(UCAL_YEAR, status) +
   1376         "/" + (int32_t)calendar->get(UCAL_MONTH, status) +
   1377         "/" + (int32_t)calendar->get(UCAL_DATE, status) +
   1378         (U_FAILURE(status) ? " FAIL: Calendar::get failed" : "");
   1379 }
   1380 
   1381 
   1382 // -------------------------------------
   1383 
   1384 /**
   1385  * Verify that various fields on a known date are set correctly.
   1386  */
   1387 void
   1388 CalendarTest::TestFields060()
   1389 {
   1390     UErrorCode status = U_ZERO_ERROR;
   1391     int32_t year = 1997;
   1392     int32_t month = UCAL_OCTOBER;
   1393     int32_t dDate = 22;
   1394     GregorianCalendar *calendar = 0;
   1395     calendar = new GregorianCalendar(year, month, dDate, status);
   1396     if (failure(status, "new GregorianCalendar", TRUE)) return;
   1397     for (int32_t i = 0; i < EXPECTED_FIELDS_length;) {
   1398         UCalendarDateFields field = (UCalendarDateFields)EXPECTED_FIELDS[i++];
   1399         int32_t expected = EXPECTED_FIELDS[i++];
   1400         if (calendar->get(field, status) != expected) {
   1401             errln(UnicodeString("Expected field ") + (int32_t)field + " to have value " + (int32_t)expected +
   1402                   "; received " + (int32_t)calendar->get(field, status) + " instead");
   1403             if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
   1404         }
   1405     }
   1406     delete calendar;
   1407 }
   1408 
   1409 int32_t CalendarTest::EXPECTED_FIELDS[] = {
   1410     UCAL_YEAR, 1997,
   1411     UCAL_MONTH, UCAL_OCTOBER,
   1412     UCAL_DATE, 22,
   1413     UCAL_DAY_OF_WEEK, UCAL_WEDNESDAY,
   1414     UCAL_DAY_OF_WEEK_IN_MONTH, 4,
   1415     UCAL_DAY_OF_YEAR, 295
   1416 };
   1417 
   1418 const int32_t CalendarTest::EXPECTED_FIELDS_length = (int32_t)(sizeof(CalendarTest::EXPECTED_FIELDS) /
   1419     sizeof(CalendarTest::EXPECTED_FIELDS[0]));
   1420 
   1421 // -------------------------------------
   1422 
   1423 /**
   1424  * Verify that various fields on a known date are set correctly.  In this
   1425  * case, the start of the epoch (January 1 1970).
   1426  */
   1427 void
   1428 CalendarTest::TestEpochStartFields()
   1429 {
   1430     UErrorCode status = U_ZERO_ERROR;
   1431     TimeZone *z = TimeZone::createDefault();
   1432     Calendar *c = Calendar::createInstance(status);
   1433     if (failure(status, "Calendar::createInstance", TRUE)) return;
   1434     UDate d = - z->getRawOffset();
   1435     GregorianCalendar *gc = new GregorianCalendar(status);
   1436     if (U_FAILURE(status)) { errln("Couldn't create GregorianCalendar"); return; }
   1437     gc->setTimeZone(*z);
   1438     gc->setTime(d, status);
   1439     if (U_FAILURE(status)) { errln("Calendar::setTime failed"); return; }
   1440     UBool idt = gc->inDaylightTime(status);
   1441     if (U_FAILURE(status)) { errln("GregorianCalendar::inDaylightTime failed"); return; }
   1442     if (idt) {
   1443         UnicodeString str;
   1444         logln("Warning: Skipping test because " + dateToString(d, str) + " is in DST.");
   1445     }
   1446     else {
   1447         c->setTime(d, status);
   1448         if (U_FAILURE(status)) { errln("Calendar::setTime failed"); return; }
   1449         for (int32_t i = 0; i < UCAL_ZONE_OFFSET;++i) {
   1450             if (c->get((UCalendarDateFields)i, status) != EPOCH_FIELDS[i])
   1451                 dataerrln(UnicodeString("Expected field ") + i + " to have value " + EPOCH_FIELDS[i] +
   1452                       "; saw " + c->get((UCalendarDateFields)i, status) + " instead");
   1453             if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
   1454         }
   1455         if (c->get(UCAL_ZONE_OFFSET, status) != z->getRawOffset())
   1456         {
   1457             errln(UnicodeString("Expected field ZONE_OFFSET to have value ") + z->getRawOffset() +
   1458                   "; saw " + c->get(UCAL_ZONE_OFFSET, status) + " instead");
   1459             if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
   1460         }
   1461         if (c->get(UCAL_DST_OFFSET, status) != 0)
   1462         {
   1463             errln(UnicodeString("Expected field DST_OFFSET to have value 0") +
   1464                   "; saw " + c->get(UCAL_DST_OFFSET, status) + " instead");
   1465             if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
   1466         }
   1467     }
   1468     delete c;
   1469     delete z;
   1470     delete gc;
   1471 }
   1472 
   1473 int32_t CalendarTest::EPOCH_FIELDS[] = {
   1474     1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, - 28800000, 0
   1475 };
   1476 
   1477 // -------------------------------------
   1478 
   1479 /**
   1480  * Test that the days of the week progress properly when add is called repeatedly
   1481  * for increments of 24 days.
   1482  */
   1483 void
   1484 CalendarTest::TestDOWProgression()
   1485 {
   1486     UErrorCode status = U_ZERO_ERROR;
   1487     Calendar *cal = new GregorianCalendar(1972, UCAL_OCTOBER, 26, status);
   1488     if (failure(status, "new GregorianCalendar", TRUE)) return;
   1489     marchByDelta(cal, 24);
   1490     delete cal;
   1491 }
   1492 
   1493 // -------------------------------------
   1494 
   1495 void
   1496 CalendarTest::TestDOW_LOCALandYEAR_WOY()
   1497 {
   1498     /* Note: I've commented out the loop_addroll tests for YEAR and
   1499      * YEAR_WOY below because these two fields should NOT behave
   1500      * identically when adding.  YEAR should keep the month/dom
   1501      * invariant.  YEAR_WOY should keep the woy/dow invariant.  I've
   1502      * added a new test that checks for this in place of the old call
   1503      * to loop_addroll. - aliu */
   1504     UErrorCode status = U_ZERO_ERROR;
   1505     int32_t times = 20;
   1506     Calendar *cal=Calendar::createInstance(Locale::getGermany(), status);
   1507     if (failure(status, "Calendar::createInstance", TRUE)) return;
   1508     SimpleDateFormat *sdf=new SimpleDateFormat(UnicodeString("YYYY'-W'ww-ee"), Locale::getGermany(), status);
   1509     if (U_FAILURE(status)) { dataerrln("Couldn't create SimpleDateFormat - %s", u_errorName(status)); return; }
   1510 
   1511     // ICU no longer use localized date-time pattern characters by default.
   1512     // So we set pattern chars using 'J' instead of 'Y'.
   1513     DateFormatSymbols *dfs = new DateFormatSymbols(Locale::getGermany(), status);
   1514     dfs->setLocalPatternChars(UnicodeString("GyMdkHmsSEDFwWahKzJeugAZvcLQq"));
   1515     sdf->adoptDateFormatSymbols(dfs);
   1516     sdf->applyLocalizedPattern(UnicodeString("JJJJ'-W'ww-ee"), status);
   1517     if (U_FAILURE(status)) { errln("Couldn't apply localized pattern"); return; }
   1518 
   1519     cal->clear();
   1520     cal->set(1997, UCAL_DECEMBER, 25);
   1521     doYEAR_WOYLoop(cal, sdf, times, status);
   1522     //loop_addroll(cal, /*sdf,*/ times, UCAL_YEAR_WOY, UCAL_YEAR,  status);
   1523     yearAddTest(*cal, status); // aliu
   1524     loop_addroll(cal, /*sdf,*/ times, UCAL_DOW_LOCAL, UCAL_DAY_OF_WEEK, status);
   1525     if (U_FAILURE(status)) { errln("Error in parse/calculate test for 1997"); return; }
   1526 
   1527     cal->clear();
   1528     cal->set(1998, UCAL_DECEMBER, 25);
   1529     doYEAR_WOYLoop(cal, sdf, times, status);
   1530     //loop_addroll(cal, /*sdf,*/ times, UCAL_YEAR_WOY, UCAL_YEAR,  status);
   1531     yearAddTest(*cal, status); // aliu
   1532     loop_addroll(cal, /*sdf,*/ times, UCAL_DOW_LOCAL, UCAL_DAY_OF_WEEK, status);
   1533     if (U_FAILURE(status)) { errln("Error in parse/calculate test for 1998"); return; }
   1534 
   1535     cal->clear();
   1536     cal->set(1582, UCAL_OCTOBER, 1);
   1537     doYEAR_WOYLoop(cal, sdf, times, status);
   1538     //loop_addroll(cal, /*sdf,*/ times, Calendar::YEAR_WOY, Calendar::YEAR,  status);
   1539     yearAddTest(*cal, status); // aliu
   1540     loop_addroll(cal, /*sdf,*/ times, UCAL_DOW_LOCAL, UCAL_DAY_OF_WEEK, status);
   1541     if (U_FAILURE(status)) { errln("Error in parse/calculate test for 1582"); return; }
   1542     delete sdf;
   1543     delete cal;
   1544 
   1545     return;
   1546 }
   1547 
   1548 /**
   1549  * Confirm that adding a YEAR and adding a YEAR_WOY work properly for
   1550  * the given Calendar at its current setting.
   1551  */
   1552 void CalendarTest::yearAddTest(Calendar& cal, UErrorCode& status) {
   1553     /**
   1554      * When adding the YEAR, the month and day should remain constant.
   1555      * When adding the YEAR_WOY, the WOY and DOW should remain constant. - aliu
   1556      * Examples:
   1557      *  Wed Jan 14 1998 / 1998-W03-03 Add(YEAR_WOY, 1) -> Wed Jan 20 1999 / 1999-W03-03
   1558      *                                Add(YEAR, 1)     -> Thu Jan 14 1999 / 1999-W02-04
   1559      *  Thu Jan 14 1999 / 1999-W02-04 Add(YEAR_WOY, 1) -> Thu Jan 13 2000 / 2000-W02-04
   1560      *                                Add(YEAR, 1)     -> Fri Jan 14 2000 / 2000-W02-05
   1561      *  Sun Oct 31 1582 / 1582-W42-07 Add(YEAR_WOY, 1) -> Sun Oct 23 1583 / 1583-W42-07
   1562      *                                Add(YEAR, 1)     -> Mon Oct 31 1583 / 1583-W44-01
   1563      */
   1564     int32_t y   = cal.get(UCAL_YEAR, status);
   1565     int32_t mon = cal.get(UCAL_MONTH, status);
   1566     int32_t day = cal.get(UCAL_DATE, status);
   1567     int32_t ywy = cal.get(UCAL_YEAR_WOY, status);
   1568     int32_t woy = cal.get(UCAL_WEEK_OF_YEAR, status);
   1569     int32_t dow = cal.get(UCAL_DOW_LOCAL, status);
   1570     UDate t = cal.getTime(status);
   1571 
   1572     if(U_FAILURE(status)){
   1573         errln(UnicodeString("Failed to create Calendar for locale. Error: ") + UnicodeString(u_errorName(status)));
   1574         return;
   1575     }
   1576     UnicodeString str, str2;
   1577     SimpleDateFormat fmt(UnicodeString("EEE MMM dd yyyy / YYYY'-W'ww-ee"), status);
   1578     fmt.setCalendar(cal);
   1579 
   1580     fmt.format(t, str.remove());
   1581     str += ".add(YEAR, 1)    =>";
   1582     cal.add(UCAL_YEAR, 1, status);
   1583     int32_t y2   = cal.get(UCAL_YEAR, status);
   1584     int32_t mon2 = cal.get(UCAL_MONTH, status);
   1585     int32_t day2 = cal.get(UCAL_DATE, status);
   1586     fmt.format(cal.getTime(status), str);
   1587     if (y2 != (y+1) || mon2 != mon || day2 != day) {
   1588         str += (UnicodeString)", expected year " +
   1589             (y+1) + ", month " + (mon+1) + ", day " + day;
   1590         errln((UnicodeString)"FAIL: " + str);
   1591         logln( UnicodeString(" -> ") + CalendarTest::calToStr(cal) );
   1592     } else {
   1593         logln(str);
   1594     }
   1595 
   1596     fmt.format(t, str.remove());
   1597     str += ".add(YEAR_WOY, 1)=>";
   1598     cal.setTime(t, status);
   1599     logln( UnicodeString(" <- ") + CalendarTest::calToStr(cal) );
   1600     cal.add(UCAL_YEAR_WOY, 1, status);
   1601     int32_t ywy2 = cal.get(UCAL_YEAR_WOY, status);
   1602     int32_t woy2 = cal.get(UCAL_WEEK_OF_YEAR, status);
   1603     int32_t dow2 = cal.get(UCAL_DOW_LOCAL, status);
   1604     fmt.format(cal.getTime(status), str);
   1605     if (ywy2 != (ywy+1) || woy2 != woy || dow2 != dow) {
   1606         str += (UnicodeString)", expected yearWOY " +
   1607             (ywy+1) + ", woy " + woy + ", dowLocal " + dow;
   1608         errln((UnicodeString)"FAIL: " + str);
   1609         logln( UnicodeString(" -> ") + CalendarTest::calToStr(cal) );
   1610     } else {
   1611         logln(str);
   1612     }
   1613 }
   1614 
   1615 // -------------------------------------
   1616 
   1617 void CalendarTest::loop_addroll(Calendar *cal, /*SimpleDateFormat *sdf,*/ int times, UCalendarDateFields field, UCalendarDateFields field2, UErrorCode& errorCode) {
   1618     Calendar *calclone;
   1619     SimpleDateFormat fmt(UnicodeString("EEE MMM dd yyyy / YYYY'-W'ww-ee"), errorCode);
   1620     fmt.setCalendar(*cal);
   1621     int i;
   1622 
   1623     for(i = 0; i<times; i++) {
   1624         calclone = cal->clone();
   1625         UDate start = cal->getTime(errorCode);
   1626         cal->add(field,1,errorCode);
   1627         if (U_FAILURE(errorCode)) { errln("Error in add"); delete calclone; return; }
   1628         calclone->add(field2,1,errorCode);
   1629         if (U_FAILURE(errorCode)) { errln("Error in add"); delete calclone; return; }
   1630         if(cal->getTime(errorCode) != calclone->getTime(errorCode)) {
   1631             UnicodeString str("FAIL: Results of add differ. "), str2;
   1632             str += fmt.format(start, str2) + " ";
   1633             str += UnicodeString("Add(") + fieldName(field) + ", 1) -> " +
   1634                 fmt.format(cal->getTime(errorCode), str2.remove()) + "; ";
   1635             str += UnicodeString("Add(") + fieldName(field2) + ", 1) -> " +
   1636                 fmt.format(calclone->getTime(errorCode), str2.remove());
   1637             errln(str);
   1638             delete calclone;
   1639             return;
   1640         }
   1641         delete calclone;
   1642     }
   1643 
   1644     for(i = 0; i<times; i++) {
   1645         calclone = cal->clone();
   1646         cal->roll(field,(int32_t)1,errorCode);
   1647         if (U_FAILURE(errorCode)) { errln("Error in roll"); delete calclone; return; }
   1648         calclone->roll(field2,(int32_t)1,errorCode);
   1649         if (U_FAILURE(errorCode)) { errln("Error in roll"); delete calclone; return; }
   1650         if(cal->getTime(errorCode) != calclone->getTime(errorCode)) {
   1651             delete calclone;
   1652             errln("Results of roll differ!");
   1653             return;
   1654         }
   1655         delete calclone;
   1656     }
   1657 }
   1658 
   1659 // -------------------------------------
   1660 
   1661 void
   1662 CalendarTest::doYEAR_WOYLoop(Calendar *cal, SimpleDateFormat *sdf,
   1663                                     int32_t times, UErrorCode& errorCode) {
   1664 
   1665     UnicodeString us;
   1666     UDate tst, original;
   1667     Calendar *tstres = new GregorianCalendar(Locale::getGermany(), errorCode);
   1668     for(int i=0; i<times; ++i) {
   1669         sdf->format(Formattable(cal->getTime(errorCode),Formattable::kIsDate), us, errorCode);
   1670         //logln("expected: "+us);
   1671         if (U_FAILURE(errorCode)) { errln("Format error"); return; }
   1672         tst=sdf->parse(us,errorCode);
   1673         if (U_FAILURE(errorCode)) { errln("Parse error"); return; }
   1674         tstres->clear();
   1675         tstres->setTime(tst, errorCode);
   1676         //logln((UnicodeString)"Parsed week of year is "+tstres->get(UCAL_WEEK_OF_YEAR, errorCode));
   1677         if (U_FAILURE(errorCode)) { errln("Set time error"); return; }
   1678         original = cal->getTime(errorCode);
   1679         us.remove();
   1680         sdf->format(Formattable(tst,Formattable::kIsDate), us, errorCode);
   1681         //logln("got: "+us);
   1682         if (U_FAILURE(errorCode)) { errln("Get time error"); return; }
   1683         if(original!=tst) {
   1684             us.remove();
   1685             sdf->format(Formattable(original, Formattable::kIsDate), us, errorCode);
   1686             errln("FAIL: Parsed time doesn't match with regular");
   1687             logln("expected "+us + " " + calToStr(*cal));
   1688             us.remove();
   1689             sdf->format(Formattable(tst, Formattable::kIsDate), us, errorCode);
   1690             logln("got "+us + " " + calToStr(*tstres));
   1691         }
   1692         tstres->clear();
   1693         tstres->set(UCAL_YEAR_WOY, cal->get(UCAL_YEAR_WOY, errorCode));
   1694         tstres->set(UCAL_WEEK_OF_YEAR, cal->get(UCAL_WEEK_OF_YEAR, errorCode));
   1695         tstres->set(UCAL_DOW_LOCAL, cal->get(UCAL_DOW_LOCAL, errorCode));
   1696         if(cal->get(UCAL_YEAR, errorCode) != tstres->get(UCAL_YEAR, errorCode)) {
   1697             errln("FAIL: Different Year!");
   1698             logln((UnicodeString)"Expected "+cal->get(UCAL_YEAR, errorCode));
   1699             logln((UnicodeString)"Got "+tstres->get(UCAL_YEAR, errorCode));
   1700             return;
   1701         }
   1702         if(cal->get(UCAL_DAY_OF_YEAR, errorCode) != tstres->get(UCAL_DAY_OF_YEAR, errorCode)) {
   1703             errln("FAIL: Different Day Of Year!");
   1704             logln((UnicodeString)"Expected "+cal->get(UCAL_DAY_OF_YEAR, errorCode));
   1705             logln((UnicodeString)"Got "+tstres->get(UCAL_DAY_OF_YEAR, errorCode));
   1706             return;
   1707         }
   1708         //logln(calToStr(*cal));
   1709         cal->add(UCAL_DATE, 1, errorCode);
   1710         if (U_FAILURE(errorCode)) { errln("Add error"); return; }
   1711         us.remove();
   1712     }
   1713     delete (tstres);
   1714 }
   1715 // -------------------------------------
   1716 
   1717 void
   1718 CalendarTest::marchByDelta(Calendar* cal, int32_t delta)
   1719 {
   1720     UErrorCode status = U_ZERO_ERROR;
   1721     Calendar *cur = (Calendar*) cal->clone();
   1722     int32_t initialDOW = cur->get(UCAL_DAY_OF_WEEK, status);
   1723     if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
   1724     int32_t DOW, newDOW = initialDOW;
   1725     do {
   1726         UnicodeString str;
   1727         DOW = newDOW;
   1728         logln(UnicodeString("DOW = ") + DOW + "  " + dateToString(cur->getTime(status), str));
   1729         if (U_FAILURE(status)) { errln("Calendar::getTime failed"); return; }
   1730         cur->add(UCAL_DAY_OF_WEEK, delta, status);
   1731         if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
   1732         newDOW = cur->get(UCAL_DAY_OF_WEEK, status);
   1733         if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
   1734         int32_t expectedDOW = 1 + (DOW + delta - 1) % 7;
   1735         if (newDOW != expectedDOW) {
   1736             errln(UnicodeString("Day of week should be ") + expectedDOW + " instead of " + newDOW +
   1737                   " on " + dateToString(cur->getTime(status), str));
   1738             if (U_FAILURE(status)) { errln("Calendar::getTime failed"); return; }
   1739             return;
   1740         }
   1741     }
   1742     while (newDOW != initialDOW);
   1743     delete cur;
   1744 }
   1745 
   1746 #define CHECK(status, msg) \
   1747     if (U_FAILURE(status)) { \
   1748         errcheckln(status, msg); \
   1749         return; \
   1750     }
   1751 
   1752 void CalendarTest::TestWOY(void) {
   1753     /*
   1754       FDW = Mon, MDFW = 4:
   1755          Sun Dec 26 1999, WOY 51
   1756          Mon Dec 27 1999, WOY 52
   1757          Tue Dec 28 1999, WOY 52
   1758          Wed Dec 29 1999, WOY 52
   1759          Thu Dec 30 1999, WOY 52
   1760          Fri Dec 31 1999, WOY 52
   1761          Sat Jan 01 2000, WOY 52 ***
   1762          Sun Jan 02 2000, WOY 52 ***
   1763          Mon Jan 03 2000, WOY 1
   1764          Tue Jan 04 2000, WOY 1
   1765          Wed Jan 05 2000, WOY 1
   1766          Thu Jan 06 2000, WOY 1
   1767          Fri Jan 07 2000, WOY 1
   1768          Sat Jan 08 2000, WOY 1
   1769          Sun Jan 09 2000, WOY 1
   1770          Mon Jan 10 2000, WOY 2
   1771 
   1772       FDW = Mon, MDFW = 2:
   1773          Sun Dec 26 1999, WOY 52
   1774          Mon Dec 27 1999, WOY 1  ***
   1775          Tue Dec 28 1999, WOY 1  ***
   1776          Wed Dec 29 1999, WOY 1  ***
   1777          Thu Dec 30 1999, WOY 1  ***
   1778          Fri Dec 31 1999, WOY 1  ***
   1779          Sat Jan 01 2000, WOY 1
   1780          Sun Jan 02 2000, WOY 1
   1781          Mon Jan 03 2000, WOY 2
   1782          Tue Jan 04 2000, WOY 2
   1783          Wed Jan 05 2000, WOY 2
   1784          Thu Jan 06 2000, WOY 2
   1785          Fri Jan 07 2000, WOY 2
   1786          Sat Jan 08 2000, WOY 2
   1787          Sun Jan 09 2000, WOY 2
   1788          Mon Jan 10 2000, WOY 3
   1789     */
   1790 
   1791     UnicodeString str;
   1792     UErrorCode status = U_ZERO_ERROR;
   1793     int32_t i;
   1794 
   1795     GregorianCalendar cal(status);
   1796     SimpleDateFormat fmt(UnicodeString("EEE MMM dd yyyy', WOY' w"), status);
   1797     if (failure(status, "Cannot construct calendar/format", TRUE)) return;
   1798 
   1799     UCalendarDaysOfWeek fdw = (UCalendarDaysOfWeek) 0;
   1800 
   1801     //for (int8_t pass=2; pass<=2; ++pass) {
   1802     for (int8_t pass=1; pass<=2; ++pass) {
   1803         switch (pass) {
   1804         case 1:
   1805             fdw = UCAL_MONDAY;
   1806             cal.setFirstDayOfWeek(fdw);
   1807             cal.setMinimalDaysInFirstWeek(4);
   1808             fmt.adoptCalendar(cal.clone());
   1809             break;
   1810         case 2:
   1811             fdw = UCAL_MONDAY;
   1812             cal.setFirstDayOfWeek(fdw);
   1813             cal.setMinimalDaysInFirstWeek(2);
   1814             fmt.adoptCalendar(cal.clone());
   1815             break;
   1816         }
   1817 
   1818         //for (i=2; i<=6; ++i) {
   1819         for (i=0; i<16; ++i) {
   1820         UDate t, t2;
   1821         int32_t t_y, t_woy, t_dow;
   1822         cal.clear();
   1823         cal.set(1999, UCAL_DECEMBER, 26 + i);
   1824         fmt.format(t = cal.getTime(status), str.remove());
   1825         CHECK(status, "Fail: getTime failed");
   1826         logln(UnicodeString("* ") + str);
   1827         int32_t dow = cal.get(UCAL_DAY_OF_WEEK, status);
   1828         int32_t woy = cal.get(UCAL_WEEK_OF_YEAR, status);
   1829         int32_t year = cal.get(UCAL_YEAR, status);
   1830         int32_t mon = cal.get(UCAL_MONTH, status);
   1831         logln(calToStr(cal));
   1832         CHECK(status, "Fail: get failed");
   1833         int32_t dowLocal = dow - fdw;
   1834         if (dowLocal < 0) dowLocal += 7;
   1835         dowLocal++;
   1836         int32_t yearWoy = year;
   1837         if (mon == UCAL_JANUARY) {
   1838             if (woy >= 52) --yearWoy;
   1839         } else {
   1840             if (woy == 1) ++yearWoy;
   1841         }
   1842 
   1843         // Basic fields->time check y/woy/dow
   1844         // Since Y/WOY is ambiguous, we do a check of the fields,
   1845         // not of the specific time.
   1846         cal.clear();
   1847         cal.set(UCAL_YEAR, year);
   1848         cal.set(UCAL_WEEK_OF_YEAR, woy);
   1849         cal.set(UCAL_DAY_OF_WEEK, dow);
   1850         t_y = cal.get(UCAL_YEAR, status);
   1851         t_woy = cal.get(UCAL_WEEK_OF_YEAR, status);
   1852         t_dow = cal.get(UCAL_DAY_OF_WEEK, status);
   1853         CHECK(status, "Fail: get failed");
   1854         if (t_y != year || t_woy != woy || t_dow != dow) {
   1855             str = "Fail: y/woy/dow fields->time => ";
   1856             fmt.format(cal.getTime(status), str);
   1857             errln(str);
   1858             logln(calToStr(cal));
   1859             logln("[get!=set] Y%d!=%d || woy%d!=%d || dow%d!=%d\n",
   1860                   t_y, year, t_woy, woy, t_dow, dow);
   1861         } else {
   1862           logln("y/woy/dow fields->time OK");
   1863         }
   1864 
   1865         // Basic fields->time check y/woy/dow_local
   1866         // Since Y/WOY is ambiguous, we do a check of the fields,
   1867         // not of the specific time.
   1868         cal.clear();
   1869         cal.set(UCAL_YEAR, year);
   1870         cal.set(UCAL_WEEK_OF_YEAR, woy);
   1871         cal.set(UCAL_DOW_LOCAL, dowLocal);
   1872         t_y = cal.get(UCAL_YEAR, status);
   1873         t_woy = cal.get(UCAL_WEEK_OF_YEAR, status);
   1874         t_dow = cal.get(UCAL_DOW_LOCAL, status);
   1875         CHECK(status, "Fail: get failed");
   1876         if (t_y != year || t_woy != woy || t_dow != dowLocal) {
   1877             str = "Fail: y/woy/dow_local fields->time => ";
   1878             fmt.format(cal.getTime(status), str);
   1879             errln(str);
   1880         }
   1881 
   1882         // Basic fields->time check y_woy/woy/dow
   1883         cal.clear();
   1884         cal.set(UCAL_YEAR_WOY, yearWoy);
   1885         cal.set(UCAL_WEEK_OF_YEAR, woy);
   1886         cal.set(UCAL_DAY_OF_WEEK, dow);
   1887         t2 = cal.getTime(status);
   1888         CHECK(status, "Fail: getTime failed");
   1889         if (t != t2) {
   1890             str = "Fail: y_woy/woy/dow fields->time => ";
   1891             fmt.format(t2, str);
   1892             errln(str);
   1893             logln(calToStr(cal));
   1894             logln("%.f != %.f\n", t, t2);
   1895         } else {
   1896           logln("y_woy/woy/dow OK");
   1897         }
   1898 
   1899         // Basic fields->time check y_woy/woy/dow_local
   1900         cal.clear();
   1901         cal.set(UCAL_YEAR_WOY, yearWoy);
   1902         cal.set(UCAL_WEEK_OF_YEAR, woy);
   1903         cal.set(UCAL_DOW_LOCAL, dowLocal);
   1904         t2 = cal.getTime(status);
   1905         CHECK(status, "Fail: getTime failed");
   1906         if (t != t2) {
   1907             str = "Fail: y_woy/woy/dow_local fields->time => ";
   1908             fmt.format(t2, str);
   1909             errln(str);
   1910         }
   1911 
   1912         logln("Testing DOW_LOCAL.. dow%d\n", dow);
   1913         // Make sure DOW_LOCAL disambiguates over DOW
   1914         int32_t wrongDow = dow - 3;
   1915         if (wrongDow < 1) wrongDow += 7;
   1916         cal.setTime(t, status);
   1917         cal.set(UCAL_DAY_OF_WEEK, wrongDow);
   1918         cal.set(UCAL_DOW_LOCAL, dowLocal);
   1919         t2 = cal.getTime(status);
   1920         CHECK(status, "Fail: set/getTime failed");
   1921         if (t != t2) {
   1922             str = "Fail: DOW_LOCAL fields->time => ";
   1923             fmt.format(t2, str);
   1924             errln(str);
   1925             logln(calToStr(cal));
   1926             logln("%.f :   DOW%d, DOW_LOCAL%d -> %.f\n",
   1927                   t, wrongDow, dowLocal, t2);
   1928         }
   1929 
   1930         // Make sure DOW disambiguates over DOW_LOCAL
   1931         int32_t wrongDowLocal = dowLocal - 3;
   1932         if (wrongDowLocal < 1) wrongDowLocal += 7;
   1933         cal.setTime(t, status);
   1934         cal.set(UCAL_DOW_LOCAL, wrongDowLocal);
   1935         cal.set(UCAL_DAY_OF_WEEK, dow);
   1936         t2 = cal.getTime(status);
   1937         CHECK(status, "Fail: set/getTime failed");
   1938         if (t != t2) {
   1939             str = "Fail: DOW       fields->time => ";
   1940             fmt.format(t2, str);
   1941             errln(str);
   1942         }
   1943 
   1944         // Make sure YEAR_WOY disambiguates over YEAR
   1945         cal.setTime(t, status);
   1946         cal.set(UCAL_YEAR, year - 2);
   1947         cal.set(UCAL_YEAR_WOY, yearWoy);
   1948         t2 = cal.getTime(status);
   1949         CHECK(status, "Fail: set/getTime failed");
   1950         if (t != t2) {
   1951             str = "Fail: YEAR_WOY  fields->time => ";
   1952             fmt.format(t2, str);
   1953             errln(str);
   1954         }
   1955 
   1956         // Make sure YEAR disambiguates over YEAR_WOY
   1957         cal.setTime(t, status);
   1958         cal.set(UCAL_YEAR_WOY, yearWoy - 2);
   1959         cal.set(UCAL_YEAR, year);
   1960         t2 = cal.getTime(status);
   1961         CHECK(status, "Fail: set/getTime failed");
   1962         if (t != t2) {
   1963             str = "Fail: YEAR      fields->time => ";
   1964             fmt.format(t2, str);
   1965             errln(str);
   1966         }
   1967     }
   1968     }
   1969 
   1970     /*
   1971       FDW = Mon, MDFW = 4:
   1972          Sun Dec 26 1999, WOY 51
   1973          Mon Dec 27 1999, WOY 52
   1974          Tue Dec 28 1999, WOY 52
   1975          Wed Dec 29 1999, WOY 52
   1976          Thu Dec 30 1999, WOY 52
   1977          Fri Dec 31 1999, WOY 52
   1978          Sat Jan 01 2000, WOY 52
   1979          Sun Jan 02 2000, WOY 52
   1980     */
   1981 
   1982     // Roll the DOW_LOCAL within week 52
   1983     for (i=27; i<=33; ++i) {
   1984         int32_t amount;
   1985         for (amount=-7; amount<=7; ++amount) {
   1986             str = "roll(";
   1987             cal.set(1999, UCAL_DECEMBER, i);
   1988             UDate t, t2;
   1989             fmt.format(cal.getTime(status), str);
   1990             CHECK(status, "Fail: getTime failed");
   1991             str += UnicodeString(", ") + amount + ") = ";
   1992 
   1993             cal.roll(UCAL_DOW_LOCAL, amount, status);
   1994             CHECK(status, "Fail: roll failed");
   1995 
   1996             t = cal.getTime(status);
   1997             int32_t newDom = i + amount;
   1998             while (newDom < 27) newDom += 7;
   1999             while (newDom > 33) newDom -= 7;
   2000             cal.set(1999, UCAL_DECEMBER, newDom);
   2001             t2 = cal.getTime(status);
   2002             CHECK(status, "Fail: getTime failed");
   2003             fmt.format(t, str);
   2004 
   2005             if (t != t2) {
   2006                 str.append(", exp ");
   2007                 fmt.format(t2, str);
   2008                 errln(str);
   2009             } else {
   2010                 logln(str);
   2011             }
   2012         }
   2013     }
   2014 }
   2015 
   2016 void CalendarTest::TestYWOY()
   2017 {
   2018    UnicodeString str;
   2019    UErrorCode status = U_ZERO_ERROR;
   2020 
   2021    GregorianCalendar cal(status);
   2022    if (failure(status, "construct GregorianCalendar", TRUE)) return;
   2023 
   2024    cal.setFirstDayOfWeek(UCAL_SUNDAY);
   2025    cal.setMinimalDaysInFirstWeek(1);
   2026 
   2027    logln("Setting:  ywoy=2004, woy=1, dow=MONDAY");
   2028    cal.clear();
   2029    cal.set(UCAL_YEAR_WOY,2004);
   2030    cal.set(UCAL_WEEK_OF_YEAR,1);
   2031    cal.set(UCAL_DAY_OF_WEEK, UCAL_MONDAY);
   2032 
   2033    logln(calToStr(cal));
   2034    if(cal.get(UCAL_YEAR, status) != 2003) {
   2035      errln("year not 2003");
   2036    }
   2037 
   2038    logln("+ setting DOW to THURSDAY");
   2039    cal.clear();
   2040    cal.set(UCAL_YEAR_WOY,2004);
   2041    cal.set(UCAL_WEEK_OF_YEAR,1);
   2042    cal.set(UCAL_DAY_OF_WEEK, UCAL_THURSDAY);
   2043 
   2044    logln(calToStr(cal));
   2045    if(cal.get(UCAL_YEAR, status) != 2004) {
   2046      errln("year not 2004");
   2047    }
   2048 
   2049    logln("+ setting DOW_LOCAL to 1");
   2050    cal.clear();
   2051    cal.set(UCAL_YEAR_WOY,2004);
   2052    cal.set(UCAL_WEEK_OF_YEAR,1);
   2053    cal.set(UCAL_DAY_OF_WEEK, UCAL_THURSDAY);
   2054    cal.set(UCAL_DOW_LOCAL, 1);
   2055 
   2056    logln(calToStr(cal));
   2057    if(cal.get(UCAL_YEAR, status) != 2003) {
   2058      errln("year not 2003");
   2059    }
   2060 
   2061    cal.setFirstDayOfWeek(UCAL_MONDAY);
   2062    cal.setMinimalDaysInFirstWeek(4);
   2063    UDate t = 946713600000.;
   2064    cal.setTime(t, status);
   2065    cal.set(UCAL_DAY_OF_WEEK, 4);
   2066    cal.set(UCAL_DOW_LOCAL, 6);
   2067    if(cal.getTime(status) != t) {
   2068      logln(calToStr(cal));
   2069      errln("FAIL:  DOW_LOCAL did not take precedence");
   2070    }
   2071 
   2072 }
   2073 
   2074 void CalendarTest::TestJD()
   2075 {
   2076   int32_t jd;
   2077   static const int32_t kEpochStartAsJulianDay = 2440588;
   2078   UErrorCode status = U_ZERO_ERROR;
   2079   GregorianCalendar cal(status);
   2080   if (failure(status, "construct GregorianCalendar", TRUE)) return;
   2081   cal.setTimeZone(*TimeZone::getGMT());
   2082   cal.clear();
   2083   jd = cal.get(UCAL_JULIAN_DAY, status);
   2084   if(jd != kEpochStartAsJulianDay) {
   2085     errln("Wanted JD of %d at time=0, [epoch 1970] but got %d\n", kEpochStartAsJulianDay, jd);
   2086   } else {
   2087     logln("Wanted JD of %d at time=0, [epoch 1970], got %d\n", kEpochStartAsJulianDay, jd);
   2088   }
   2089 
   2090   cal.setTime(Calendar::getNow(), status);
   2091   cal.clear();
   2092   cal.set(UCAL_JULIAN_DAY, kEpochStartAsJulianDay);
   2093   UDate epochTime = cal.getTime(status);
   2094   if(epochTime != 0) {
   2095     errln("Wanted time of 0 at jd=%d, got %.1lf\n", kEpochStartAsJulianDay, epochTime);
   2096   } else {
   2097     logln("Wanted time of 0 at jd=%d, got %.1lf\n", kEpochStartAsJulianDay, epochTime);
   2098   }
   2099 
   2100 }
   2101 
   2102 // make sure the ctestfw utilities are in sync with the Calendar
   2103 void CalendarTest::TestDebug()
   2104 {
   2105     for(int32_t  t=0;t<=UDBG_ENUM_COUNT;t++) {
   2106         int32_t count = udbg_enumCount((UDebugEnumType)t);
   2107         if(count == -1) {
   2108             logln("enumCount(%d) returned -1", count);
   2109             continue;
   2110         }
   2111         for(int32_t i=0;i<=count;i++) {
   2112             if(t<=UDBG_HIGHEST_CONTIGUOUS_ENUM && i<count) {
   2113                 if( i!=udbg_enumArrayValue((UDebugEnumType)t, i)) {
   2114                     errln("FAIL: udbg_enumArrayValue(%d,%d) returned %d, expected %d", t, i, udbg_enumArrayValue((UDebugEnumType)t,i), i);
   2115                 }
   2116             } else {
   2117                 logln("Testing count+1:");
   2118             }
   2119                   const char *name = udbg_enumName((UDebugEnumType)t,i);
   2120                   if(name==NULL) {
   2121                           if(i==count || t>UDBG_HIGHEST_CONTIGUOUS_ENUM  ) {
   2122                                 logln(" null name - expected.\n");
   2123                           } else {
   2124                                 errln("FAIL: udbg_enumName(%d,%d) returned NULL", t, i);
   2125                           }
   2126                           name = "(null)";
   2127                   }
   2128           logln("udbg_enumArrayValue(%d,%d) = %s, returned %d", t, i,
   2129                       name, udbg_enumArrayValue((UDebugEnumType)t,i));
   2130             logln("udbg_enumString = " + udbg_enumString((UDebugEnumType)t,i));
   2131         }
   2132         if(udbg_enumExpectedCount((UDebugEnumType)t) != count && t<=UDBG_HIGHEST_CONTIGUOUS_ENUM) {
   2133             errln("FAIL: udbg_enumExpectedCount(%d): %d, != UCAL_FIELD_COUNT=%d ", t, udbg_enumExpectedCount((UDebugEnumType)t), count);
   2134         } else {
   2135             logln("udbg_ucal_fieldCount: %d, UCAL_FIELD_COUNT=udbg_enumCount %d ", udbg_enumExpectedCount((UDebugEnumType)t), count);
   2136         }
   2137     }
   2138 }
   2139 
   2140 
   2141 #undef CHECK
   2142 
   2143 // List of interesting locales
   2144 const char *CalendarTest::testLocaleID(int32_t i)
   2145 {
   2146   switch(i) {
   2147   case 0: return "he_IL@calendar=hebrew";
   2148   case 1: return "en_US@calendar=hebrew";
   2149   case 2: return "fr_FR@calendar=hebrew";
   2150   case 3: return "fi_FI@calendar=hebrew";
   2151   case 4: return "nl_NL@calendar=hebrew";
   2152   case 5: return "hu_HU@calendar=hebrew";
   2153   case 6: return "nl_BE@currency=MTL;calendar=islamic";
   2154   case 7: return "th_TH_TRADITIONAL@calendar=gregorian";
   2155   case 8: return "ar_JO@calendar=islamic-civil";
   2156   case 9: return "fi_FI@calendar=islamic";
   2157   case 10: return "fr_CH@calendar=islamic-civil";
   2158   case 11: return "he_IL@calendar=islamic-civil";
   2159   case 12: return "hu_HU@calendar=buddhist";
   2160   case 13: return "hu_HU@calendar=islamic";
   2161   case 14: return "en_US@calendar=japanese";
   2162   default: return NULL;
   2163   }
   2164 }
   2165 
   2166 int32_t CalendarTest::testLocaleCount()
   2167 {
   2168   static int32_t gLocaleCount = -1;
   2169   if(gLocaleCount < 0) {
   2170     int32_t i;
   2171     for(i=0;testLocaleID(i) != NULL;i++) {
   2172       ;
   2173     }
   2174     gLocaleCount = i;
   2175   }
   2176   return gLocaleCount;
   2177 }
   2178 
   2179 static UDate doMinDateOfCalendar(Calendar* adopt, UBool &isGregorian, UErrorCode& status) {
   2180   if(U_FAILURE(status)) return 0.0;
   2181 
   2182   adopt->clear();
   2183   adopt->set(UCAL_EXTENDED_YEAR, adopt->getActualMinimum(UCAL_EXTENDED_YEAR, status));
   2184   UDate ret = adopt->getTime(status);
   2185   isGregorian = dynamic_cast<GregorianCalendar*>(adopt) != NULL;
   2186   delete adopt;
   2187   return ret;
   2188 }
   2189 
   2190 UDate CalendarTest::minDateOfCalendar(const Locale& locale, UBool &isGregorian, UErrorCode& status) {
   2191   if(U_FAILURE(status)) return 0.0;
   2192   return doMinDateOfCalendar(Calendar::createInstance(locale, status), isGregorian, status);
   2193 }
   2194 
   2195 UDate CalendarTest::minDateOfCalendar(const Calendar& cal, UBool &isGregorian, UErrorCode& status) {
   2196   if(U_FAILURE(status)) return 0.0;
   2197   return doMinDateOfCalendar(cal.clone(), isGregorian, status);
   2198 }
   2199 
   2200 void CalendarTest::Test6703()
   2201 {
   2202     UErrorCode status = U_ZERO_ERROR;
   2203     Calendar *cal;
   2204 
   2205     Locale loc1("en@calendar=fubar");
   2206     cal = Calendar::createInstance(loc1, status);
   2207     if (failure(status, "Calendar::createInstance", TRUE)) return;
   2208     delete cal;
   2209 
   2210     status = U_ZERO_ERROR;
   2211     Locale loc2("en");
   2212     cal = Calendar::createInstance(loc2, status);
   2213     if (failure(status, "Calendar::createInstance")) return;
   2214     delete cal;
   2215 
   2216     status = U_ZERO_ERROR;
   2217     Locale loc3("en@calendar=roc");
   2218     cal = Calendar::createInstance(loc3, status);
   2219     if (failure(status, "Calendar::createInstance")) return;
   2220     delete cal;
   2221 
   2222     return;
   2223 }
   2224 
   2225 void CalendarTest::Test3785()
   2226 {
   2227     UErrorCode status = U_ZERO_ERROR;
   2228     UnicodeString uzone = UNICODE_STRING_SIMPLE("Europe/Paris");
   2229     UnicodeString exp1 = UNICODE_STRING_SIMPLE("Mon 30 Jumada II 1433 AH, 01:47:03");
   2230     UnicodeString exp2 = UNICODE_STRING_SIMPLE("Mon 1 Rajab 1433 AH, 01:47:04");
   2231 
   2232     LocalUDateFormatPointer df(udat_open(UDAT_NONE, UDAT_NONE, "en@calendar=islamic", uzone.getTerminatedBuffer(),
   2233                                          uzone.length(), NULL, 0, &status));
   2234     if (df.isNull() || U_FAILURE(status)) return;
   2235 
   2236     UChar upattern[64];
   2237     u_uastrcpy(upattern, "EEE d MMMM y G, HH:mm:ss");
   2238     udat_applyPattern(df.getAlias(), FALSE, upattern, u_strlen(upattern));
   2239 
   2240     UChar ubuffer[1024];
   2241     UDate ud0 = 1337557623000.0;
   2242 
   2243     status = U_ZERO_ERROR;
   2244     udat_format(df.getAlias(), ud0, ubuffer, 1024, NULL, &status);
   2245     if (U_FAILURE(status)) {
   2246         errln("Error formatting date 1\n");
   2247         return;
   2248     }
   2249     //printf("formatted: '%s'\n", mkcstr(ubuffer));
   2250 
   2251     UnicodeString act1(ubuffer);
   2252     if ( act1 != exp1 ) {
   2253         errln("Unexpected result from date 1 format\n");
   2254     }
   2255     ud0 += 1000.0; // add one second
   2256 
   2257     status = U_ZERO_ERROR;
   2258     udat_format(df.getAlias(), ud0, ubuffer, 1024, NULL, &status);
   2259     if (U_FAILURE(status)) {
   2260         errln("Error formatting date 2\n");
   2261         return;
   2262     }
   2263     //printf("formatted: '%s'\n", mkcstr(ubuffer));
   2264     UnicodeString act2(ubuffer);
   2265     if ( act2 != exp2 ) {
   2266         errln("Unexpected result from date 2 format\n");
   2267     }
   2268 
   2269     return;
   2270 }
   2271 
   2272 void CalendarTest::Test1624() {
   2273     UErrorCode status = U_ZERO_ERROR;
   2274     Locale loc("he_IL@calendar=hebrew");
   2275     HebrewCalendar hc(loc,status);
   2276 
   2277     for (int32_t year = 5600; year < 5800; year++ ) {
   2278 
   2279         for (int32_t month = HebrewCalendar::TISHRI; month <= HebrewCalendar::ELUL; month++) {
   2280             // skip the adar 1 month if year is not a leap year
   2281             if (HebrewCalendar::isLeapYear(year) == FALSE && month == HebrewCalendar::ADAR_1) {
   2282                 continue;
   2283             }
   2284             int32_t day = 15;
   2285             hc.set(year,month,day);
   2286             int32_t dayHC = hc.get(UCAL_DATE,status);
   2287             int32_t monthHC = hc.get(UCAL_MONTH,status);
   2288             int32_t yearHC = hc.get(UCAL_YEAR,status);
   2289 
   2290             if (failure(status, "HebrewCalendar.get()", TRUE)) continue;
   2291 
   2292             if (dayHC != day) {
   2293                 errln(" ==> day %d incorrect, should be: %d\n",dayHC,day);
   2294                 break;
   2295             }
   2296             if (monthHC != month) {
   2297                 errln(" ==> month %d incorrect, should be: %d\n",monthHC,month);
   2298                 break;
   2299             }
   2300             if (yearHC != year) {
   2301                 errln(" ==> day %d incorrect, should be: %d\n",yearHC,year);
   2302                 break;
   2303             }
   2304         }
   2305     }
   2306     return;
   2307 }
   2308 
   2309 void CalendarTest::TestTimeStamp() {
   2310     UErrorCode status = U_ZERO_ERROR;
   2311     UDate start = 0.0, time;
   2312     Calendar *cal;
   2313 
   2314     // Create a new Gregorian Calendar.
   2315     cal = Calendar::createInstance("en_US@calender=gregorian", status);
   2316     if (U_FAILURE(status)) {
   2317         dataerrln("Error creating Gregorian calendar.");
   2318         return;
   2319     }
   2320 
   2321     for (int i = 0; i < 20000; i++) {
   2322         // Set the Gregorian Calendar to a specific date for testing.
   2323         cal->set(2009, UCAL_JULY, 3, 0, 49, 46);
   2324 
   2325         time = cal->getTime(status);
   2326         if (U_FAILURE(status)) {
   2327             errln("Error calling getTime()");
   2328             break;
   2329         }
   2330 
   2331         if (i == 0) {
   2332             start = time;
   2333         } else {
   2334             if (start != time) {
   2335                 errln("start and time not equal.");
   2336                 break;
   2337             }
   2338         }
   2339     }
   2340 
   2341     delete cal;
   2342 }
   2343 
   2344 void CalendarTest::TestISO8601() {
   2345     const char* TEST_LOCALES[] = {
   2346         "en_US@calendar=iso8601",
   2347         "en_US@calendar=Iso8601",
   2348         "th_TH@calendar=iso8601",
   2349         "ar_EG@calendar=iso8601",
   2350         NULL
   2351     };
   2352 
   2353     int32_t TEST_DATA[][3] = {
   2354         {2008, 1, 2008},
   2355         {2009, 1, 2009},
   2356         {2010, 53, 2009},
   2357         {2011, 52, 2010},
   2358         {2012, 52, 2011},
   2359         {2013, 1, 2013},
   2360         {2014, 1, 2014},
   2361         {0, 0, 0},
   2362     };
   2363 
   2364     for (int i = 0; TEST_LOCALES[i] != NULL; i++) {
   2365         UErrorCode status = U_ZERO_ERROR;
   2366         Calendar *cal = Calendar::createInstance(TEST_LOCALES[i], status);
   2367         if (U_FAILURE(status)) {
   2368             errln("Error: Failed to create a calendar for locale: %s", TEST_LOCALES[i]);
   2369             continue;
   2370         }
   2371         if (uprv_strcmp(cal->getType(), "gregorian") != 0) {
   2372             errln("Error: Gregorian calendar is not used for locale: %s", TEST_LOCALES[i]);
   2373             continue;
   2374         }
   2375         for (int j = 0; TEST_DATA[j][0] != 0; j++) {
   2376             cal->set(TEST_DATA[j][0], UCAL_JANUARY, 1);
   2377             int32_t weekNum = cal->get(UCAL_WEEK_OF_YEAR, status);
   2378             int32_t weekYear = cal->get(UCAL_YEAR_WOY, status);
   2379             if (U_FAILURE(status)) {
   2380                 errln("Error: Failed to get week of year");
   2381                 break;
   2382             }
   2383             if (weekNum != TEST_DATA[j][1] || weekYear != TEST_DATA[j][2]) {
   2384                 errln("Error: Incorrect week of year on January 1st, %d for locale %s: Returned [weekNum=%d, weekYear=%d], Expected [weekNum=%d, weekYear=%d]",
   2385                     TEST_DATA[j][0], TEST_LOCALES[i], weekNum, weekYear, TEST_DATA[j][1], TEST_DATA[j][2]);
   2386             }
   2387         }
   2388         delete cal;
   2389     }
   2390 
   2391 }
   2392 
   2393 void
   2394 CalendarTest::TestAmbiguousWallTimeAPIs(void) {
   2395     UErrorCode status = U_ZERO_ERROR;
   2396     Calendar* cal = Calendar::createInstance(status);
   2397     if (U_FAILURE(status)) {
   2398         errln("Fail: Error creating a calendar instance.");
   2399         return;
   2400     }
   2401 
   2402     if (cal->getRepeatedWallTimeOption() != UCAL_WALLTIME_LAST) {
   2403         errln("Fail: Default repeted time option is not UCAL_WALLTIME_LAST");
   2404     }
   2405     if (cal->getSkippedWallTimeOption() != UCAL_WALLTIME_LAST) {
   2406         errln("Fail: Default skipped time option is not UCAL_WALLTIME_LAST");
   2407     }
   2408 
   2409     Calendar* cal2 = cal->clone();
   2410 
   2411     if (*cal != *cal2) {
   2412         errln("Fail: Cloned calendar != the original");
   2413     }
   2414     if (!cal->equals(*cal2, status)) {
   2415         errln("Fail: The time of cloned calendar is not equal to the original");
   2416     } else if (U_FAILURE(status)) {
   2417         errln("Fail: Error equals");
   2418     }
   2419     status = U_ZERO_ERROR;
   2420 
   2421     cal2->setRepeatedWallTimeOption(UCAL_WALLTIME_FIRST);
   2422     cal2->setSkippedWallTimeOption(UCAL_WALLTIME_FIRST);
   2423 
   2424     if (*cal == *cal2) {
   2425         errln("Fail: Cloned and modified calendar == the original");
   2426     }
   2427     if (!cal->equals(*cal2, status)) {
   2428         errln("Fail: The time of cloned calendar is not equal to the original after changing wall time options");
   2429     } else if (U_FAILURE(status)) {
   2430         errln("Fail: Error equals after changing wall time options");
   2431     }
   2432     status = U_ZERO_ERROR;
   2433 
   2434     if (cal2->getRepeatedWallTimeOption() != UCAL_WALLTIME_FIRST) {
   2435         errln("Fail: Repeted time option is not UCAL_WALLTIME_FIRST");
   2436     }
   2437     if (cal2->getSkippedWallTimeOption() != UCAL_WALLTIME_FIRST) {
   2438         errln("Fail: Skipped time option is not UCAL_WALLTIME_FIRST");
   2439     }
   2440 
   2441     cal2->setRepeatedWallTimeOption(UCAL_WALLTIME_NEXT_VALID);
   2442     if (cal2->getRepeatedWallTimeOption() != UCAL_WALLTIME_FIRST) {
   2443         errln("Fail: Repeated wall time option was updated other than UCAL_WALLTIME_FIRST");
   2444     }
   2445 
   2446     delete cal;
   2447     delete cal2;
   2448 }
   2449 
   2450 class CalFields {
   2451 public:
   2452     CalFields(int32_t year, int32_t month, int32_t day, int32_t hour, int32_t min, int32_t sec, int32_t ms = 0);
   2453     CalFields(const Calendar& cal, UErrorCode& status);
   2454     void setTo(Calendar& cal) const;
   2455     char* toString(char* buf, int32_t len) const;
   2456     UBool operator==(const CalFields& rhs) const;
   2457     UBool operator!=(const CalFields& rhs) const;
   2458     UBool isEquivalentTo(const Calendar& cal, UErrorCode& status) const;
   2459 
   2460 private:
   2461     int32_t year;
   2462     int32_t month;
   2463     int32_t day;
   2464     int32_t hour;
   2465     int32_t min;
   2466     int32_t sec;
   2467     int32_t ms;
   2468 };
   2469 
   2470 CalFields::CalFields(int32_t year, int32_t month, int32_t day, int32_t hour, int32_t min, int32_t sec, int32_t ms)
   2471     : year(year), month(month), day(day), hour(hour), min(min), sec(sec), ms(ms) {
   2472 }
   2473 
   2474 CalFields::CalFields(const Calendar& cal, UErrorCode& status) {
   2475     year = cal.get(UCAL_YEAR, status);
   2476     month = cal.get(UCAL_MONTH, status) + 1;
   2477     day = cal.get(UCAL_DAY_OF_MONTH, status);
   2478     hour = cal.get(UCAL_HOUR_OF_DAY, status);
   2479     min = cal.get(UCAL_MINUTE, status);
   2480     sec = cal.get(UCAL_SECOND, status);
   2481     ms = cal.get(UCAL_MILLISECOND, status);
   2482 }
   2483 
   2484 void
   2485 CalFields::setTo(Calendar& cal) const {
   2486     cal.clear();
   2487     cal.set(year, month - 1, day, hour, min, sec);
   2488     cal.set(UCAL_MILLISECOND, ms);
   2489 }
   2490 
   2491 char*
   2492 CalFields::toString(char* buf, int32_t len) const {
   2493     char local[32];
   2494     sprintf(local, "%04d-%02d-%02d %02d:%02d:%02d.%03d", year, month, day, hour, min, sec, ms);
   2495     uprv_strncpy(buf, local, len - 1);
   2496     buf[len - 1] = 0;
   2497     return buf;
   2498 }
   2499 
   2500 UBool
   2501 CalFields::operator==(const CalFields& rhs) const {
   2502     return year == rhs.year
   2503         && month == rhs.month
   2504         && day == rhs.day
   2505         && hour == rhs.hour
   2506         && min == rhs.min
   2507         && sec == rhs.sec
   2508         && ms == rhs.ms;
   2509 }
   2510 
   2511 UBool
   2512 CalFields::operator!=(const CalFields& rhs) const {
   2513     return !(*this == rhs);
   2514 }
   2515 
   2516 UBool
   2517 CalFields::isEquivalentTo(const Calendar& cal, UErrorCode& status) const {
   2518     return year == cal.get(UCAL_YEAR, status)
   2519         && month == cal.get(UCAL_MONTH, status) + 1
   2520         && day == cal.get(UCAL_DAY_OF_MONTH, status)
   2521         && hour == cal.get(UCAL_HOUR_OF_DAY, status)
   2522         && min == cal.get(UCAL_MINUTE, status)
   2523         && sec == cal.get(UCAL_SECOND, status)
   2524         && ms == cal.get(UCAL_MILLISECOND, status);
   2525 }
   2526 
   2527 typedef struct {
   2528     const char*     tzid;
   2529     const CalFields in;
   2530     const CalFields expLastGMT;
   2531     const CalFields expFirstGMT;
   2532 } RepeatedWallTimeTestData;
   2533 
   2534 static const RepeatedWallTimeTestData RPDATA[] =
   2535 {
   2536     // Time zone            Input wall time                 WALLTIME_LAST in GMT            WALLTIME_FIRST in GMT
   2537     {"America/New_York",    CalFields(2011,11,6,0,59,59),   CalFields(2011,11,6,4,59,59),   CalFields(2011,11,6,4,59,59)},
   2538     {"America/New_York",    CalFields(2011,11,6,1,0,0),     CalFields(2011,11,6,6,0,0),     CalFields(2011,11,6,5,0,0)},
   2539     {"America/New_York",    CalFields(2011,11,6,1,0,1),     CalFields(2011,11,6,6,0,1),     CalFields(2011,11,6,5,0,1)},
   2540     {"America/New_York",    CalFields(2011,11,6,1,30,0),    CalFields(2011,11,6,6,30,0),    CalFields(2011,11,6,5,30,0)},
   2541     {"America/New_York",    CalFields(2011,11,6,1,59,59),   CalFields(2011,11,6,6,59,59),   CalFields(2011,11,6,5,59,59)},
   2542     {"America/New_York",    CalFields(2011,11,6,2,0,0),     CalFields(2011,11,6,7,0,0),     CalFields(2011,11,6,7,0,0)},
   2543     {"America/New_York",    CalFields(2011,11,6,2,0,1),     CalFields(2011,11,6,7,0,1),     CalFields(2011,11,6,7,0,1)},
   2544 
   2545     {"Australia/Lord_Howe", CalFields(2011,4,3,1,29,59),    CalFields(2011,4,2,14,29,59),   CalFields(2011,4,2,14,29,59)},
   2546     {"Australia/Lord_Howe", CalFields(2011,4,3,1,30,0),     CalFields(2011,4,2,15,0,0),     CalFields(2011,4,2,14,30,0)},
   2547     {"Australia/Lord_Howe", CalFields(2011,4,3,1,45,0),     CalFields(2011,4,2,15,15,0),    CalFields(2011,4,2,14,45,0)},
   2548     {"Australia/Lord_Howe", CalFields(2011,4,3,1,59,59),    CalFields(2011,4,2,15,29,59),   CalFields(2011,4,2,14,59,59)},
   2549     {"Australia/Lord_Howe", CalFields(2011,4,3,2,0,0),      CalFields(2011,4,2,15,30,0),    CalFields(2011,4,2,15,30,0)},
   2550     {"Australia/Lord_Howe", CalFields(2011,4,3,2,0,1),      CalFields(2011,4,2,15,30,1),    CalFields(2011,4,2,15,30,1)},
   2551 
   2552     {NULL,                  CalFields(0,0,0,0,0,0),         CalFields(0,0,0,0,0,0),          CalFields(0,0,0,0,0,0)}
   2553 };
   2554 
   2555 void CalendarTest::TestRepeatedWallTime(void) {
   2556     UErrorCode status = U_ZERO_ERROR;
   2557     GregorianCalendar calGMT((const TimeZone&)*TimeZone::getGMT(), status);
   2558     GregorianCalendar calDefault(status);
   2559     GregorianCalendar calLast(status);
   2560     GregorianCalendar calFirst(status);
   2561 
   2562     if (U_FAILURE(status)) {
   2563         errln("Fail: Failed to create a calendar object.");
   2564         return;
   2565     }
   2566 
   2567     calLast.setRepeatedWallTimeOption(UCAL_WALLTIME_LAST);
   2568     calFirst.setRepeatedWallTimeOption(UCAL_WALLTIME_FIRST);
   2569 
   2570     for (int32_t i = 0; RPDATA[i].tzid != NULL; i++) {
   2571         char buf[32];
   2572         TimeZone *tz = TimeZone::createTimeZone(RPDATA[i].tzid);
   2573 
   2574         // UCAL_WALLTIME_LAST
   2575         status = U_ZERO_ERROR;
   2576         calLast.setTimeZone(*tz);
   2577         RPDATA[i].in.setTo(calLast);
   2578         calGMT.setTime(calLast.getTime(status), status);
   2579         CalFields outLastGMT(calGMT, status);
   2580         if (U_FAILURE(status)) {
   2581             errln(UnicodeString("Fail: Failed to get/set time calLast/calGMT (UCAL_WALLTIME_LAST) - ")
   2582                 + RPDATA[i].in.toString(buf, sizeof(buf)) + "[" + RPDATA[i].tzid + "]");
   2583         } else {
   2584             if (outLastGMT != RPDATA[i].expLastGMT) {
   2585                 dataerrln(UnicodeString("Fail: UCAL_WALLTIME_LAST ") + RPDATA[i].in.toString(buf, sizeof(buf)) + "[" + RPDATA[i].tzid + "] is parsed as "
   2586                     + outLastGMT.toString(buf, sizeof(buf)) + "[GMT]. Expected: " + RPDATA[i].expLastGMT.toString(buf, sizeof(buf)) + "[GMT]");
   2587             }
   2588         }
   2589 
   2590         // default
   2591         status = U_ZERO_ERROR;
   2592         calDefault.setTimeZone(*tz);
   2593         RPDATA[i].in.setTo(calDefault);
   2594         calGMT.setTime(calDefault.getTime(status), status);
   2595         CalFields outDefGMT(calGMT, status);
   2596         if (U_FAILURE(status)) {
   2597             errln(UnicodeString("Fail: Failed to get/set time calLast/calGMT (default) - ")
   2598                 + RPDATA[i].in.toString(buf, sizeof(buf)) + "[" + RPDATA[i].tzid + "]");
   2599         } else {
   2600             if (outDefGMT != RPDATA[i].expLastGMT) {
   2601                 dataerrln(UnicodeString("Fail: (default) ") + RPDATA[i].in.toString(buf, sizeof(buf)) + "[" + RPDATA[i].tzid + "] is parsed as "
   2602                     + outDefGMT.toString(buf, sizeof(buf)) + "[GMT]. Expected: " + RPDATA[i].expLastGMT.toString(buf, sizeof(buf)) + "[GMT]");
   2603             }
   2604         }
   2605 
   2606         // UCAL_WALLTIME_FIRST
   2607         status = U_ZERO_ERROR;
   2608         calFirst.setTimeZone(*tz);
   2609         RPDATA[i].in.setTo(calFirst);
   2610         calGMT.setTime(calFirst.getTime(status), status);
   2611         CalFields outFirstGMT(calGMT, status);
   2612         if (U_FAILURE(status)) {
   2613             errln(UnicodeString("Fail: Failed to get/set time calLast/calGMT (UCAL_WALLTIME_FIRST) - ")
   2614                 + RPDATA[i].in.toString(buf, sizeof(buf)) + "[" + RPDATA[i].tzid + "]");
   2615         } else {
   2616             if (outFirstGMT != RPDATA[i].expFirstGMT) {
   2617                 dataerrln(UnicodeString("Fail: UCAL_WALLTIME_FIRST ") + RPDATA[i].in.toString(buf, sizeof(buf)) + "[" + RPDATA[i].tzid + "] is parsed as "
   2618                     + outFirstGMT.toString(buf, sizeof(buf)) + "[GMT]. Expected: " + RPDATA[i].expFirstGMT.toString(buf, sizeof(buf)) + "[GMT]");
   2619             }
   2620         }
   2621         delete tz;
   2622     }
   2623 }
   2624 
   2625 typedef struct {
   2626     const char*     tzid;
   2627     const CalFields in;
   2628     UBool           isValid;
   2629     const CalFields expLastGMT;
   2630     const CalFields expFirstGMT;
   2631     const CalFields expNextAvailGMT;
   2632 } SkippedWallTimeTestData;
   2633 
   2634 static SkippedWallTimeTestData SKDATA[] =
   2635 {
   2636      // Time zone           Input wall time                 valid?  WALLTIME_LAST in GMT            WALLTIME_FIRST in GMT           WALLTIME_NEXT_VALID in GMT
   2637     {"America/New_York",    CalFields(2011,3,13,1,59,59),   TRUE,   CalFields(2011,3,13,6,59,59),   CalFields(2011,3,13,6,59,59),   CalFields(2011,3,13,6,59,59)},
   2638     {"America/New_York",    CalFields(2011,3,13,2,0,0),     FALSE,  CalFields(2011,3,13,7,0,0),     CalFields(2011,3,13,6,0,0),     CalFields(2011,3,13,7,0,0)},
   2639     {"America/New_York",    CalFields(2011,3,13,2,1,0),     FALSE,  CalFields(2011,3,13,7,1,0),     CalFields(2011,3,13,6,1,0),     CalFields(2011,3,13,7,0,0)},
   2640     {"America/New_York",    CalFields(2011,3,13,2,30,0),    FALSE,  CalFields(2011,3,13,7,30,0),    CalFields(2011,3,13,6,30,0),    CalFields(2011,3,13,7,0,0)},
   2641     {"America/New_York",    CalFields(2011,3,13,2,59,59),   FALSE,  CalFields(2011,3,13,7,59,59),   CalFields(2011,3,13,6,59,59),   CalFields(2011,3,13,7,0,0)},
   2642     {"America/New_York",    CalFields(2011,3,13,3,0,0),     TRUE,   CalFields(2011,3,13,7,0,0),     CalFields(2011,3,13,7,0,0),     CalFields(2011,3,13,7,0,0)},
   2643 
   2644     {"Pacific/Apia",        CalFields(2011,12,29,23,59,59), TRUE,   CalFields(2011,12,30,9,59,59),  CalFields(2011,12,30,9,59,59),  CalFields(2011,12,30,9,59,59)},
   2645     {"Pacific/Apia",        CalFields(2011,12,30,0,0,0),    FALSE,  CalFields(2011,12,30,10,0,0),   CalFields(2011,12,29,10,0,0),   CalFields(2011,12,30,10,0,0)},
   2646     {"Pacific/Apia",        CalFields(2011,12,30,12,0,0),   FALSE,  CalFields(2011,12,30,22,0,0),   CalFields(2011,12,29,22,0,0),   CalFields(2011,12,30,10,0,0)},
   2647     {"Pacific/Apia",        CalFields(2011,12,30,23,59,59), FALSE,  CalFields(2011,12,31,9,59,59),  CalFields(2011,12,30,9,59,59),  CalFields(2011,12,30,10,0,0)},
   2648     {"Pacific/Apia",        CalFields(2011,12,31,0,0,0),    TRUE,   CalFields(2011,12,30,10,0,0),   CalFields(2011,12,30,10,0,0),   CalFields(2011,12,30,10,0,0)},
   2649 
   2650     {NULL,                  CalFields(0,0,0,0,0,0),         TRUE,   CalFields(0,0,0,0,0,0),         CalFields(0,0,0,0,0,0),         CalFields(0,0,0,0,0,0)}
   2651 };
   2652 
   2653 
   2654 void CalendarTest::TestSkippedWallTime(void) {
   2655     UErrorCode status = U_ZERO_ERROR;
   2656     GregorianCalendar calGMT((const TimeZone&)*TimeZone::getGMT(), status);
   2657     GregorianCalendar calDefault(status);
   2658     GregorianCalendar calLast(status);
   2659     GregorianCalendar calFirst(status);
   2660     GregorianCalendar calNextAvail(status);
   2661 
   2662     if (U_FAILURE(status)) {
   2663         errln("Fail: Failed to create a calendar object.");
   2664         return;
   2665     }
   2666 
   2667     calLast.setSkippedWallTimeOption(UCAL_WALLTIME_LAST);
   2668     calFirst.setSkippedWallTimeOption(UCAL_WALLTIME_FIRST);
   2669     calNextAvail.setSkippedWallTimeOption(UCAL_WALLTIME_NEXT_VALID);
   2670 
   2671     for (int32_t i = 0; SKDATA[i].tzid != NULL; i++) {
   2672         UDate d;
   2673         char buf[32];
   2674         TimeZone *tz = TimeZone::createTimeZone(SKDATA[i].tzid);
   2675 
   2676         for (int32_t j = 0; j < 2; j++) {
   2677             UBool bLenient = (j == 0);
   2678 
   2679             // UCAL_WALLTIME_LAST
   2680             status = U_ZERO_ERROR;
   2681             calLast.setLenient(bLenient);
   2682             calLast.setTimeZone(*tz);
   2683             SKDATA[i].in.setTo(calLast);
   2684             d = calLast.getTime(status);
   2685             if (bLenient || SKDATA[i].isValid) {
   2686                 calGMT.setTime(d, status);
   2687                 CalFields outLastGMT(calGMT, status);
   2688                 if (U_FAILURE(status)) {
   2689                     errln(UnicodeString("Fail: Failed to get/set time calLast/calGMT (UCAL_WALLTIME_LAST) - ")
   2690                         + SKDATA[i].in.toString(buf, sizeof(buf)) + "[" + SKDATA[i].tzid + "]");
   2691                 } else {
   2692                     if (outLastGMT != SKDATA[i].expLastGMT) {
   2693                         dataerrln(UnicodeString("Fail: UCAL_WALLTIME_LAST ") + SKDATA[i].in.toString(buf, sizeof(buf)) + "[" + SKDATA[i].tzid + "] is parsed as "
   2694                             + outLastGMT.toString(buf, sizeof(buf)) + "[GMT]. Expected: " + SKDATA[i].expLastGMT.toString(buf, sizeof(buf)) + "[GMT]");
   2695                     }
   2696                 }
   2697             } else if (U_SUCCESS(status)) {
   2698                 // strict, invalid wall time - must report an error
   2699                 dataerrln(UnicodeString("Fail: An error expected (UCAL_WALLTIME_LAST)") +
   2700                     + SKDATA[i].in.toString(buf, sizeof(buf)) + "[" + SKDATA[i].tzid + "]");
   2701             }
   2702 
   2703             // default
   2704             status = U_ZERO_ERROR;
   2705             calDefault.setLenient(bLenient);
   2706             calDefault.setTimeZone(*tz);
   2707             SKDATA[i].in.setTo(calDefault);
   2708             d = calDefault.getTime(status);
   2709             if (bLenient || SKDATA[i].isValid) {
   2710                 calGMT.setTime(d, status);
   2711                 CalFields outDefGMT(calGMT, status);
   2712                 if (U_FAILURE(status)) {
   2713                     errln(UnicodeString("Fail: Failed to get/set time calDefault/calGMT (default) - ")
   2714                         + SKDATA[i].in.toString(buf, sizeof(buf)) + "[" + SKDATA[i].tzid + "]");
   2715                 } else {
   2716                     if (outDefGMT != SKDATA[i].expLastGMT) {
   2717                         dataerrln(UnicodeString("Fail: (default) ") + SKDATA[i].in.toString(buf, sizeof(buf)) + "[" + SKDATA[i].tzid + "] is parsed as "
   2718                             + outDefGMT.toString(buf, sizeof(buf)) + "[GMT]. Expected: " + SKDATA[i].expLastGMT.toString(buf, sizeof(buf)) + "[GMT]");
   2719                     }
   2720                 }
   2721             } else if (U_SUCCESS(status)) {
   2722                 // strict, invalid wall time - must report an error
   2723                 dataerrln(UnicodeString("Fail: An error expected (default)") +
   2724                     + SKDATA[i].in.toString(buf, sizeof(buf)) + "[" + SKDATA[i].tzid + "]");
   2725             }
   2726 
   2727             // UCAL_WALLTIME_FIRST
   2728             status = U_ZERO_ERROR;
   2729             calFirst.setLenient(bLenient);
   2730             calFirst.setTimeZone(*tz);
   2731             SKDATA[i].in.setTo(calFirst);
   2732             d = calFirst.getTime(status);
   2733             if (bLenient || SKDATA[i].isValid) {
   2734                 calGMT.setTime(d, status);
   2735                 CalFields outFirstGMT(calGMT, status);
   2736                 if (U_FAILURE(status)) {
   2737                     errln(UnicodeString("Fail: Failed to get/set time calFirst/calGMT (UCAL_WALLTIME_FIRST) - ")
   2738                         + SKDATA[i].in.toString(buf, sizeof(buf)) + "[" + SKDATA[i].tzid + "]");
   2739                 } else {
   2740                     if (outFirstGMT != SKDATA[i].expFirstGMT) {
   2741                         dataerrln(UnicodeString("Fail: UCAL_WALLTIME_FIRST ") + SKDATA[i].in.toString(buf, sizeof(buf)) + "[" + SKDATA[i].tzid + "] is parsed as "
   2742                             + outFirstGMT.toString(buf, sizeof(buf)) + "[GMT]. Expected: " + SKDATA[i].expFirstGMT.toString(buf, sizeof(buf)) + "[GMT]");
   2743                     }
   2744                 }
   2745             } else if (U_SUCCESS(status)) {
   2746                 // strict, invalid wall time - must report an error
   2747                 dataerrln(UnicodeString("Fail: An error expected (UCAL_WALLTIME_FIRST)") +
   2748                     + SKDATA[i].in.toString(buf, sizeof(buf)) + "[" + SKDATA[i].tzid + "]");
   2749             }
   2750 
   2751             // UCAL_WALLTIME_NEXT_VALID
   2752             status = U_ZERO_ERROR;
   2753             calNextAvail.setLenient(bLenient);
   2754             calNextAvail.setTimeZone(*tz);
   2755             SKDATA[i].in.setTo(calNextAvail);
   2756             d = calNextAvail.getTime(status);
   2757             if (bLenient || SKDATA[i].isValid) {
   2758                 calGMT.setTime(d, status);
   2759                 CalFields outNextAvailGMT(calGMT, status);
   2760                 if (U_FAILURE(status)) {
   2761                     errln(UnicodeString("Fail: Failed to get/set time calNextAvail/calGMT (UCAL_WALLTIME_NEXT_VALID) - ")
   2762                         + SKDATA[i].in.toString(buf, sizeof(buf)) + "[" + SKDATA[i].tzid + "]");
   2763                 } else {
   2764                     if (outNextAvailGMT != SKDATA[i].expNextAvailGMT) {
   2765                         dataerrln(UnicodeString("Fail: UCAL_WALLTIME_NEXT_VALID ") + SKDATA[i].in.toString(buf, sizeof(buf)) + "[" + SKDATA[i].tzid + "] is parsed as "
   2766                             + outNextAvailGMT.toString(buf, sizeof(buf)) + "[GMT]. Expected: " + SKDATA[i].expNextAvailGMT.toString(buf, sizeof(buf)) + "[GMT]");
   2767                     }
   2768                 }
   2769             } else if (U_SUCCESS(status)) {
   2770                 // strict, invalid wall time - must report an error
   2771                 dataerrln(UnicodeString("Fail: An error expected (UCAL_WALLTIME_NEXT_VALID)") +
   2772                     + SKDATA[i].in.toString(buf, sizeof(buf)) + "[" + SKDATA[i].tzid + "]");
   2773             }
   2774         }
   2775 
   2776         delete tz;
   2777     }
   2778 }
   2779 
   2780 void CalendarTest::TestCloneLocale(void) {
   2781   UErrorCode status = U_ZERO_ERROR;
   2782   LocalPointer<Calendar>  cal(Calendar::createInstance(TimeZone::getGMT()->clone(),
   2783                                                        Locale::createFromName("en"), status));
   2784   TEST_CHECK_STATUS;
   2785   Locale l0 = cal->getLocale(ULOC_VALID_LOCALE, status);
   2786   TEST_CHECK_STATUS;
   2787   LocalPointer<Calendar> cal2(cal->clone());
   2788   Locale l = cal2->getLocale(ULOC_VALID_LOCALE, status);
   2789   if(l0!=l) {
   2790     errln("Error: cloned locale %s != original locale %s, status %s\n", l0.getName(), l.getName(), u_errorName(status));
   2791   }
   2792   TEST_CHECK_STATUS;
   2793 }
   2794 
   2795 void CalendarTest::setAndTestCalendar(Calendar* cal, int32_t initMonth, int32_t initDay, int32_t initYear, UErrorCode& status) {
   2796         cal->clear();
   2797         cal->setLenient(FALSE);
   2798         cal->set(initYear, initMonth, initDay);
   2799         int32_t day = cal->get(UCAL_DAY_OF_MONTH, status);
   2800         int32_t month = cal->get(UCAL_MONTH, status);
   2801         int32_t year = cal->get(UCAL_YEAR, status);
   2802         if(U_FAILURE(status))
   2803             return;
   2804 
   2805         if(initDay != day || initMonth != month || initYear != year)
   2806         {
   2807             errln(" year init values:\tmonth %i\tday %i\tyear %i", initMonth, initDay, initYear);
   2808             errln("values post set():\tmonth %i\tday %i\tyear %i",month, day, year);
   2809         }
   2810 }
   2811 
   2812 void CalendarTest::setAndTestWholeYear(Calendar* cal, int32_t startYear, UErrorCode& status) {
   2813         for(int32_t startMonth = 0; startMonth < 12; startMonth++) {
   2814             for(int32_t startDay = 1; startDay < 31; startDay++ ) {
   2815                     setAndTestCalendar(cal, startMonth, startDay, startYear, status);
   2816                     if(U_FAILURE(status) && startDay == 30) {
   2817                         status = U_ZERO_ERROR;
   2818                         continue;
   2819                     }
   2820                     TEST_CHECK_STATUS;
   2821             }
   2822         }
   2823 }
   2824 
   2825 // =====================================================================
   2826 
   2827 typedef struct {
   2828     int16_t  gYear;
   2829     int8_t   gMon;
   2830     int8_t   gDay;
   2831     int16_t  uYear;
   2832     int8_t   uMon;
   2833     int8_t   uDay;
   2834 } GregoUmmAlQuraMap;
   2835 
   2836 // data from
   2837 // Official Umm-al-Qura calendar of SA:
   2838 // home, http://www.ummulqura.org.sa/default.aspx
   2839 // converter, http://www.ummulqura.org.sa/Index.aspx
   2840 static const GregoUmmAlQuraMap guMappings[] = {
   2841 //  gregorian,    ummAlQura
   2842 //  year mo da,   year mo da
   2843 //  (using 1-based months here)
   2844   { 1882,11,12,   1300, 1, 1 },
   2845   { 1892, 7,25,   1310, 1, 1 },
   2846   { 1896, 6,12,   1314, 1, 1 },
   2847   { 1898, 5,22,   1316, 1, 1 },
   2848   { 1900, 4,30,   1318, 1, 1 },
   2849   { 1901, 4,20,   1319, 1, 1 },
   2850   { 1902, 4,10,   1320, 1, 1 },
   2851   { 1903, 3,30,   1321, 1, 1 },
   2852   { 1904, 3,19,   1322, 1, 1 },
   2853   { 1905, 3, 8,   1323, 1, 1 },
   2854   { 1906, 2,25,   1324, 1, 1 },
   2855   { 1907, 2,14,   1325, 1, 1 },
   2856   { 1908, 2, 4,   1326, 1, 1 },
   2857   { 1909, 1,23,   1327, 1, 1 },
   2858   { 1910, 1,13,   1328, 1, 1 },
   2859   { 1911, 1, 2,   1329, 1, 1 },
   2860   { 1911,12,22,   1330, 1, 1 },
   2861   { 1912,12,10,   1331, 1, 1 },
   2862   { 1913,11,30,   1332, 1, 1 },
   2863   { 1914,11,19,   1333, 1, 1 },
   2864   { 1915,11, 9,   1334, 1, 1 },
   2865   { 1916,10,28,   1335, 1, 1 },
   2866   { 1917,10,18,   1336, 1, 1 },
   2867   { 1918,10, 7,   1337, 1, 1 },
   2868   { 1919, 9,26,   1338, 1, 1 },
   2869   { 1920, 9,14,   1339, 1, 1 },
   2870   { 1921, 9, 4,   1340, 1, 1 },
   2871   { 1922, 8,24,   1341, 1, 1 },
   2872   { 1923, 8,14,   1342, 1, 1 },
   2873   { 1924, 8, 2,   1343, 1, 1 },
   2874   { 1925, 7,22,   1344, 1, 1 },
   2875   { 1926, 7,11,   1345, 1, 1 },
   2876   { 1927, 6,30,   1346, 1, 1 },
   2877   { 1928, 6,19,   1347, 1, 1 },
   2878   { 1929, 6, 9,   1348, 1, 1 },
   2879   { 1930, 5,29,   1349, 1, 1 },
   2880   { 1931, 5,19,   1350, 1, 1 },
   2881   { 1932, 5, 7,   1351, 1, 1 },
   2882   { 1933, 4,26,   1352, 1, 1 },
   2883   { 1934, 4,15,   1353, 1, 1 },
   2884   { 1935, 4, 5,   1354, 1, 1 },
   2885   { 1936, 3,24,   1355, 1, 1 },
   2886   { 1937, 3,14,   1356, 1, 1 },
   2887   { 1938, 3, 4,   1357, 1, 1 },
   2888   { 1939, 2,21,   1358, 1, 1 },
   2889   { 1940, 2,10,   1359, 1, 1 },
   2890   { 1941, 1,29,   1360, 1, 1 },
   2891   { 1942, 1,18,   1361, 1, 1 },
   2892   { 1943, 1, 8,   1362, 1, 1 },
   2893   { 1943,12,28,   1363, 1, 1 },
   2894   { 1944,12,17,   1364, 1, 1 },
   2895   { 1945,12, 6,   1365, 1, 1 },
   2896   { 1946,11,25,   1366, 1, 1 },
   2897   { 1947,11,14,   1367, 1, 1 },
   2898   { 1948,11, 3,   1368, 1, 1 },
   2899   { 1949,10,23,   1369, 1, 1 },
   2900   { 1950,10,13,   1370, 1, 1 },
   2901   { 1951,10, 3,   1371, 1, 1 },
   2902   { 1952, 9,21,   1372, 1, 1 },
   2903   { 1953, 9,10,   1373, 1, 1 },
   2904   { 1954, 8,30,   1374, 1, 1 },
   2905   { 1955, 8,19,   1375, 1, 1 },
   2906   { 1956, 8, 8,   1376, 1, 1 },
   2907   { 1957, 7,29,   1377, 1, 1 },
   2908   { 1958, 7,18,   1378, 1, 1 },
   2909   { 1959, 7, 8,   1379, 1, 1 },
   2910   { 1960, 6,26,   1380, 1, 1 },
   2911   { 1961, 6,15,   1381, 1, 1 },
   2912   { 1962, 6, 4,   1382, 1, 1 },
   2913   { 1963, 5,24,   1383, 1, 1 },
   2914   { 1964, 5,13,   1384, 1, 1 },
   2915   { 1965, 5, 3,   1385, 1, 1 },
   2916   { 1966, 4,22,   1386, 1, 1 },
   2917   { 1967, 4,11,   1387, 1, 1 },
   2918   { 1968, 3,30,   1388, 1, 1 },
   2919   { 1969, 3,19,   1389, 1, 1 },
   2920   { 1970, 3, 9,   1390, 1, 1 },
   2921   { 1971, 2,27,   1391, 1, 1 },
   2922   { 1972, 2,16,   1392, 1, 1 },
   2923   { 1973, 2, 5,   1393, 1, 1 },
   2924   { 1974, 1,25,   1394, 1, 1 },
   2925   { 1975, 1,14,   1395, 1, 1 },
   2926   { 1976, 1, 3,   1396, 1, 1 },
   2927   { 1976,12,22,   1397, 1, 1 },
   2928   { 1977,12,12,   1398, 1, 1 },
   2929   { 1978,12, 1,   1399, 1, 1 },
   2930   { 1979,11,21,   1400, 1, 1 },
   2931   { 1980,11, 9,   1401, 1, 1 },
   2932   { 1981,10,29,   1402, 1, 1 },
   2933   { 1982,10,18,   1403, 1, 1 },
   2934   { 1983,10, 8,   1404, 1, 1 },
   2935   { 1984, 9,26,   1405, 1, 1 },
   2936   { 1985, 9,16,   1406, 1, 1 },
   2937   { 1986, 9, 6,   1407, 1, 1 },
   2938   { 1987, 8,26,   1408, 1, 1 },
   2939   { 1988, 8,14,   1409, 1, 1 },
   2940   { 1989, 8, 3,   1410, 1, 1 },
   2941   { 1990, 7,23,   1411, 1, 1 },
   2942   { 1991, 7,13,   1412, 1, 1 },
   2943   { 1992, 7, 2,   1413, 1, 1 },
   2944   { 1993, 6,21,   1414, 1, 1 },
   2945   { 1994, 6,11,   1415, 1, 1 },
   2946   { 1995, 5,31,   1416, 1, 1 },
   2947   { 1996, 5,19,   1417, 1, 1 },
   2948   { 1997, 5, 8,   1418, 1, 1 },
   2949   { 1998, 4,28,   1419, 1, 1 },
   2950   { 1999, 4,17,   1420, 1, 1 },
   2951   { 1999, 5,16,   1420, 2, 1 },
   2952   { 1999, 6,15,   1420, 3, 1 },
   2953   { 1999, 7,14,   1420, 4, 1 },
   2954   { 1999, 8,12,   1420, 5, 1 },
   2955   { 1999, 9,11,   1420, 6, 1 },
   2956   { 1999,10,10,   1420, 7, 1 },
   2957   { 1999,11, 9,   1420, 8, 1 },
   2958   { 1999,12, 9,   1420, 9, 1 },
   2959   { 2000, 1, 8,   1420,10, 1 },
   2960   { 2000, 2, 7,   1420,11, 1 },
   2961   { 2000, 3, 7,   1420,12, 1 },
   2962   { 2000, 4, 6,   1421, 1, 1 },
   2963   { 2000, 5, 5,   1421, 2, 1 },
   2964   { 2000, 6, 3,   1421, 3, 1 },
   2965   { 2000, 7, 3,   1421, 4, 1 },
   2966   { 2000, 8, 1,   1421, 5, 1 },
   2967   { 2000, 8,30,   1421, 6, 1 },
   2968   { 2000, 9,28,   1421, 7, 1 },
   2969   { 2000,10,28,   1421, 8, 1 },
   2970   { 2000,11,27,   1421, 9, 1 },
   2971   { 2000,12,27,   1421,10, 1 },
   2972   { 2001, 1,26,   1421,11, 1 },
   2973   { 2001, 2,24,   1421,12, 1 },
   2974   { 2001, 3,26,   1422, 1, 1 },
   2975   { 2001, 4,25,   1422, 2, 1 },
   2976   { 2001, 5,24,   1422, 3, 1 },
   2977   { 2001, 6,22,   1422, 4, 1 },
   2978   { 2001, 7,22,   1422, 5, 1 },
   2979   { 2001, 8,20,   1422, 6, 1 },
   2980   { 2001, 9,18,   1422, 7, 1 },
   2981   { 2001,10,17,   1422, 8, 1 },
   2982   { 2001,11,16,   1422, 9, 1 },
   2983   { 2001,12,16,   1422,10, 1 },
   2984   { 2002, 1,15,   1422,11, 1 },
   2985   { 2002, 2,13,   1422,12, 1 },
   2986   { 2002, 3,15,   1423, 1, 1 },
   2987   { 2002, 4,14,   1423, 2, 1 },
   2988   { 2002, 5,13,   1423, 3, 1 },
   2989   { 2002, 6,12,   1423, 4, 1 },
   2990   { 2002, 7,11,   1423, 5, 1 },
   2991   { 2002, 8,10,   1423, 6, 1 },
   2992   { 2002, 9, 8,   1423, 7, 1 },
   2993   { 2002,10, 7,   1423, 8, 1 },
   2994   { 2002,11, 6,   1423, 9, 1 },
   2995   { 2002,12, 5,   1423,10, 1 },
   2996   { 2003, 1, 4,   1423,11, 1 },
   2997   { 2003, 2, 2,   1423,12, 1 },
   2998   { 2003, 3, 4,   1424, 1, 1 },
   2999   { 2003, 4, 3,   1424, 2, 1 },
   3000   { 2003, 5, 2,   1424, 3, 1 },
   3001   { 2003, 6, 1,   1424, 4, 1 },
   3002   { 2003, 7, 1,   1424, 5, 1 },
   3003   { 2003, 7,30,   1424, 6, 1 },
   3004   { 2003, 8,29,   1424, 7, 1 },
   3005   { 2003, 9,27,   1424, 8, 1 },
   3006   { 2003,10,26,   1424, 9, 1 },
   3007   { 2003,11,25,   1424,10, 1 },
   3008   { 2003,12,24,   1424,11, 1 },
   3009   { 2004, 1,23,   1424,12, 1 },
   3010   { 2004, 2,21,   1425, 1, 1 },
   3011   { 2004, 3,22,   1425, 2, 1 },
   3012   { 2004, 4,20,   1425, 3, 1 },
   3013   { 2004, 5,20,   1425, 4, 1 },
   3014   { 2004, 6,19,   1425, 5, 1 },
   3015   { 2004, 7,18,   1425, 6, 1 },
   3016   { 2004, 8,17,   1425, 7, 1 },
   3017   { 2004, 9,15,   1425, 8, 1 },
   3018   { 2004,10,15,   1425, 9, 1 },
   3019   { 2004,11,14,   1425,10, 1 },
   3020   { 2004,12,13,   1425,11, 1 },
   3021   { 2005, 1,12,   1425,12, 1 },
   3022   { 2005, 2,10,   1426, 1, 1 },
   3023   { 2005, 3,11,   1426, 2, 1 },
   3024   { 2005, 4,10,   1426, 3, 1 },
   3025   { 2005, 5, 9,   1426, 4, 1 },
   3026   { 2005, 6, 8,   1426, 5, 1 },
   3027   { 2005, 7, 7,   1426, 6, 1 },
   3028   { 2005, 8, 6,   1426, 7, 1 },
   3029   { 2005, 9, 5,   1426, 8, 1 },
   3030   { 2005,10, 4,   1426, 9, 1 },
   3031   { 2005,11, 3,   1426,10, 1 },
   3032   { 2005,12, 3,   1426,11, 1 },
   3033   { 2006, 1, 1,   1426,12, 1 },
   3034   { 2006, 1,31,   1427, 1, 1 },
   3035   { 2006, 3, 1,   1427, 2, 1 },
   3036   { 2006, 3,30,   1427, 3, 1 },
   3037   { 2006, 4,29,   1427, 4, 1 },
   3038   { 2006, 5,28,   1427, 5, 1 },
   3039   { 2006, 6,27,   1427, 6, 1 },
   3040   { 2006, 7,26,   1427, 7, 1 },
   3041   { 2006, 8,25,   1427, 8, 1 },
   3042   { 2006, 9,24,   1427, 9, 1 },
   3043   { 2006,10,23,   1427,10, 1 },
   3044   { 2006,11,22,   1427,11, 1 },
   3045   { 2006,12,22,   1427,12, 1 },
   3046   { 2007, 1,20,   1428, 1, 1 },
   3047   { 2007, 2,19,   1428, 2, 1 },
   3048   { 2007, 3,20,   1428, 3, 1 },
   3049   { 2007, 4,18,   1428, 4, 1 },
   3050   { 2007, 5,18,   1428, 5, 1 },
   3051   { 2007, 6,16,   1428, 6, 1 },
   3052   { 2007, 7,15,   1428, 7, 1 },
   3053   { 2007, 8,14,   1428, 8, 1 },
   3054   { 2007, 9,13,   1428, 9, 1 },
   3055   { 2007,10,13,   1428,10, 1 },
   3056   { 2007,11,11,   1428,11, 1 },
   3057   { 2007,12,11,   1428,12, 1 },
   3058   { 2008, 1,10,   1429, 1, 1 },
   3059   { 2008, 2, 8,   1429, 2, 1 },
   3060   { 2008, 3, 9,   1429, 3, 1 },
   3061   { 2008, 4, 7,   1429, 4, 1 },
   3062   { 2008, 5, 6,   1429, 5, 1 },
   3063   { 2008, 6, 5,   1429, 6, 1 },
   3064   { 2008, 7, 4,   1429, 7, 1 },
   3065   { 2008, 8, 2,   1429, 8, 1 },
   3066   { 2008, 9, 1,   1429, 9, 1 },
   3067   { 2008,10, 1,   1429,10, 1 },
   3068   { 2008,10,30,   1429,11, 1 },
   3069   { 2008,11,29,   1429,12, 1 },
   3070   { 2008,12,29,   1430, 1, 1 },
   3071   { 2009, 1,27,   1430, 2, 1 },
   3072   { 2009, 2,26,   1430, 3, 1 },
   3073   { 2009, 3,28,   1430, 4, 1 },
   3074   { 2009, 4,26,   1430, 5, 1 },
   3075   { 2009, 5,25,   1430, 6, 1 },
   3076   { 2009, 6,24,   1430, 7, 1 },
   3077   { 2009, 7,23,   1430, 8, 1 },
   3078   { 2009, 8,22,   1430, 9, 1 },
   3079   { 2009, 9,20,   1430,10, 1 },
   3080   { 2009,10,20,   1430,11, 1 },
   3081   { 2009,11,18,   1430,12, 1 },
   3082   { 2009,12,18,   1431, 1, 1 },
   3083   { 2010, 1,16,   1431, 2, 1 },
   3084   { 2010, 2,15,   1431, 3, 1 },
   3085   { 2010, 3,17,   1431, 4, 1 },
   3086   { 2010, 4,15,   1431, 5, 1 },
   3087   { 2010, 5,15,   1431, 6, 1 },
   3088   { 2010, 6,13,   1431, 7, 1 },
   3089   { 2010, 7,13,   1431, 8, 1 },
   3090   { 2010, 8,11,   1431, 9, 1 },
   3091   { 2010, 9,10,   1431,10, 1 },
   3092   { 2010,10, 9,   1431,11, 1 },
   3093   { 2010,11, 7,   1431,12, 1 },
   3094   { 2010,12, 7,   1432, 1, 1 },
   3095   { 2011, 1, 5,   1432, 2, 1 },
   3096   { 2011, 2, 4,   1432, 3, 1 },
   3097   { 2011, 3, 6,   1432, 4, 1 },
   3098   { 2011, 4, 5,   1432, 5, 1 },
   3099   { 2011, 5, 4,   1432, 6, 1 },
   3100   { 2011, 6, 3,   1432, 7, 1 },
   3101   { 2011, 7, 2,   1432, 8, 1 },
   3102   { 2011, 8, 1,   1432, 9, 1 },
   3103   { 2011, 8,30,   1432,10, 1 },
   3104   { 2011, 9,29,   1432,11, 1 },
   3105   { 2011,10,28,   1432,12, 1 },
   3106   { 2011,11,26,   1433, 1, 1 },
   3107   { 2011,12,26,   1433, 2, 1 },
   3108   { 2012, 1,24,   1433, 3, 1 },
   3109   { 2012, 2,23,   1433, 4, 1 },
   3110   { 2012, 3,24,   1433, 5, 1 },
   3111   { 2012, 4,22,   1433, 6, 1 },
   3112   { 2012, 5,22,   1433, 7, 1 },
   3113   { 2012, 6,21,   1433, 8, 1 },
   3114   { 2012, 7,20,   1433, 9, 1 },
   3115   { 2012, 8,19,   1433,10, 1 },
   3116   { 2012, 9,17,   1433,11, 1 },
   3117   { 2012,10,17,   1433,12, 1 },
   3118   { 2012,11,15,   1434, 1, 1 },
   3119   { 2012,12,14,   1434, 2, 1 },
   3120   { 2013, 1,13,   1434, 3, 1 },
   3121   { 2013, 2,11,   1434, 4, 1 },
   3122   { 2013, 3,13,   1434, 5, 1 },
   3123   { 2013, 4,11,   1434, 6, 1 },
   3124   { 2013, 5,11,   1434, 7, 1 },
   3125   { 2013, 6,10,   1434, 8, 1 },
   3126   { 2013, 7, 9,   1434, 9, 1 },
   3127   { 2013, 8, 8,   1434,10, 1 },
   3128   { 2013, 9, 7,   1434,11, 1 },
   3129   { 2013,10, 6,   1434,12, 1 },
   3130   { 2013,11, 4,   1435, 1, 1 },
   3131   { 2013,12, 4,   1435, 2, 1 },
   3132   { 2014, 1, 2,   1435, 3, 1 },
   3133   { 2014, 2, 1,   1435, 4, 1 },
   3134   { 2014, 3, 2,   1435, 5, 1 },
   3135   { 2014, 4, 1,   1435, 6, 1 },
   3136   { 2014, 4,30,   1435, 7, 1 },
   3137   { 2014, 5,30,   1435, 8, 1 },
   3138   { 2014, 6,28,   1435, 9, 1 },
   3139   { 2014, 7,28,   1435,10, 1 },
   3140   { 2014, 8,27,   1435,11, 1 },
   3141   { 2014, 9,25,   1435,12, 1 },
   3142   { 2014,10,25,   1436, 1, 1 },
   3143   { 2014,11,23,   1436, 2, 1 },
   3144   { 2014,12,23,   1436, 3, 1 },
   3145   { 2015, 1,21,   1436, 4, 1 },
   3146   { 2015, 2,20,   1436, 5, 1 },
   3147   { 2015, 3,21,   1436, 6, 1 },
   3148   { 2015, 4,20,   1436, 7, 1 },
   3149   { 2015, 5,19,   1436, 8, 1 },
   3150   { 2015, 6,18,   1436, 9, 1 },
   3151   { 2015, 7,17,   1436,10, 1 },
   3152   { 2015, 8,16,   1436,11, 1 },
   3153   { 2015, 9,14,   1436,12, 1 },
   3154   { 2015,10,14,   1437, 1, 1 },
   3155   { 2015,11,13,   1437, 2, 1 },
   3156   { 2015,12,12,   1437, 3, 1 },
   3157   { 2016, 1,11,   1437, 4, 1 },
   3158   { 2016, 2,10,   1437, 5, 1 },
   3159   { 2016, 3,10,   1437, 6, 1 },
   3160   { 2016, 4, 8,   1437, 7, 1 },
   3161   { 2016, 5, 8,   1437, 8, 1 },
   3162   { 2016, 6, 6,   1437, 9, 1 },
   3163   { 2016, 7, 6,   1437,10, 1 },
   3164   { 2016, 8, 4,   1437,11, 1 },
   3165   { 2016, 9, 2,   1437,12, 1 },
   3166   { 2016,10, 2,   1438, 1, 1 },
   3167   { 2016,11, 1,   1438, 2, 1 },
   3168   { 2016,11,30,   1438, 3, 1 },
   3169   { 2016,12,30,   1438, 4, 1 },
   3170   { 2017, 1,29,   1438, 5, 1 },
   3171   { 2017, 2,28,   1438, 6, 1 },
   3172   { 2017, 3,29,   1438, 7, 1 },
   3173   { 2017, 4,27,   1438, 8, 1 },
   3174   { 2017, 5,27,   1438, 9, 1 },
   3175   { 2017, 6,25,   1438,10, 1 },
   3176   { 2017, 7,24,   1438,11, 1 },
   3177   { 2017, 8,23,   1438,12, 1 },
   3178   { 2017, 9,21,   1439, 1, 1 },
   3179   { 2017,10,21,   1439, 2, 1 },
   3180   { 2017,11,19,   1439, 3, 1 },
   3181   { 2017,12,19,   1439, 4, 1 },
   3182   { 2018, 1,18,   1439, 5, 1 },
   3183   { 2018, 2,17,   1439, 6, 1 },
   3184   { 2018, 3,18,   1439, 7, 1 },
   3185   { 2018, 4,17,   1439, 8, 1 },
   3186   { 2018, 5,16,   1439, 9, 1 },
   3187   { 2018, 6,15,   1439,10, 1 },
   3188   { 2018, 7,14,   1439,11, 1 },
   3189   { 2018, 8,12,   1439,12, 1 },
   3190   { 2018, 9,11,   1440, 1, 1 },
   3191   { 2019, 8,31,   1441, 1, 1 },
   3192   { 2020, 8,20,   1442, 1, 1 },
   3193   { 2021, 8, 9,   1443, 1, 1 },
   3194   { 2022, 7,30,   1444, 1, 1 },
   3195   { 2023, 7,19,   1445, 1, 1 },
   3196   { 2024, 7, 7,   1446, 1, 1 },
   3197   { 2025, 6,26,   1447, 1, 1 },
   3198   { 2026, 6,16,   1448, 1, 1 },
   3199   { 2027, 6, 6,   1449, 1, 1 },
   3200   { 2028, 5,25,   1450, 1, 1 },
   3201   { 2029, 5,14,   1451, 1, 1 },
   3202   { 2030, 5, 4,   1452, 1, 1 },
   3203   { 2031, 4,23,   1453, 1, 1 },
   3204   { 2032, 4,11,   1454, 1, 1 },
   3205   { 2033, 4, 1,   1455, 1, 1 },
   3206   { 2034, 3,22,   1456, 1, 1 },
   3207   { 2035, 3,11,   1457, 1, 1 },
   3208   { 2036, 2,29,   1458, 1, 1 },
   3209   { 2037, 2,17,   1459, 1, 1 },
   3210   { 2038, 2, 6,   1460, 1, 1 },
   3211   { 2039, 1,26,   1461, 1, 1 },
   3212   { 2040, 1,15,   1462, 1, 1 },
   3213   { 2041, 1, 4,   1463, 1, 1 },
   3214   { 2041,12,25,   1464, 1, 1 },
   3215   { 2042,12,14,   1465, 1, 1 },
   3216   { 2043,12, 3,   1466, 1, 1 },
   3217   { 2044,11,21,   1467, 1, 1 },
   3218   { 2045,11,11,   1468, 1, 1 },
   3219   { 2046,10,31,   1469, 1, 1 },
   3220   { 2047,10,21,   1470, 1, 1 },
   3221   { 2048,10, 9,   1471, 1, 1 },
   3222   { 2049, 9,29,   1472, 1, 1 },
   3223   { 2050, 9,18,   1473, 1, 1 },
   3224   { 2051, 9, 7,   1474, 1, 1 },
   3225   { 2052, 8,26,   1475, 1, 1 },
   3226   { 2053, 8,15,   1476, 1, 1 },
   3227   { 2054, 8, 5,   1477, 1, 1 },
   3228   { 2055, 7,26,   1478, 1, 1 },
   3229   { 2056, 7,14,   1479, 1, 1 },
   3230   { 2057, 7, 3,   1480, 1, 1 },
   3231   { 2058, 6,22,   1481, 1, 1 },
   3232   { 2059, 6,11,   1482, 1, 1 },
   3233   { 2061, 5,21,   1484, 1, 1 },
   3234   { 2063, 4,30,   1486, 1, 1 },
   3235   { 2065, 4, 7,   1488, 1, 1 },
   3236   { 2067, 3,17,   1490, 1, 1 },
   3237   { 2069, 2,23,   1492, 1, 1 },
   3238   { 2071, 2, 2,   1494, 1, 1 },
   3239   { 2073, 1,10,   1496, 1, 1 },
   3240   { 2074,12,20,   1498, 1, 1 },
   3241   { 2076,11,28,   1500, 1, 1 },
   3242   {    0, 0, 0,      0, 0, 0 }, // terminator
   3243 };
   3244 
   3245 static const UChar zoneSA[] = {0x41,0x73,0x69,0x61,0x2F,0x52,0x69,0x79,0x61,0x64,0x68,0}; // "Asia/Riyadh"
   3246 
   3247 void CalendarTest::TestIslamicUmAlQura() {
   3248 
   3249     UErrorCode status = U_ZERO_ERROR;
   3250     Locale umalquraLoc("ar_SA@calendar=islamic-umalqura");
   3251     Locale gregoLoc("ar_SA@calendar=gregorian");
   3252     TimeZone* tzSA = TimeZone::createTimeZone(UnicodeString(TRUE, zoneSA, -1));
   3253     Calendar* tstCal = Calendar::createInstance(*((const TimeZone *)tzSA), umalquraLoc, status);
   3254     Calendar* gregCal = Calendar::createInstance(*((const TimeZone *)tzSA), gregoLoc, status);
   3255 
   3256     IslamicCalendar* iCal = (IslamicCalendar*)tstCal;
   3257     if(strcmp(iCal->getType(), "islamic-umalqura") != 0) {
   3258         errln("wrong type of calendar created - %s", iCal->getType());
   3259     }
   3260 
   3261     int32_t firstYear = 1318;
   3262     int32_t lastYear = 1368;    // just enough to be pretty sure
   3263     //int32_t lastYear = 1480;    // the whole shootin' match
   3264 
   3265     tstCal->clear();
   3266     tstCal->setLenient(FALSE);
   3267 
   3268     int32_t day=0, month=0, year=0, initDay = 27, initMonth = IslamicCalendar::RAJAB, initYear = 1434;
   3269 
   3270     for( int32_t startYear = firstYear; startYear <= lastYear; startYear++) {
   3271         setAndTestWholeYear(tstCal, startYear, status);
   3272         status = U_ZERO_ERROR;
   3273     }
   3274 
   3275     initMonth = IslamicCalendar::RABI_2;
   3276     initDay = 5;
   3277     int32_t loopCnt = 25;
   3278     tstCal->clear();
   3279     setAndTestCalendar( tstCal, initMonth, initDay, initYear, status);
   3280     TEST_CHECK_STATUS;
   3281 
   3282     for(int x=1; x<=loopCnt; x++) {
   3283         day = tstCal->get(UCAL_DAY_OF_MONTH,status);
   3284         month = tstCal->get(UCAL_MONTH,status);
   3285         year = tstCal->get(UCAL_YEAR,status);
   3286         TEST_CHECK_STATUS;
   3287         tstCal->roll(UCAL_DAY_OF_MONTH, (UBool)TRUE, status);
   3288         TEST_CHECK_STATUS;
   3289     }
   3290 
   3291     if(day != (initDay + loopCnt - 1) || month != IslamicCalendar::RABI_2 || year != 1434)
   3292       errln("invalid values for RABI_2 date after roll of %d", loopCnt);
   3293 
   3294     status = U_ZERO_ERROR;
   3295     tstCal->clear();
   3296     initMonth = 2;
   3297     initDay = 30;
   3298     setAndTestCalendar( tstCal, initMonth, initDay, initYear, status);
   3299     if(U_SUCCESS(status)) {
   3300         errln("error NOT detected status %i",status);
   3301         errln("      init values:\tmonth %i\tday %i\tyear %i", initMonth, initDay, initYear);
   3302         int32_t day = tstCal->get(UCAL_DAY_OF_MONTH, status);
   3303         int32_t month = tstCal->get(UCAL_MONTH, status);
   3304         int32_t year = tstCal->get(UCAL_YEAR, status);
   3305         errln("values post set():\tmonth %i\tday %i\tyear %i",month, day, year);
   3306     }
   3307 
   3308     status = U_ZERO_ERROR;
   3309     tstCal->clear();
   3310     initMonth = 3;
   3311     initDay = 30;
   3312     setAndTestCalendar( tstCal, initMonth, initDay, initYear, status);
   3313     TEST_CHECK_STATUS;
   3314 
   3315     SimpleDateFormat* formatter = new SimpleDateFormat("yyyy-MM-dd", Locale::getUS(), status);
   3316     UDate date = formatter->parse("1975-05-06", status);
   3317     Calendar* is_cal = Calendar::createInstance(umalquraLoc, status);
   3318     is_cal->setTime(date, status);
   3319     int32_t is_day = is_cal->get(UCAL_DAY_OF_MONTH,status);
   3320     int32_t is_month = is_cal->get(UCAL_MONTH,status);
   3321     int32_t is_year = is_cal->get(UCAL_YEAR,status);
   3322     TEST_CHECK_STATUS;
   3323     if(is_day != 24 || is_month != IslamicCalendar::RABI_2 || is_year != 1395)
   3324         errln("unexpected conversion date month %i not %i or day %i not 24 or year %i not 1395", is_month, IslamicCalendar::RABI_2, is_day, is_year);
   3325 
   3326     UDate date2 = is_cal->getTime(status);
   3327     TEST_CHECK_STATUS;
   3328     if(date2 != date) {
   3329         errln("before(%f) and after(%f) dates don't match up!",date, date2);
   3330     }
   3331 
   3332     // check against data
   3333     const GregoUmmAlQuraMap* guMapPtr;
   3334     gregCal->clear();
   3335     tstCal->clear();
   3336     for (guMapPtr = guMappings; guMapPtr->gYear != 0; guMapPtr++) {
   3337         status = U_ZERO_ERROR;
   3338         gregCal->set(guMapPtr->gYear, guMapPtr->gMon - 1, guMapPtr->gDay, 12, 0);
   3339         date = gregCal->getTime(status);
   3340         tstCal->setTime(date, status);
   3341         int32_t uYear = tstCal->get(UCAL_YEAR, status);
   3342         int32_t uMon = tstCal->get(UCAL_MONTH, status) + 1;
   3343         int32_t uDay = tstCal->get(UCAL_DATE, status);
   3344         if(U_FAILURE(status)) {
   3345             errln("For gregorian %4d-%02d-%02d, get status %s",
   3346                     guMapPtr->gYear, guMapPtr->gMon, guMapPtr->gDay, u_errorName(status) );
   3347         } else if (uYear != guMapPtr->uYear || uMon != guMapPtr->uMon || uDay != guMapPtr->uDay) {
   3348             errln("For gregorian %4d-%02d-%02d, expect umalqura %4d-%02d-%02d, get %4d-%02d-%02d",
   3349                     guMapPtr->gYear, guMapPtr->gMon, guMapPtr->gDay,
   3350                     guMapPtr->uYear, guMapPtr->uMon, guMapPtr->uDay, uYear, uMon, uDay );
   3351         }
   3352     }
   3353 
   3354     delete is_cal;
   3355     delete formatter;
   3356     delete gregCal;
   3357     delete tstCal;
   3358     delete tzSA;
   3359 }
   3360 
   3361 void CalendarTest::TestIslamicTabularDates() {
   3362     UErrorCode status = U_ZERO_ERROR;
   3363     Locale islamicLoc("ar_SA@calendar=islamic-civil");
   3364     Locale tblaLoc("ar_SA@calendar=islamic-tbla");
   3365     SimpleDateFormat* formatter = new SimpleDateFormat("yyyy-MM-dd", Locale::getUS(), status);
   3366     UDate date = formatter->parse("1975-05-06", status);
   3367 
   3368     Calendar* tstCal = Calendar::createInstance(islamicLoc, status);
   3369     tstCal->setTime(date, status);
   3370     int32_t is_day = tstCal->get(UCAL_DAY_OF_MONTH,status);
   3371     int32_t is_month = tstCal->get(UCAL_MONTH,status);
   3372     int32_t is_year = tstCal->get(UCAL_YEAR,status);
   3373     TEST_CHECK_STATUS;
   3374     delete tstCal;
   3375 
   3376     tstCal = Calendar::createInstance(tblaLoc, status);
   3377     tstCal->setTime(date, status);
   3378     int32_t tbla_day = tstCal->get(UCAL_DAY_OF_MONTH,status);
   3379     int32_t tbla_month = tstCal->get(UCAL_MONTH,status);
   3380     int32_t tbla_year = tstCal->get(UCAL_YEAR,status);
   3381     TEST_CHECK_STATUS;
   3382 
   3383     if(tbla_month != is_month || tbla_year != is_year)
   3384         errln("unexpected difference between islamic and tbla month %d : %d and/or year %d : %d",tbla_month,is_month,tbla_year,is_year);
   3385 
   3386     if(tbla_day - is_day != 1)
   3387         errln("unexpected day difference between islamic and tbla: %d : %d ",tbla_day,is_day);
   3388     delete tstCal;
   3389     delete formatter;
   3390 }
   3391 
   3392 void CalendarTest::TestHebrewMonthValidation() {
   3393     UErrorCode status = U_ZERO_ERROR;
   3394     LocalPointer<Calendar>  cal(Calendar::createInstance(Locale::createFromName("he_IL@calendar=hebrew"), status));
   3395     if (failure(status, "Calendar::createInstance, locale:he_IL@calendar=hebrew", TRUE)) return;
   3396     Calendar *pCal = cal.getAlias();
   3397 
   3398     UDate d;
   3399     pCal->setLenient(FALSE);
   3400 
   3401     // 5776 is a leap year and has month Adar I
   3402     pCal->set(5776, HebrewCalendar::ADAR_1, 1);
   3403     d = pCal->getTime(status);
   3404     if (U_FAILURE(status)) {
   3405         errln("Fail: 5776 Adar I 1 is a valid date.");
   3406     }
   3407     status = U_ZERO_ERROR;
   3408 
   3409     // 5777 is NOT a lear year and does not have month Adar I
   3410     pCal->set(5777, HebrewCalendar::ADAR_1, 1);
   3411     d = pCal->getTime(status);
   3412     (void)d;
   3413     if (status == U_ILLEGAL_ARGUMENT_ERROR) {
   3414         logln("Info: U_ILLEGAL_ARGUMENT_ERROR, because 5777 Adar I 1 is not a valid date.");
   3415     } else {
   3416         errln("Fail: U_ILLEGAL_ARGUMENT_ERROR should be set for input date 5777 Adar I 1.");
   3417     }
   3418 }
   3419 
   3420 void CalendarTest::TestWeekData() {
   3421     // Each line contains two locales using the same set of week rule data.
   3422     const char* LOCALE_PAIRS[] = {
   3423         "en",       "en_US",
   3424         "de",       "de_DE",
   3425         "de_DE",    "en_DE",
   3426         "en_GB",    "und_GB",
   3427         "ar_EG",    "en_EG",
   3428         "ar_SA",    "fr_SA",
   3429         0
   3430     };
   3431 
   3432     UErrorCode status;
   3433 
   3434     for (int32_t i = 0; LOCALE_PAIRS[i] != 0; i += 2) {
   3435         status = U_ZERO_ERROR;
   3436         LocalPointer<Calendar>  cal1(Calendar::createInstance(LOCALE_PAIRS[i], status));
   3437         LocalPointer<Calendar>  cal2(Calendar::createInstance(LOCALE_PAIRS[i + 1], status));
   3438         TEST_CHECK_STATUS_LOCALE(LOCALE_PAIRS[i]);
   3439 
   3440         // First day of week
   3441         UCalendarDaysOfWeek dow1 = cal1->getFirstDayOfWeek(status);
   3442         UCalendarDaysOfWeek dow2 = cal2->getFirstDayOfWeek(status);
   3443         TEST_CHECK_STATUS;
   3444         TEST_ASSERT(dow1 == dow2);
   3445 
   3446         // Minimum days in first week
   3447         uint8_t minDays1 = cal1->getMinimalDaysInFirstWeek();
   3448         uint8_t minDays2 = cal2->getMinimalDaysInFirstWeek();
   3449         TEST_ASSERT(minDays1 == minDays2);
   3450 
   3451         // Weekdays and Weekends
   3452         for (int32_t d = UCAL_SUNDAY; d <= UCAL_SATURDAY; d++) {
   3453             status = U_ZERO_ERROR;
   3454             UCalendarWeekdayType wdt1 = cal1->getDayOfWeekType((UCalendarDaysOfWeek)d, status);
   3455             UCalendarWeekdayType wdt2 = cal2->getDayOfWeekType((UCalendarDaysOfWeek)d, status);
   3456             TEST_CHECK_STATUS;
   3457             TEST_ASSERT(wdt1 == wdt2);
   3458         }
   3459     }
   3460 }
   3461 
   3462 typedef struct {
   3463     const char* zone;
   3464     const CalFields base;
   3465     int32_t deltaDays;
   3466     UCalendarWallTimeOption skippedWTOpt;
   3467     const CalFields expected;
   3468 } TestAddAcrossZoneTransitionData;
   3469 
   3470 static const TestAddAcrossZoneTransitionData AAZTDATA[] =
   3471 {
   3472     // Time zone                Base wall time                      day(s)  Skipped time options
   3473     //                          Expected wall time
   3474 
   3475     // Add 1 day, from the date before DST transition
   3476     {"America/Los_Angeles",     CalFields(2014,3,8,1,59,59,999),    1,      UCAL_WALLTIME_FIRST,
   3477                                 CalFields(2014,3,9,1,59,59,999)},
   3478 
   3479     {"America/Los_Angeles",     CalFields(2014,3,8,1,59,59,999),    1,      UCAL_WALLTIME_LAST,
   3480                                 CalFields(2014,3,9,1,59,59,999)},
   3481 
   3482     {"America/Los_Angeles",     CalFields(2014,3,8,1,59,59,999),    1,      UCAL_WALLTIME_NEXT_VALID,
   3483                                 CalFields(2014,3,9,1,59,59,999)},
   3484 
   3485 
   3486     {"America/Los_Angeles",     CalFields(2014,3,8,2,0,0,0),        1,      UCAL_WALLTIME_FIRST,
   3487                                 CalFields(2014,3,9,1,0,0,0)},
   3488 
   3489     {"America/Los_Angeles",     CalFields(2014,3,8,2,0,0,0),        1,      UCAL_WALLTIME_LAST,
   3490                                 CalFields(2014,3,9,3,0,0,0)},
   3491 
   3492     {"America/Los_Angeles",     CalFields(2014,3,8,2,0,0,0),        1,      UCAL_WALLTIME_NEXT_VALID,
   3493                                 CalFields(2014,3,9,3,0,0,0)},
   3494 
   3495 
   3496     {"America/Los_Angeles",     CalFields(2014,3,8,2,30,0,0),       1,      UCAL_WALLTIME_FIRST,
   3497                                 CalFields(2014,3,9,1,30,0,0)},
   3498 
   3499     {"America/Los_Angeles",     CalFields(2014,3,8,2,30,0,0),       1,      UCAL_WALLTIME_LAST,
   3500                                 CalFields(2014,3,9,3,30,0,0)},
   3501 
   3502     {"America/Los_Angeles",     CalFields(2014,3,8,2,30,0,0),       1,      UCAL_WALLTIME_NEXT_VALID,
   3503                                 CalFields(2014,3,9,3,0,0,0)},
   3504 
   3505 
   3506     {"America/Los_Angeles",     CalFields(2014,3,8,3,0,0,0),        1,      UCAL_WALLTIME_FIRST,
   3507                                 CalFields(2014,3,9,3,0,0,0)},
   3508 
   3509     {"America/Los_Angeles",     CalFields(2014,3,8,3,0,0,0),        1,      UCAL_WALLTIME_LAST,
   3510                                 CalFields(2014,3,9,3,0,0,0)},
   3511 
   3512     {"America/Los_Angeles",     CalFields(2014,3,8,3,0,0,0),        1,      UCAL_WALLTIME_NEXT_VALID,
   3513                                 CalFields(2014,3,9,3,0,0,0)},
   3514 
   3515     // Subtract 1 day, from one day after DST transition
   3516     {"America/Los_Angeles",     CalFields(2014,3,10,1,59,59,999),   -1,     UCAL_WALLTIME_FIRST,
   3517                                 CalFields(2014,3,9,1,59,59,999)},
   3518 
   3519     {"America/Los_Angeles",     CalFields(2014,3,10,1,59,59,999),   -1,     UCAL_WALLTIME_LAST,
   3520                                 CalFields(2014,3,9,1,59,59,999)},
   3521 
   3522     {"America/Los_Angeles",     CalFields(2014,3,10,1,59,59,999),   -1,     UCAL_WALLTIME_NEXT_VALID,
   3523                                 CalFields(2014,3,9,1,59,59,999)},
   3524 
   3525 
   3526     {"America/Los_Angeles",     CalFields(2014,3,10,2,0,0,0),       -1,     UCAL_WALLTIME_FIRST,
   3527                                 CalFields(2014,3,9,1,0,0,0)},
   3528 
   3529     {"America/Los_Angeles",     CalFields(2014,3,10,2,0,0,0),       -1,     UCAL_WALLTIME_LAST,
   3530                                 CalFields(2014,3,9,3,0,0,0)},
   3531 
   3532     {"America/Los_Angeles",     CalFields(2014,3,10,2,0,0,0),       -1,     UCAL_WALLTIME_NEXT_VALID,
   3533                                 CalFields(2014,3,9,3,0,0,0)},
   3534 
   3535 
   3536     {"America/Los_Angeles",     CalFields(2014,3,10,2,30,0,0),      -1,     UCAL_WALLTIME_FIRST,
   3537                                 CalFields(2014,3,9,1,30,0,0)},
   3538 
   3539     {"America/Los_Angeles",     CalFields(2014,3,10,2,30,0,0),      -1,     UCAL_WALLTIME_LAST,
   3540                                 CalFields(2014,3,9,3,30,0,0)},
   3541 
   3542     {"America/Los_Angeles",     CalFields(2014,3,10,2,30,0,0),      -1,     UCAL_WALLTIME_NEXT_VALID,
   3543                                 CalFields(2014,3,9,3,0,0,0)},
   3544 
   3545 
   3546     {"America/Los_Angeles",     CalFields(2014,3,10,3,0,0,0),       -1,     UCAL_WALLTIME_FIRST,
   3547                                 CalFields(2014,3,9,3,0,0,0)},
   3548 
   3549     {"America/Los_Angeles",     CalFields(2014,3,10,3,0,0,0),       -1,     UCAL_WALLTIME_LAST,
   3550                                 CalFields(2014,3,9,3,0,0,0)},
   3551 
   3552     {"America/Los_Angeles",     CalFields(2014,3,10,3,0,0,0),       -1,     UCAL_WALLTIME_NEXT_VALID,
   3553                                 CalFields(2014,3,9,3,0,0,0)},
   3554 
   3555 
   3556     // Test case for ticket#10544
   3557     {"America/Santiago",        CalFields(2013,4,27,0,0,0,0),       134,    UCAL_WALLTIME_FIRST,
   3558                                 CalFields(2013,9,7,23,0,0,0)},
   3559 
   3560     {"America/Santiago",        CalFields(2013,4,27,0,0,0,0),       134,    UCAL_WALLTIME_LAST,
   3561                                 CalFields(2013,9,8,1,0,0,0)},
   3562 
   3563     {"America/Santiago",        CalFields(2013,4,27,0,0,0,0),       134,    UCAL_WALLTIME_NEXT_VALID,
   3564                                 CalFields(2013,9,8,1,0,0,0)},
   3565 
   3566 
   3567     {"America/Santiago",        CalFields(2013,4,27,0,30,0,0),      134,    UCAL_WALLTIME_FIRST,
   3568                                 CalFields(2013,9,7,23,30,0,0)},
   3569 
   3570     {"America/Santiago",        CalFields(2013,4,27,0,30,0,0),      134,    UCAL_WALLTIME_LAST,
   3571                                 CalFields(2013,9,8,1,30,0,0)},
   3572 
   3573     {"America/Santiago",        CalFields(2013,4,27,0,30,0,0),      134,    UCAL_WALLTIME_NEXT_VALID,
   3574                                 CalFields(2013,9,8,1,0,0,0)},
   3575 
   3576 
   3577     // Extreme transition - Pacific/Apia completely skips 2011-12-30
   3578     {"Pacific/Apia",            CalFields(2011,12,29,0,0,0,0),      1,      UCAL_WALLTIME_FIRST,
   3579                                 CalFields(2011,12,31,0,0,0,0)},
   3580 
   3581     {"Pacific/Apia",            CalFields(2011,12,29,0,0,0,0),      1,      UCAL_WALLTIME_LAST,
   3582                                 CalFields(2011,12,31,0,0,0,0)},
   3583 
   3584     {"Pacific/Apia",            CalFields(2011,12,29,0,0,0,0),      1,      UCAL_WALLTIME_NEXT_VALID,
   3585                                 CalFields(2011,12,31,0,0,0,0)},
   3586 
   3587 
   3588     {"Pacific/Apia",            CalFields(2011,12,31,12,0,0,0),     -1,     UCAL_WALLTIME_FIRST,
   3589                                 CalFields(2011,12,29,12,0,0,0)},
   3590 
   3591     {"Pacific/Apia",            CalFields(2011,12,31,12,0,0,0),     -1,     UCAL_WALLTIME_LAST,
   3592                                 CalFields(2011,12,29,12,0,0,0)},
   3593 
   3594     {"Pacific/Apia",            CalFields(2011,12,31,12,0,0,0),     -1,     UCAL_WALLTIME_NEXT_VALID,
   3595                                 CalFields(2011,12,29,12,0,0,0)},
   3596 
   3597 
   3598     // 30 minutes DST - Australia/Lord_Howe
   3599     {"Australia/Lord_Howe",     CalFields(2013,10,5,2,15,0,0),      1,      UCAL_WALLTIME_FIRST,
   3600                                 CalFields(2013,10,6,1,45,0,0)},
   3601 
   3602     {"Australia/Lord_Howe",     CalFields(2013,10,5,2,15,0,0),      1,      UCAL_WALLTIME_LAST,
   3603                                 CalFields(2013,10,6,2,45,0,0)},
   3604 
   3605     {"Australia/Lord_Howe",     CalFields(2013,10,5,2,15,0,0),      1,      UCAL_WALLTIME_NEXT_VALID,
   3606                                 CalFields(2013,10,6,2,30,0,0)},
   3607 
   3608     {NULL, CalFields(0,0,0,0,0,0,0), 0, UCAL_WALLTIME_LAST, CalFields(0,0,0,0,0,0,0)}
   3609 };
   3610 
   3611 void CalendarTest::TestAddAcrossZoneTransition() {
   3612     UErrorCode status = U_ZERO_ERROR;
   3613     GregorianCalendar cal(status);
   3614     TEST_CHECK_STATUS;
   3615 
   3616     for (int32_t i = 0; AAZTDATA[i].zone; i++) {
   3617         status = U_ZERO_ERROR;
   3618         TimeZone *tz = TimeZone::createTimeZone(AAZTDATA[i].zone);
   3619         cal.adoptTimeZone(tz);
   3620         cal.setSkippedWallTimeOption(AAZTDATA[i].skippedWTOpt);
   3621         AAZTDATA[i].base.setTo(cal);
   3622         cal.add(UCAL_DATE, AAZTDATA[i].deltaDays, status);
   3623         TEST_CHECK_STATUS;
   3624 
   3625         if (!AAZTDATA[i].expected.isEquivalentTo(cal, status)) {
   3626             CalFields res(cal, status);
   3627             TEST_CHECK_STATUS;
   3628             char buf[32];
   3629             const char *optDisp = AAZTDATA[i].skippedWTOpt == UCAL_WALLTIME_FIRST ? "FIRST" :
   3630                     AAZTDATA[i].skippedWTOpt == UCAL_WALLTIME_LAST ? "LAST" : "NEXT_VALID";
   3631             dataerrln(UnicodeString("Error: base:") + AAZTDATA[i].base.toString(buf, sizeof(buf)) + ", tz:" + AAZTDATA[i].zone
   3632                         + ", delta:" + AAZTDATA[i].deltaDays + " day(s), opt:" + optDisp
   3633                         + ", result:" + res.toString(buf, sizeof(buf))
   3634                         + " - expected:" + AAZTDATA[i].expected.toString(buf, sizeof(buf)));
   3635         }
   3636     }
   3637 }
   3638 
   3639 // Data in a separate file (Gregorian to Chinese lunar map)
   3640 #define INCLUDED_FROM_CALTEST_CPP
   3641 #include "caltestdata.h"
   3642 
   3643 void CalendarTest::TestChineseCalendarMapping() {
   3644     UErrorCode status = U_ZERO_ERROR;
   3645     LocalPointer<TimeZone> zone(TimeZone::createTimeZone(UnicodeString("China")));
   3646     Locale locEnCalGregory = Locale::createFromName("en@calendar=gregorian");
   3647     Locale locEnCalChinese = Locale::createFromName("en@calendar=chinese");
   3648     LocalPointer<Calendar>  calGregory(Calendar::createInstance(zone->clone(), locEnCalGregory, status));
   3649     LocalPointer<Calendar>  calChinese(Calendar::createInstance(zone.orphan(), locEnCalChinese, status));
   3650     if ( U_FAILURE(status) ) {
   3651         errln("Fail: Calendar::createInstance fails for en with calendar=gregorian or calendar=chinese: %s", u_errorName(status));
   3652     } else {
   3653         const GregoToLunar * mapPtr = gregoToLunar; // in "caltestdata.h" included above
   3654         calGregory->clear();
   3655         calChinese->clear();
   3656         for (; mapPtr->gyr != 0; mapPtr++) {
   3657             status = U_ZERO_ERROR;
   3658             calGregory->set(mapPtr->gyr, mapPtr->gmo - 1, mapPtr->gda, 8, 0);
   3659             UDate date = calGregory->getTime(status);
   3660             calChinese->setTime(date, status);
   3661             if ( U_FAILURE(status) ) {
   3662                 errln("Fail: for Gregorian %4d-%02d-%02d, calGregory->getTime or calChinese->setTime reports: %s",
   3663                         mapPtr->gyr, mapPtr->gmo, mapPtr->gda, u_errorName(status));
   3664                 continue;
   3665             }
   3666             int32_t era = calChinese->get(UCAL_ERA, status);
   3667             int32_t yr  = calChinese->get(UCAL_YEAR, status);
   3668             int32_t mo  = calChinese->get(UCAL_MONTH, status) + 1;
   3669             int32_t lp  = calChinese->get(UCAL_IS_LEAP_MONTH, status);
   3670             int32_t da  = calChinese->get(UCAL_DATE, status);
   3671             if ( U_FAILURE(status) ) {
   3672                 errln("Fail: for Gregorian %4d-%02d-%02d, calChinese->get (for era, yr, mo, leapmo, da) reports: %s",
   3673                         mapPtr->gyr, mapPtr->gmo, mapPtr->gda, u_errorName(status));
   3674                 continue;
   3675             }
   3676             if (yr != mapPtr->cyr || mo != mapPtr->cmo || lp != mapPtr->clp || da != mapPtr->cda) {
   3677                 errln("Fail: for Gregorian %4d-%02d-%02d, expected Chinese %2d-%02d(%d)-%02d, got %2d-%02d(%d)-%02d",
   3678                         mapPtr->gyr, mapPtr->gmo, mapPtr->gda, mapPtr->cyr, mapPtr->cmo, mapPtr->clp, mapPtr->cda, yr, mo, lp, da);
   3679                 continue;
   3680             }
   3681             // If Grego->Chinese worked, try reverse mapping
   3682             calChinese->set(UCAL_ERA, era);
   3683             calChinese->set(UCAL_YEAR, mapPtr->cyr);
   3684             calChinese->set(UCAL_MONTH, mapPtr->cmo - 1);
   3685             calChinese->set(UCAL_IS_LEAP_MONTH, mapPtr->clp);
   3686             calChinese->set(UCAL_DATE, mapPtr->cda);
   3687             calChinese->set(UCAL_HOUR_OF_DAY, 8);
   3688             date = calChinese->getTime(status);
   3689             calGregory->setTime(date, status);
   3690             if ( U_FAILURE(status) ) {
   3691                 errln("Fail: for Chinese %2d-%02d(%d)-%02d, calChinese->getTime or calGregory->setTime reports: %s",
   3692                         mapPtr->cyr, mapPtr->cmo, mapPtr->clp, mapPtr->cda, u_errorName(status));
   3693                 continue;
   3694             }
   3695             yr  = calGregory->get(UCAL_YEAR, status);
   3696             mo  = calGregory->get(UCAL_MONTH, status) + 1;
   3697             da  = calGregory->get(UCAL_DATE, status);
   3698             if ( U_FAILURE(status) ) {
   3699                 errln("Fail: for Chinese %2d-%02d(%d)-%02d, calGregory->get (for yr, mo, da) reports: %s",
   3700                         mapPtr->cyr, mapPtr->cmo, mapPtr->clp, mapPtr->cda, u_errorName(status));
   3701                 continue;
   3702             }
   3703             if (yr != mapPtr->gyr || mo != mapPtr->gmo || da != mapPtr->gda) {
   3704                 errln("Fail: for Chinese %2d-%02d(%d)-%02d, Gregorian %4d-%02d-%02d, got %4d-%02d-%02d",
   3705                         mapPtr->cyr, mapPtr->cmo, mapPtr->clp, mapPtr->cda, mapPtr->gyr, mapPtr->gmo, mapPtr->gda, yr, mo, da);
   3706                 continue;
   3707             }
   3708         }
   3709     }
   3710 }
   3711 
   3712 #endif /* #if !UCONFIG_NO_FORMATTING */
   3713 
   3714 //eof
   3715