Lines Matching refs:status
27 if (U_FAILURE(status)) { \
28 if (status == U_MISSING_RESOURCE_ERROR) { \
29 dataerrln("%s:%d: Test failure. status=%s", __FILE__, __LINE__, u_errorName(status)); \
31 errln("%s:%d: Test failure. status=%s", __FILE__, __LINE__, u_errorName(status)); \
43 UErrorCode status = U_ZERO_ERROR;
47 out += (UnicodeString("") + fieldName((UCalendarDateFields)i) + "=" + cal.get((UCalendarDateFields)i, status) + UnicodeString(" "));
51 if(cal.inDaylightTime(status)) {
60 d = cal.getTime(status);
365 UErrorCode status = U_ZERO_ERROR;
376 Calendar *cal = Calendar::createInstance(zone->clone(), status);
377 if (failure(status, "Calendar::createInstance", TRUE)) return;
381 Calendar *cal2 = Calendar::createInstance(cal->getTimeZone(), status);
382 if (failure(status, "Calendar::createInstance")) return;
383 cal->setTime(when, status);
384 cal2->setTime(when, status);
385 if (failure(status, "Calendar::setTime")) return;
389 if (!cal->equals(*cal2, status) ||
390 cal->before(*cal2, status) ||
391 cal->after(*cal2, status) ||
392 U_FAILURE(status)) errln("FAIL: equals/before/after failed");
394 logln(UnicodeString("cal=") +cal->getTime(status) + UnicodeString(calToStr(*cal)));
395 logln(UnicodeString("cal2=") +cal2->getTime(status) + UnicodeString(calToStr(*cal2)));
397 cal2->setTime(when + 1000, status);
398 logln(UnicodeString("cal2=") +cal2->getTime(status) + UnicodeString(calToStr(*cal2)));
400 if (failure(status, "Calendar::setTime")) return;
401 if (cal->equals(*cal2, status) ||
402 cal2->before(*cal, status) ||
403 cal->after(*cal2, status) ||
404 U_FAILURE(status)) errln("FAIL: equals/before/after failed after setTime(+1000)");
407 cal->roll(UCAL_SECOND, (UBool) TRUE, status);
408 logln(UnicodeString("cal=") +cal->getTime(status) + UnicodeString(calToStr(*cal)));
409 cal->roll(UCAL_SECOND, (int32_t)0, status);
410 logln(UnicodeString("cal=") +cal->getTime(status) + UnicodeString(calToStr(*cal)));
411 if (failure(status, "Calendar::roll")) return;
413 if (!(eq=cal->equals(*cal2, status)) ||
414 (b4=cal->before(*cal2, status)) ||
415 (af=cal->after(*cal2, status)) ||
416 U_FAILURE(status)) {
421 logln(UnicodeString("cal=") +cal->getTime(status) + UnicodeString(calToStr(*cal)));
422 logln(UnicodeString("cal2=") +cal2->getTime(status) + UnicodeString(calToStr(*cal2)));
426 cal->roll(UCAL_MONTH, (int32_t)(1 + UCAL_DECEMBER - cal->get(UCAL_MONTH, status)), status);
427 if (failure(status, "Calendar::roll")) return;
428 if (cal->equals(*cal2, status) ||
429 cal2->before(*cal, status) ||
430 cal->after(*cal2, status) ||
431 U_FAILURE(status)) errln("FAIL: equals/before/after failed after rollback to January");
452 if (cal->getFirstDayOfWeek(aStatus) != i || U_FAILURE(aStatus)) errln("FAIL: getFirstDayOfWeek(status) failed");
474 if (cal->getTime(status) != date(84, 5, 24) || U_FAILURE(status))
479 if (cal->getTime(status) != date(85, 3, 2, 11, 49) || U_FAILURE(status))
484 if (cal->getTime(status) != date(95, 9, 12, 1, 39, 55) || U_FAILURE(status))
487 cal->getTime(status);
488 if (failure(status, "Calendar::getTime")) return;
504 if(cal->getActualMinimum(Calendar::SECOND, status) != 0){
508 Calendar *cal3 = Calendar::createInstance(status);
509 cal3->roll(Calendar::SECOND, (int32_t)0, status);
510 if (failure(status, "Calendar::roll(EDateFields, int32_t, UErrorCode)")) return;
526 cal = Calendar::createInstance(loc[i], status);
527 if (failure(status, "Calendar::createInstance")) return;
532 cal = Calendar::createInstance(TimeZone::createDefault(), Locale::getEnglish(), status);
533 if (failure(status, "Calendar::createInstance")) return;
536 cal = Calendar::createInstance(*zone, Locale::getEnglish(), status);
537 if (failure(status, "Calendar::createInstance")) return;
540 GregorianCalendar *gc = new GregorianCalendar(*zone, status);
541 if (failure(status, "new GregorianCalendar")) return;
544 gc = new GregorianCalendar(Locale::getEnglish(), status);
545 if (failure(status, "new GregorianCalendar")) return;
548 gc = new GregorianCalendar(Locale::getEnglish(), status);
551 gc = new GregorianCalendar(*zone, Locale::getEnglish(), status);
552 if (failure(status, "new GregorianCalendar")) return;
555 gc = new GregorianCalendar(zone, status);
556 if (failure(status, "new GregorianCalendar")) return;
559 gc = new GregorianCalendar(1998, 10, 14, 21, 43, status);
560 if (gc->getTime(status) != (d =date(98, 10, 14, 21, 43) )|| U_FAILURE(status))
561 errln("FAIL: new GregorianCalendar(ymdhm) failed with " + UnicodeString(u_errorName(status)) + ", cal=" + gc->getTime(status) + UnicodeString(calToStr(*gc)) + ", d=" + d);
563 logln(UnicodeString("GOOD: cal=") +gc->getTime(status) + UnicodeString(calToStr(*gc)) + ", d=" + d);
566 gc = new GregorianCalendar(1998, 10, 14, 21, 43, 55, status);
567 if (gc->getTime(status) != (d=date(98, 10, 14, 21, 43, 55)) || U_FAILURE(status))
568 errln("FAIL: new GregorianCalendar(ymdhms) failed with " + UnicodeString(u_errorName(status)));
570 GregorianCalendar gc2(Locale::getEnglish(), status);
571 if (failure(status, "new GregorianCalendar")) return;
578 cal = Calendar::createInstance(status);
579 if (failure(status, "Calendar::createInstance")) {
582 ((Calendar *)cal)->roll(UCAL_HOUR, (int32_t)100, status);
585 URegistryKey key = cal->registerFactory(NULL, status);
586 cal->unregister(key, status);
591 status = U_ZERO_ERROR;
592 cal = Calendar::createInstance(Locale("he_IL@calendar=hebrew"), status);
593 if (failure(status, "Calendar::createInstance")) {
596 cal->roll(Calendar::MONTH, (int32_t)100, status);
600 Calendar::getKeywordValuesForLocale("calendar", Locale("he"), FALSE, status));
601 if (values.isNull() || U_FAILURE(status)) {
602 dataerrln("FAIL: Calendar::getKeywordValuesForLocale(he): %s", u_errorName(status));
607 while ((charValue = values->next(&valueLength, status)) != NULL) {
616 values->reset(status);
620 while ((ucharValue = values->unext(&valueLength, status)) != NULL) {
630 values->reset(status);
633 while ((stringValue = values->snext(status)) != NULL) {
654 UErrorCode status = U_ZERO_ERROR;
655 GregorianCalendar* gc = new GregorianCalendar(status);
656 if (failure(status, "new GregorianCalendar", TRUE)) return;
663 for (int32_t i = 0; i < 9; i++, gc->add(UCAL_DATE, 1, status)) {
664 if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
665 if (gc->get(UCAL_YEAR, status) != year ||
666 gc->get(UCAL_MONTH, status) != month ||
667 gc->get(UCAL_DATE, status) != (date + i)) errln("FAIL: Date wrong");
668 if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
688 UErrorCode status = U_ZERO_ERROR;
689 GregorianCalendar* cal = new GregorianCalendar(status);
690 if (failure(status, "new GregorianCalendar", TRUE)) return;
693 cal->getTime(status);
694 if (U_FAILURE(status)) { errln("Calendar::getTime failed"); return; }
700 int32_t dow = cal->get(UCAL_DAY_OF_WEEK, status);
701 if (U_FAILURE(status)) { errln("Calendar::get failed [%s]", u_errorName(status)); return; }
720 UErrorCode status = U_ZERO_ERROR;
721 Calendar *c = Calendar::createInstance(status);
722 if (failure(status, "Calendar::createInstance", TRUE)) return;
726 if (c->get(UCAL_MILLISECOND, status) != 123 ||
727 d->get(UCAL_MILLISECOND, status) != 456) {
730 if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
744 UErrorCode status = U_ZERO_ERROR;
746 GregorianCalendar* c = new GregorianCalendar(status);
747 if (failure(status, "new GregorianCalendar", TRUE)) return;
753 c->setGregorianChange(date(0, 0, 1), status);
754 if (U_FAILURE(status)) { errln("GregorianCalendar::setGregorianChange failed"); return; }
771 UErrorCode status = U_ZERO_ERROR;
772 Calendar *c = Calendar::createInstance("en_US", status);
773 if (failure(status, "Calendar::createInstance", TRUE)) return;
793 status = U_ZERO_ERROR;
799 c->getTime(status);
800 verify765("1997 zero-th Tuesday in June = ", status);
815 status = U_ZERO_ERROR;
822 c->getTime(status);
823 verify765("1997 Tuesday in week 0 of June = ", status);
875 UErrorCode status = U_ZERO_ERROR;
876 int32_t y = c->get(UCAL_YEAR, status);
877 int32_t m = c->get(UCAL_MONTH, status);
878 int32_t d = c->get(UCAL_DATE, status);
882 if (U_FAILURE(status)) { errln("FAIL: Calendar::get failed"); return; }
883 logln("PASS: " + msg + dateToString(c->getTime(status), str));
884 if (U_FAILURE(status)) { errln("Calendar::getTime failed"); return; }
887 errln("FAIL: " + msg + dateToString(c->getTime(status), str) + "; expected " + (int32_t)year + "/" + (int32_t)(month + 1) + "/" + (int32_t)day +
888 "; got " + (int32_t)y + "/" + (int32_t)(m + 1) + "/" + (int32_t)d + " for Locale: " + c->getLocaleID(ULOC_ACTUAL_LOCALE,status));
889 if (U_FAILURE(status)) { errln("Calendar::getTime failed"); return; }
896 CalendarTest::verify765(const UnicodeString& msg/*, IllegalArgumentException e*/, UErrorCode status)
898 if (status != U_ILLEGAL_ARGUMENT_ERROR) errln("FAIL: No IllegalArgumentException for " + msg);
920 UErrorCode status = U_ZERO_ERROR;
922 Calendar *gmtcal = Calendar::createInstance(status);
923 if (failure(status, "Calendar::createInstance", TRUE)) return;
927 date = gmtcal->getTime(status);
928 if (U_FAILURE(status)) { errln("Calendar::getTime failed"); return; }
930 Calendar *cal = Calendar::createInstance(status);
931 if (U_FAILURE(status)) { errln("Calendar::createInstance failed"); return; }
932 cal->setTime(date, status);
933 if (U_FAILURE(status)) { errln("Calendar::setTime failed"); return; }
934 int32_t offset = cal->getTimeZone().getOffset((uint8_t)cal->get(UCAL_ERA, status),
935 cal->get(UCAL_YEAR, status),
936 cal->get(UCAL_MONTH, status),
937 cal->get(UCAL_DATE, status),
938 (uint8_t)cal->get(UCAL_DAY_OF_WEEK, status),
939 cal->get(UCAL_MILLISECOND, status), status);
940 if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
942 int32_t utc = ((cal->get(UCAL_HOUR_OF_DAY, status) * 60 +
943 cal->get(UCAL_MINUTE, status)) * 60 +
944 cal->get(UCAL_SECOND, status)) * 1000 +
945 cal->get(UCAL_MILLISECOND, status) - offset;
946 if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
964 UErrorCode status = U_ZERO_ERROR;
965 Calendar *cal = Calendar::createInstance(status);
966 if (failure(status, "Calendar::createInstance", TRUE)) return;
968 cal->setTime(d, status);
969 if (U_FAILURE(status)) {
974 cal->add(UCAL_DATE, - 5, status);
975 if (U_FAILURE(status)) {
984 dateToString(cal->getTime(status), s);
985 if (U_FAILURE(status)) {
992 cal = Calendar::createInstance(status);
993 if (U_FAILURE(status)) {
998 cal->setTime(d, status);
999 if (U_FAILURE(status)) {
1007 cal->add(UCAL_DATE, - 5, status);
1008 if (U_FAILURE(status)) {
1014 dateToString(cal->getTime(status), s2);
1015 if (U_FAILURE(status)) {
1036 UErrorCode status = U_ZERO_ERROR;
1037 GregorianCalendar *temp = new GregorianCalendar(y, m, d, status);
1038 if (failure(status, "new GregorianCalendar", TRUE)) return;
1040 temp->add(UCAL_YEAR, 1, status);
1041 if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
1044 temp->add(UCAL_MONTH, 1, status);
1045 if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
1048 temp->add(UCAL_DATE, 1, status);
1049 if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
1052 temp->add(UCAL_DATE, 2, status);
1053 if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
1056 temp->add(UCAL_DATE, 28, status);
1057 if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
1073 UErrorCode status = U_ZERO_ERROR;
1074 GregorianCalendar *temp = new GregorianCalendar(y, m, d, status);
1075 if (failure(status, "new GregorianCalendar", TRUE)) return;
1090 status = U_ZERO_ERROR;
1092 temp->add(e, 1, status);
1093 if (U_FAILURE(status)) { limit = i; status = U_ZERO_ERROR; }
1096 temp->add(e, -1, status);
1097 if (U_FAILURE(status)) { errln("GregorianCalendar::add -1 failed"); return; }
1109 status = U_ZERO_ERROR;
1112 temp->roll(e, 1, status);
1113 if (U_FAILURE(status)) {
1114 logln("caltest.cpp:%d e=%d, i=%d - roll(+) err %s\n", __LINE__, (int) e, (int) i, u_errorName(status));
1116 limit = i; status = U_ZERO_ERROR;
1122 temp->roll(e, -1, status);
1123 if (U_FAILURE(status)) { errln(UnicodeString("GregorianCalendar::roll ") + CalendarTest::fieldName(e) + " count=" + UnicodeString('@'+i) + " by -1 failed with " + u_errorName(status) ); return; }
1141 UErrorCode status = U_ZERO_ERROR;
1142 if (c->get(UCAL_YEAR, status) != y ||
1143 c->get(UCAL_MONTH, status) != m ||
1144 c->get(UCAL_DATE, status) != d ||
1145 c->get(UCAL_HOUR, status) != hr ||
1146 c->get(UCAL_MINUTE, status) != min ||
1147 c->get(UCAL_SECOND, status) != sec ||
1148 c->get(UCAL_MILLISECOND, status) != ms) {
1153 "; got " + c->get(UCAL_YEAR, status) +
1154 "/" + (c->get(UCAL_MONTH, status) + 1) +
1155 "/" + c->get(UCAL_DATE, status) +
1156 " " + c->get(UCAL_HOUR, status) + ":" +
1157 c->get(UCAL_MINUTE, status) + ":" +
1158 c->get(UCAL_SECOND, status) + ":" +
1159 c->get(UCAL_MILLISECOND, status)
1162 if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
1176 UErrorCode status = U_ZERO_ERROR;
1177 if (c->get(UCAL_YEAR, status) != y ||
1178 c->get(UCAL_MONTH, status) != m ||
1179 c->get(UCAL_DATE, status) != d) {
1182 "; got " + c->get(UCAL_YEAR, status) +
1183 "/" + (c->get(UCAL_MONTH, status) + 1) +
1184 "/" + c->get(UCAL_DATE, status)
1187 if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
1204 UErrorCode status = U_ZERO_ERROR;
1205 GregorianCalendar *g = new GregorianCalendar(status);
1206 if (failure(status, "new GregorianCalendar", TRUE)) return;
1207 GregorianCalendar *g2 = new GregorianCalendar(status);
1208 if (U_FAILURE(status)) { errln("Couldn't create GregorianCalendar"); return; }
1209 g2->set(UCAL_HOUR, 12, status);
1210 g2->set(UCAL_MINUTE, 0, status);
1211 g2->set(UCAL_SECOND, 0, status);
1212 if (U_FAILURE(status)) { errln("Calendar::set failed"); return; }
1277 UErrorCode status = U_ZERO_ERROR;
1278 Calendar *cal = new GregorianCalendar(status);
1279 if (failure(status, "new GregorianCalendar", TRUE)) return;
1280 cal->setTime(Calendar::getNow(), status);
1281 if (U_FAILURE(status)) { errln("Calendar::setTime failed"); return; }
1283 if (U_FAILURE(status)) { errln("Calendar::set failed"); return; }
1284 UDate d = cal->getTime(status);
1285 if (U_FAILURE(status)) { errln("Calendar::getTime failed"); return; }
1307 UErrorCode status = U_ZERO_ERROR;
1309 Calendar *calendar = new GregorianCalendar(status);
1310 if (failure(status, "new GregorianCalendar", TRUE)) return;
1313 calendar->add(UCAL_DATE, 1, status);
1314 if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
1322 Calendar *calendar = new GregorianCalendar(1993, UCAL_JANUARY, 4, status);
1323 if (U_FAILURE(status)) { errln("Couldn't create GregorianCalendar"); return; }
1325 calendar->add(UCAL_DATE, 1, status);
1326 if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
1334 Calendar *calendar = new GregorianCalendar(1993, UCAL_JANUARY, 4, status);
1335 if (U_FAILURE(status)) { errln("Couldn't create GregorianCalendar"); return; }
1337 calendar->getTime(status);
1338 if (U_FAILURE(status)) { errln("Calendar::getTime failed"); return; }
1339 calendar->add(UCAL_DATE, 1, status);
1340 if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
1354 UErrorCode status = U_ZERO_ERROR;
1355 return UnicodeString("") + (int32_t)calendar->get(UCAL_YEAR, status) +
1356 "/" + (int32_t)calendar->get(UCAL_MONTH, status) +
1357 "/" + (int32_t)calendar->get(UCAL_DATE, status) +
1358 (U_FAILURE(status) ? " FAIL: Calendar::get failed" : "");
1370 UErrorCode status = U_ZERO_ERROR;
1375 calendar = new GregorianCalendar(year, month, dDate, status);
1376 if (failure(status, "new GregorianCalendar", TRUE)) return;
1380 if (calendar->get(field, status) != expected) {
1382 "; received " + (int32_t)calendar->get(field, status) + " instead");
1383 if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
1410 UErrorCode status = U_ZERO_ERROR;
1412 Calendar *c = Calendar::createInstance(status);
1413 if (failure(status, "Calendar::createInstance", TRUE)) return;
1415 GregorianCalendar *gc = new GregorianCalendar(status);
1416 if (U_FAILURE(status)) { errln("Couldn't create GregorianCalendar"); return; }
1418 gc->setTime(d, status);
1419 if (U_FAILURE(status)) { errln("Calendar::setTime failed"); return; }
1420 UBool idt = gc->inDaylightTime(status);
1421 if (U_FAILURE(status)) { errln("GregorianCalendar::inDaylightTime failed"); return; }
1427 c->setTime(d, status);
1428 if (U_FAILURE(status)) { errln("Calendar::setTime failed"); return; }
1430 if (c->get((UCalendarDateFields)i, status) != EPOCH_FIELDS[i])
1432 "; saw " + c->get((UCalendarDateFields)i, status) + " instead");
1433 if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
1435 if (c->get(UCAL_ZONE_OFFSET, status) != z->getRawOffset())
1438 "; saw " + c->get(UCAL_ZONE_OFFSET, status) + " instead");
1439 if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
1441 if (c->get(UCAL_DST_OFFSET, status) != 0)
1444 "; saw " + c->get(UCAL_DST_OFFSET, status) + " instead");
1445 if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
1466 UErrorCode status = U_ZERO_ERROR;
1467 Calendar *cal = new GregorianCalendar(1972, UCAL_OCTOBER, 26, status);
1468 if (failure(status, "new GregorianCalendar", TRUE)) return;
1484 UErrorCode status = U_ZERO_ERROR;
1486 Calendar *cal=Calendar::createInstance(Locale::getGermany(), status);
1487 if (failure(status, "Calendar::createInstance", TRUE)) return;
1488 SimpleDateFormat *sdf=new SimpleDateFormat(UnicodeString("YYYY'-W'ww-ee"), Locale::getGermany(), status);
1489 if (U_FAILURE(status)) { dataerrln("Couldn't create SimpleDateFormat - %s", u_errorName(status)); return; }
1493 DateFormatSymbols *dfs = new DateFormatSymbols(Locale::getGermany(), status);
1496 sdf->applyLocalizedPattern(UnicodeString("JJJJ'-W'ww-ee"), status);
1497 if (U_FAILURE(status)) { errln("Couldn't apply localized pattern"); return; }
1501 doYEAR_WOYLoop(cal, sdf, times, status);
1502 //loop_addroll(cal, /*sdf,*/ times, UCAL_YEAR_WOY, UCAL_YEAR, status);
1503 yearAddTest(*cal, status); // aliu
1504 loop_addroll(cal, /*sdf,*/ times, UCAL_DOW_LOCAL, UCAL_DAY_OF_WEEK, status);
1505 if (U_FAILURE(status)) { errln("Error in parse/calculate test for 1997"); return; }
1509 doYEAR_WOYLoop(cal, sdf, times, status);
1510 //loop_addroll(cal, /*sdf,*/ times, UCAL_YEAR_WOY, UCAL_YEAR, status);
1511 yearAddTest(*cal, status); // aliu
1512 loop_addroll(cal, /*sdf,*/ times, UCAL_DOW_LOCAL, UCAL_DAY_OF_WEEK, status);
1513 if (U_FAILURE(status)) { errln("Error in parse/calculate test for 1998"); return; }
1517 doYEAR_WOYLoop(cal, sdf, times, status);
1518 //loop_addroll(cal, /*sdf,*/ times, Calendar::YEAR_WOY, Calendar::YEAR, status);
1519 yearAddTest(*cal, status); // aliu
1520 loop_addroll(cal, /*sdf,*/ times, UCAL_DOW_LOCAL, UCAL_DAY_OF_WEEK, status);
1521 if (U_FAILURE(status)) { errln("Error in parse/calculate test for 1582"); return; }
1532 void CalendarTest::yearAddTest(Calendar& cal, UErrorCode& status) {
1544 int32_t y = cal.get(UCAL_YEAR, status);
1545 int32_t mon = cal.get(UCAL_MONTH, status);
1546 int32_t day = cal.get(UCAL_DATE, status);
1547 int32_t ywy = cal.get(UCAL_YEAR_WOY, status);
1548 int32_t woy = cal.get(UCAL_WEEK_OF_YEAR, status);
1549 int32_t dow = cal.get(UCAL_DOW_LOCAL, status);
1550 UDate t = cal.getTime(status);
1552 if(U_FAILURE(status)){
1553 errln(UnicodeString("Failed to create Calendar for locale. Error: ") + UnicodeString(u_errorName(status)));
1557 SimpleDateFormat fmt(UnicodeString("EEE MMM dd yyyy / YYYY'-W'ww-ee"), status);
1562 cal.add(UCAL_YEAR, 1, status);
1563 int32_t y2 = cal.get(UCAL_YEAR, status);
1564 int32_t mon2 = cal.get(UCAL_MONTH, status);
1565 int32_t day2 = cal.get(UCAL_DATE, status);
1566 fmt.format(cal.getTime(status), str);
1578 cal.setTime(t, status);
1580 cal.add(UCAL_YEAR_WOY, 1, status);
1581 int32_t ywy2 = cal.get(UCAL_YEAR_WOY, status);
1582 int32_t woy2 = cal.get(UCAL_WEEK_OF_YEAR, status);
1583 int32_t dow2 = cal.get(UCAL_DOW_LOCAL, status);
1584 fmt.format(cal.getTime(status), str);
1700 UErrorCode status = U_ZERO_ERROR;
1702 int32_t initialDOW = cur->get(UCAL_DAY_OF_WEEK, status);
1703 if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
1708 logln(UnicodeString("DOW = ") + DOW + " " + dateToString(cur->getTime(status), str));
1709 if (U_FAILURE(status)) { errln("Calendar::getTime failed"); return; }
1710 cur->add(UCAL_DAY_OF_WEEK, delta, status);
1711 if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
1712 newDOW = cur->get(UCAL_DAY_OF_WEEK, status);
1713 if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
1717 " on " + dateToString(cur->getTime(status), str));
1718 if (U_FAILURE(status)) { errln("Calendar::getTime failed"); return; }
1726 #define CHECK(status, msg) \
1727 if (U_FAILURE(status)) { \
1728 errcheckln(status, msg); \
1772 UErrorCode status = U_ZERO_ERROR;
1775 GregorianCalendar cal(status);
1776 SimpleDateFormat fmt(UnicodeString("EEE MMM dd yyyy', WOY' w"), status);
1777 if (failure(status, "Cannot construct calendar/format", TRUE)) return;
1804 fmt.format(t = cal.getTime(status), str.remove());
1805 CHECK(status, "Fail: getTime failed");
1807 int32_t dow = cal.get(UCAL_DAY_OF_WEEK, status);
1808 int32_t woy = cal.get(UCAL_WEEK_OF_YEAR, status);
1809 int32_t year = cal.get(UCAL_YEAR, status);
1810 int32_t mon = cal.get(UCAL_MONTH, status);
1812 CHECK(status, "Fail: get failed");
1830 t_y = cal.get(UCAL_YEAR, status);
1831 t_woy = cal.get(UCAL_WEEK_OF_YEAR, status);
1832 t_dow = cal.get(UCAL_DAY_OF_WEEK, status);
1833 CHECK(status, "Fail: get failed");
1836 fmt.format(cal.getTime(status), str);
1852 t_y = cal.get(UCAL_YEAR, status);
1853 t_woy = cal.get(UCAL_WEEK_OF_YEAR, status);
1854 t_dow = cal.get(UCAL_DOW_LOCAL, status);
1855 CHECK(status, "Fail: get failed");
1858 fmt.format(cal.getTime(status), str);
1867 t2 = cal.getTime(status);
1868 CHECK(status, "Fail: getTime failed");
1884 t2 = cal.getTime(status);
1885 CHECK(status, "Fail: getTime failed");
1896 cal.setTime(t, status);
1899 t2 = cal.getTime(status);
1900 CHECK(status, "Fail: set/getTime failed");
1913 cal.setTime(t, status);
1916 t2 = cal.getTime(status);
1917 CHECK(status, "Fail: set/getTime failed");
1925 cal.setTime(t, status);
1928 t2 = cal.getTime(status);
1929 CHECK(status, "Fail: set/getTime failed");
1937 cal.setTime(t, status);
1940 t2 = cal.getTime(status);
1941 CHECK(status, "Fail: set/getTime failed");
1969 fmt.format(cal.getTime(status), str);
1970 CHECK(status, "Fail: getTime failed");
1973 cal.roll(UCAL_DOW_LOCAL, amount, status);
1974 CHECK(status, "Fail: roll failed");
1976 t = cal.getTime(status);
1981 t2 = cal.getTime(status);
1982 CHECK(status, "Fail: getTime failed");
1999 UErrorCode status = U_ZERO_ERROR;
2001 GregorianCalendar cal(status);
2002 if (failure(status, "construct GregorianCalendar", TRUE)) return;
2014 if(cal.get(UCAL_YEAR, status) != 2003) {
2025 if(cal.get(UCAL_YEAR, status) != 2004) {
2037 if(cal.get(UCAL_YEAR, status) != 2003) {
2044 cal.setTime(t, status);
2047 if(cal.getTime(status) != t) {
2058 UErrorCode status = U_ZERO_ERROR;
2059 GregorianCalendar cal(status);
2060 if (failure(status, "construct GregorianCalendar", TRUE)) return;
2063 jd = cal.get(UCAL_JULIAN_DAY, status);
2070 cal.setTime(Calendar::getNow(), status);
2073 UDate epochTime = cal.getTime(status);
2159 static UDate doMinDateOfCalendar(Calendar* adopt, UBool &isGregorian, UErrorCode& status) {
2160 if(U_FAILURE(status)) return 0.0;
2163 adopt->set(UCAL_EXTENDED_YEAR, adopt->getActualMinimum(UCAL_EXTENDED_YEAR, status));
2164 UDate ret = adopt->getTime(status);
2170 UDate CalendarTest::minDateOfCalendar(const Locale& locale, UBool &isGregorian, UErrorCode& status) {
2171 if(U_FAILURE(status)) return 0.0;
2172 return doMinDateOfCalendar(Calendar::createInstance(locale, status), isGregorian, status);
2175 UDate CalendarTest::minDateOfCalendar(const Calendar& cal, UBool &isGregorian, UErrorCode& status) {
2176 if(U_FAILURE(status)) return 0.0;
2177 return doMinDateOfCalendar(cal.clone(), isGregorian, status);
2182 UErrorCode status = U_ZERO_ERROR;
2186 cal = Calendar::createInstance(loc1, status);
2187 if (failure(status, "Calendar::createInstance", TRUE)) return;
2190 status = U_ZERO_ERROR;
2192 cal = Calendar::createInstance(loc2, status);
2193 if (failure(status, "Calendar::createInstance")) return;
2196 status = U_ZERO_ERROR;
2198 cal = Calendar::createInstance(loc3, status);
2199 if (failure(status, "Calendar::createInstance")) return;
2207 UErrorCode status = U_ZERO_ERROR;
2213 uzone.length(), NULL, 0, &status));
2214 if (df.isNull() || U_FAILURE(status)) return;
2223 status = U_ZERO_ERROR;
2224 udat_format(df.getAlias(), ud0, ubuffer, 1024, NULL, &status);
2225 if (U_FAILURE(status)) {
2237 status = U_ZERO_ERROR;
2238 udat_format(df.getAlias(), ud0, ubuffer, 1024, NULL, &status);
2239 if (U_FAILURE(status)) {
2253 UErrorCode status = U_ZERO_ERROR;
2255 HebrewCalendar hc(loc,status);
2266 int32_t dayHC = hc.get(UCAL_DATE,status);
2267 int32_t monthHC = hc.get(UCAL_MONTH,status);
2268 int32_t yearHC = hc.get(UCAL_YEAR,status);
2270 if (failure(status, "HebrewCalendar.get()", TRUE)) continue;
2290 UErrorCode status = U_ZERO_ERROR;
2295 cal = Calendar::createInstance("en_US@calender=gregorian", status);
2296 if (U_FAILURE(status)) {
2305 time = cal->getTime(status);
2306 if (U_FAILURE(status)) {
2345 UErrorCode status = U_ZERO_ERROR;
2346 Calendar *cal = Calendar::createInstance(TEST_LOCALES[i], status);
2347 if (U_FAILURE(status)) {
2357 int32_t weekNum = cal->get(UCAL_WEEK_OF_YEAR, status);
2358 int32_t weekYear = cal->get(UCAL_YEAR_WOY, status);
2359 if (U_FAILURE(status)) {
2375 UErrorCode status = U_ZERO_ERROR;
2376 Calendar* cal = Calendar::createInstance(status);
2377 if (U_FAILURE(status)) {
2394 if (!cal->equals(*cal2, status)) {
2396 } else if (U_FAILURE(status)) {
2399 status = U_ZERO_ERROR;
2407 if (!cal->equals(*cal2, status)) {
2409 } else if (U_FAILURE(status)) {
2412 status = U_ZERO_ERROR;
2433 CalFields(const Calendar& cal, UErrorCode& status);
2438 UBool isEquivalentTo(const Calendar& cal, UErrorCode& status) const;
2454 CalFields::CalFields(const Calendar& cal, UErrorCode& status) {
2455 year = cal.get(UCAL_YEAR, status);
2456 month = cal.get(UCAL_MONTH, status) + 1;
2457 day = cal.get(UCAL_DAY_OF_MONTH, status);
2458 hour = cal.get(UCAL_HOUR_OF_DAY, status);
2459 min = cal.get(UCAL_MINUTE, status);
2460 sec = cal.get(UCAL_SECOND, status);
2461 ms = cal.get(UCAL_MILLISECOND, status);
2497 CalFields::isEquivalentTo(const Calendar& cal, UErrorCode& status) const {
2498 return year == cal.get(UCAL_YEAR, status)
2499 && month == cal.get(UCAL_MONTH, status) + 1
2500 && day == cal.get(UCAL_DAY_OF_MONTH, status)
2501 && hour == cal.get(UCAL_HOUR_OF_DAY, status)
2502 && min == cal.get(UCAL_MINUTE, status)
2503 && sec == cal.get(UCAL_SECOND, status)
2504 && ms == cal.get(UCAL_MILLISECOND, status);
2536 UErrorCode status = U_ZERO_ERROR;
2537 GregorianCalendar calGMT((const TimeZone&)*TimeZone::getGMT(), status);
2538 GregorianCalendar calDefault(status);
2539 GregorianCalendar calLast(status);
2540 GregorianCalendar calFirst(status);
2542 if (U_FAILURE(status)) {
2555 status = U_ZERO_ERROR;
2558 calGMT.setTime(calLast.getTime(status), status);
2559 CalFields outLastGMT(calGMT, status);
2560 if (U_FAILURE(status)) {
2571 status = U_ZERO_ERROR;
2574 calGMT.setTime(calDefault.getTime(status), status);
2575 CalFields outDefGMT(calGMT, status);
2576 if (U_FAILURE(status)) {
2587 status = U_ZERO_ERROR;
2590 calGMT.setTime(calFirst.getTime(status), status);
2591 CalFields outFirstGMT(calGMT, status);
2592 if (U_FAILURE(status)) {
2635 UErrorCode status = U_ZERO_ERROR;
2636 GregorianCalendar calGMT((const TimeZone&)*TimeZone::getGMT(), status);
2637 GregorianCalendar calDefault(status);
2638 GregorianCalendar calLast(status);
2639 GregorianCalendar calFirst(status);
2640 GregorianCalendar calNextAvail(status);
2642 if (U_FAILURE(status)) {
2660 status = U_ZERO_ERROR;
2664 d = calLast.getTime(status);
2666 calGMT.setTime(d, status);
2667 CalFields outLastGMT(calGMT, status);
2668 if (U_FAILURE(status)) {
2677 } else if (U_SUCCESS(status)) {
2684 status = U_ZERO_ERROR;
2688 d = calDefault.getTime(status);
2690 calGMT.setTime(d, status);
2691 CalFields outDefGMT(calGMT, status);
2692 if (U_FAILURE(status)) {
2701 } else if (U_SUCCESS(status)) {
2708 status = U_ZERO_ERROR;
2712 d = calFirst.getTime(status);
2714 calGMT.setTime(d, status);
2715 CalFields outFirstGMT(calGMT, status);
2716 if (U_FAILURE(status)) {
2725 } else if (U_SUCCESS(status)) {
2732 status = U_ZERO_ERROR;
2736 d = calNextAvail.getTime(status);
2738 calGMT.setTime(d, status);
2739 CalFields outNextAvailGMT(calGMT, status);
2740 if (U_FAILURE(status)) {
2749 } else if (U_SUCCESS(status)) {
2761 UErrorCode status = U_ZERO_ERROR;
2763 Locale::createFromName("en"), status));
2765 Locale l0 = cal->getLocale(ULOC_VALID_LOCALE, status);
2768 Locale l = cal2->getLocale(ULOC_VALID_LOCALE, status);
2770 errln("Error: cloned locale %s != original locale %s, status %s\n", l0.getName(), l.getName(), u_errorName(status));
2775 void CalendarTest::setAndTestCalendar(Calendar* cal, int32_t initMonth, int32_t initDay, int32_t initYear, UErrorCode& status) {
2779 int32_t day = cal->get(UCAL_DAY_OF_MONTH, status);
2780 int32_t month = cal->get(UCAL_MONTH, status);
2781 int32_t year = cal->get(UCAL_YEAR, status);
2782 if(U_FAILURE(status))
2792 void CalendarTest::setAndTestWholeYear(Calendar* cal, int32_t startYear, UErrorCode& status) {
2795 setAndTestCalendar(cal, startMonth, startDay, startYear, status);
2796 if(U_FAILURE(status) && startDay == 30) {
2797 status = U_ZERO_ERROR;
2808 UErrorCode status = U_ZERO_ERROR;
2810 Calendar* tstCal = Calendar::createInstance(islamicLoc, status);
2828 setAndTestWholeYear(tstCal, startYear, status);
2829 status = U_ZERO_ERROR;
2836 setAndTestCalendar( tstCal, initMonth, initDay, initYear, status);
2840 day = tstCal->get(UCAL_DAY_OF_MONTH,status);
2841 month = tstCal->get(UCAL_MONTH,status);
2842 year = tstCal->get(UCAL_YEAR,status);
2844 tstCal->roll(UCAL_DAY_OF_MONTH, (UBool)TRUE, status);
2851 status = U_ZERO_ERROR;
2855 setAndTestCalendar( tstCal, initMonth, initDay, initYear, status);
2856 if(U_SUCCESS(status)) {
2857 errln("error NOT detected status %i",status);
2859 int32_t day = tstCal->get(UCAL_DAY_OF_MONTH, status);
2860 int32_t month = tstCal->get(UCAL_MONTH, status);
2861 int32_t year = tstCal->get(UCAL_YEAR, status);
2865 status = U_ZERO_ERROR;
2869 setAndTestCalendar( tstCal, initMonth, initDay, initYear, status);
2872 SimpleDateFormat* formatter = new SimpleDateFormat("yyyy-MM-dd", Locale::getUS(), status);
2873 UDate date = formatter->parse("1975-05-06", status);
2874 Calendar* is_cal = Calendar::createInstance(islamicLoc, status);
2875 is_cal->setTime(date, status);
2876 int32_t is_day = is_cal->get(UCAL_DAY_OF_MONTH,status);
2877 int32_t is_month = is_cal->get(UCAL_MONTH,status);
2878 int32_t is_year = is_cal->get(UCAL_YEAR,status);
2883 UDate date2 = is_cal->getTime(status);
2895 UErrorCode status = U_ZERO_ERROR;
2898 SimpleDateFormat* formatter = new SimpleDateFormat("yyyy-MM-dd", Locale::getUS(), status);
2899 UDate date = formatter->parse("1975-05-06", status);
2901 Calendar* tstCal = Calendar::createInstance(islamicLoc, status);
2902 tstCal->setTime(date, status);
2903 int32_t is_day = tstCal->get(UCAL_DAY_OF_MONTH,status);
2904 int32_t is_month = tstCal->get(UCAL_MONTH,status);
2905 int32_t is_year = tstCal->get(UCAL_YEAR,status);
2909 tstCal = Calendar::createInstance(tblaLoc, status);
2910 tstCal->setTime(date, status);
2911 int32_t tbla_day = tstCal->get(UCAL_DAY_OF_MONTH,status);
2912 int32_t tbla_month = tstCal->get(UCAL_MONTH,status);
2913 int32_t tbla_year = tstCal->get(UCAL_YEAR,status);
2926 UErrorCode status = U_ZERO_ERROR;
2927 LocalPointer<Calendar> cal(Calendar::createInstance(Locale::createFromName("he_IL@calendar=hebrew"), status));
2928 if (failure(status, "Calendar::createInstance, locale:he_IL@calendar=hebrew", TRUE)) return;
2936 d = pCal->getTime(status);
2937 if (U_FAILURE(status)) {
2940 status = U_ZERO_ERROR;
2944 d = pCal->getTime(status);
2946 if (status == U_ILLEGAL_ARGUMENT_ERROR) {
2965 UErrorCode status;
2968 status = U_ZERO_ERROR;
2969 LocalPointer<Calendar> cal1(Calendar::createInstance(LOCALE_PAIRS[i], status));
2970 LocalPointer<Calendar> cal2(Calendar::createInstance(LOCALE_PAIRS[i + 1], status));
2974 UCalendarDaysOfWeek dow1 = cal1->getFirstDayOfWeek(status);
2975 UCalendarDaysOfWeek dow2 = cal2->getFirstDayOfWeek(status);
2986 status = U_ZERO_ERROR;
2987 UCalendarWeekdayType wdt1 = cal1->getDayOfWeekType((UCalendarDaysOfWeek)d, status);
2988 UCalendarWeekdayType wdt2 = cal2->getDayOfWeekType((UCalendarDaysOfWeek)d, status);
3145 UErrorCode status = U_ZERO_ERROR;
3146 GregorianCalendar cal(status);
3150 status = U_ZERO_ERROR;
3155 cal.add(UCAL_DATE, AAZTDATA[i].deltaDays, status);
3158 if (!AAZTDATA[i].expected.isEquivalentTo(cal, status)) {
3159 CalFields res(cal, status);