[apple/icu.git] / icuSources / test / intltest / tzoffloc.cpp

/*
*******************************************************************************
* Copyright (C) 2007-2011, International Business Machines Corporation and         *
* others. All Rights Reserved.                                                *
*******************************************************************************
*/
#include "unicode/utypes.h"

#if !UCONFIG_NO_FORMATTING

#include "tzoffloc.h"

#include "unicode/ucal.h"
#include "unicode/timezone.h"
#include "unicode/calendar.h"
#include "unicode/dtrule.h"
#include "unicode/tzrule.h"
#include "unicode/rbtz.h"
#include "unicode/simpletz.h"
#include "unicode/tzrule.h"
#include "unicode/smpdtfmt.h"
#include "unicode/gregocal.h"

void
TimeZoneOffsetLocalTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
{
    if (exec) {
        logln("TestSuite TimeZoneOffsetLocalTest");
    }
    switch (index) {
        TESTCASE(0, TestGetOffsetAroundTransition);
        default: name = ""; break;
    }
}

/*
 * Testing getOffset APIs around rule transition by local standard/wall time.
 */
void
TimeZoneOffsetLocalTest::TestGetOffsetAroundTransition() {
    const int32_t NUM_DATES = 10;
    const int32_t NUM_TIMEZONES = 3;

    const int32_t HOUR = 60*60*1000;
    const int32_t MINUTE = 60*1000;

    const int32_t DATES[NUM_DATES][6] = {
        {2006, UCAL_APRIL, 2, 1, 30, 1*HOUR+30*MINUTE},
        {2006, UCAL_APRIL, 2, 2, 00, 2*HOUR},
        {2006, UCAL_APRIL, 2, 2, 30, 2*HOUR+30*MINUTE},
        {2006, UCAL_APRIL, 2, 3, 00, 3*HOUR},
        {2006, UCAL_APRIL, 2, 3, 30, 3*HOUR+30*MINUTE},
        {2006, UCAL_OCTOBER, 29, 0, 30, 0*HOUR+30*MINUTE},
        {2006, UCAL_OCTOBER, 29, 1, 00, 1*HOUR},
        {2006, UCAL_OCTOBER, 29, 1, 30, 1*HOUR+30*MINUTE},
        {2006, UCAL_OCTOBER, 29, 2, 00, 2*HOUR},
        {2006, UCAL_OCTOBER, 29, 2, 30, 2*HOUR+30*MINUTE},
    };

    // Expected offsets by int32_t getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
    // uint8_t dayOfWeek, int32_t millis, UErrorCode& status)
    const int32_t OFFSETS1[NUM_DATES] = {
        // April 2, 2006
        -8*HOUR,
        -7*HOUR,
        -7*HOUR,
        -7*HOUR,
        -7*HOUR,

        // October 29, 2006
        -7*HOUR,
        -8*HOUR,
        -8*HOUR,
        -8*HOUR,
        -8*HOUR,
    };

    // Expected offsets by void getOffset(UDate date, UBool local, int32_t& rawOffset,
    // int32_t& dstOffset, UErrorCode& ec) with local=TRUE
    // or void getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
    // int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) with
    // nonExistingTimeOpt=kStandard/duplicatedTimeOpt=kStandard
    const int32_t OFFSETS2[NUM_DATES][2] = {
        // April 2, 2006
        {-8*HOUR, 0},
        {-8*HOUR, 0},
        {-8*HOUR, 0},
        {-8*HOUR, 1*HOUR},
        {-8*HOUR, 1*HOUR},

        // Oct 29, 2006
        {-8*HOUR, 1*HOUR},
        {-8*HOUR, 0},
        {-8*HOUR, 0},
        {-8*HOUR, 0},
        {-8*HOUR, 0},
    };

    // Expected offsets by void getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt,
    // int32_t duplicatedTimeOpt, int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) with
    // nonExistingTimeOpt=kDaylight/duplicatedTimeOpt=kDaylight
    const int32_t OFFSETS3[][2] = {
        // April 2, 2006
        {-8*HOUR, 0},
        {-8*HOUR, 1*HOUR},
        {-8*HOUR, 1*HOUR},
        {-8*HOUR, 1*HOUR},
        {-8*HOUR, 1*HOUR},

        // October 29, 2006
        {-8*HOUR, 1*HOUR},
        {-8*HOUR, 1*HOUR},
        {-8*HOUR, 1*HOUR},
        {-8*HOUR, 0},
        {-8*HOUR, 0},
    };

    UErrorCode status = U_ZERO_ERROR;

    int32_t rawOffset, dstOffset;
    TimeZone* utc = TimeZone::createTimeZone("UTC");
    Calendar* cal = Calendar::createInstance(*utc, status);
    if (U_FAILURE(status)) {
        dataerrln("Calendar::createInstance failed: %s", u_errorName(status));
        return;
    }
    cal->clear();

    // Set up TimeZone objects - OlsonTimeZone, SimpleTimeZone and RuleBasedTimeZone
    BasicTimeZone *TESTZONES[NUM_TIMEZONES];

    TESTZONES[0] = (BasicTimeZone*)TimeZone::createTimeZone("America/Los_Angeles");
    TESTZONES[1] = new SimpleTimeZone(-8*HOUR, "Simple Pacific Time",
                                        UCAL_APRIL, 1, UCAL_SUNDAY, 2*HOUR,
                                        UCAL_OCTOBER, -1, UCAL_SUNDAY, 2*HOUR, status);
    if (U_FAILURE(status)) {
        errln("SimpleTimeZone constructor failed");
        return;
    }

    InitialTimeZoneRule *ir = new InitialTimeZoneRule(
            "Pacific Standard Time", // Initial time Name
            -8*HOUR,        // Raw offset
            0*HOUR);        // DST saving amount

    RuleBasedTimeZone *rbPT = new RuleBasedTimeZone("Rule based Pacific Time", ir);

    DateTimeRule *dtr;
    AnnualTimeZoneRule *atzr;
    const int32_t STARTYEAR = 2000;

    dtr = new DateTimeRule(UCAL_APRIL, 1, UCAL_SUNDAY,
                        2*HOUR, DateTimeRule::WALL_TIME); // 1st Sunday in April, at 2AM wall time
    atzr = new AnnualTimeZoneRule("Pacific Daylight Time",
            -8*HOUR /* rawOffset */, 1*HOUR /* dstSavings */, dtr,
            STARTYEAR, AnnualTimeZoneRule::MAX_YEAR);
    rbPT->addTransitionRule(atzr, status);
    if (U_FAILURE(status)) {
        errln("Could not add DST start rule to the RuleBasedTimeZone rbPT");
        return;
    }

    dtr = new DateTimeRule(UCAL_OCTOBER, -1, UCAL_SUNDAY,
                        2*HOUR, DateTimeRule::WALL_TIME); // last Sunday in October, at 2AM wall time
    atzr = new AnnualTimeZoneRule("Pacific Standard Time",
            -8*HOUR /* rawOffset */, 0 /* dstSavings */, dtr,
            STARTYEAR, AnnualTimeZoneRule::MAX_YEAR);
    rbPT->addTransitionRule(atzr, status);
    if (U_FAILURE(status)) {
        errln("Could not add STD start rule to the RuleBasedTimeZone rbPT");
        return;
    }

    rbPT->complete(status);
    if (U_FAILURE(status)) {
        errln("complete() failed for RuleBasedTimeZone rbPT");
        return;
    }

    TESTZONES[2] = rbPT;

    // Calculate millis
    UDate MILLIS[NUM_DATES];
    for (int32_t i = 0; i < NUM_DATES; i++) {
        cal->clear();
        cal->set(DATES[i][0], DATES[i][1], DATES[i][2], DATES[i][3], DATES[i][4]);
        MILLIS[i] = cal->getTime(status);
        if (U_FAILURE(status)) {
            errln("cal->getTime failed");
            return;
        }
    }

    SimpleDateFormat df(UnicodeString("yyyy-MM-dd HH:mm:ss"), status);
    if (U_FAILURE(status)) {
        dataerrln("Failed to initialize a SimpleDateFormat - %s", u_errorName(status));
    }
    df.setTimeZone(*utc);
    UnicodeString dateStr;

    // Test getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
    // uint8_t dayOfWeek, int32_t millis, UErrorCode& status)
    for (int32_t i = 0; i < NUM_TIMEZONES; i++) {
        for (int32_t d = 0; d < NUM_DATES; d++) {
            status = U_ZERO_ERROR;
            int32_t offset = TESTZONES[i]->getOffset(GregorianCalendar::AD, DATES[d][0], DATES[d][1], DATES[d][2],
                                                UCAL_SUNDAY, DATES[d][5], status);
            if (U_FAILURE(status)) {
                errln((UnicodeString)"getOffset(era,year,month,day,dayOfWeek,millis,status) failed for TESTZONES[" + i + "]");
            } else if (offset != OFFSETS1[d]) {
                dateStr.remove();
                df.format(MILLIS[d], dateStr);
                dataerrln((UnicodeString)"Bad offset returned by TESTZONES[" + i + "] at "
                        + dateStr + "(standard) - Got: " + offset + " Expected: " + OFFSETS1[d]);
            }
        }
    }

    // Test getOffset(UDate date, UBool local, int32_t& rawOffset,
    // int32_t& dstOffset, UErrorCode& ec) with local = TRUE
    for (int32_t i = 0; i < NUM_TIMEZONES; i++) {
        for (int32_t m = 0; m < NUM_DATES; m++) {
            status = U_ZERO_ERROR;
            TESTZONES[i]->getOffset(MILLIS[m], TRUE, rawOffset, dstOffset, status);
            if (U_FAILURE(status)) {
                errln((UnicodeString)"getOffset(date,local,rawOfset,dstOffset,ec) failed for TESTZONES[" + i + "]");
            } else if (rawOffset != OFFSETS2[m][0] || dstOffset != OFFSETS2[m][1]) {
                dateStr.remove();
                df.format(MILLIS[m], dateStr);
                dataerrln((UnicodeString)"Bad offset returned by TESTZONES[" + i + "] at "
                        + dateStr + "(wall) - Got: "
                        + rawOffset + "/" + dstOffset
                        + " Expected: " + OFFSETS2[m][0] + "/" + OFFSETS2[m][1]);
            }
        }
    }

    // Test getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
    // int32_t& rawOffset, int32_t& dstOffset, UErroCode& status)
    // with nonExistingTimeOpt=kStandard/duplicatedTimeOpt=kStandard
    for (int32_t i = 0; i < NUM_TIMEZONES; i++) {
        for (int m = 0; m < NUM_DATES; m++) {
            status = U_ZERO_ERROR;
            TESTZONES[i]->getOffsetFromLocal(MILLIS[m], BasicTimeZone::kStandard, BasicTimeZone::kStandard,
                rawOffset, dstOffset, status);
            if (U_FAILURE(status)) {
                errln((UnicodeString)"getOffsetFromLocal with kStandard/kStandard failed for TESTZONES[" + i + "]");
            } else if (rawOffset != OFFSETS2[m][0] || dstOffset != OFFSETS2[m][1]) {
                dateStr.remove();
                df.format(MILLIS[m], dateStr);
                dataerrln((UnicodeString)"Bad offset returned by TESTZONES[" + i + "] at "
                        + dateStr + "(wall/kStandard/kStandard) - Got: "
                        + rawOffset + "/" + dstOffset
                        + " Expected: " + OFFSETS2[m][0] + "/" + OFFSETS2[m][1]);
            }
        }
    }

    // Test getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
    // int32_t& rawOffset, int32_t& dstOffset, UErroCode& status)
    // with nonExistingTimeOpt=kDaylight/duplicatedTimeOpt=kDaylight
    for (int32_t i = 0; i < NUM_TIMEZONES; i++) {
        for (int m = 0; m < NUM_DATES; m++) {
            status = U_ZERO_ERROR;
            TESTZONES[i]->getOffsetFromLocal(MILLIS[m], BasicTimeZone::kDaylight, BasicTimeZone::kDaylight,
                rawOffset, dstOffset, status);
            if (U_FAILURE(status)) {
                errln((UnicodeString)"getOffsetFromLocal with kDaylight/kDaylight failed for TESTZONES[" + i + "]");
            } else if (rawOffset != OFFSETS3[m][0] || dstOffset != OFFSETS3[m][1]) {
                dateStr.remove();
                df.format(MILLIS[m], dateStr);
                dataerrln((UnicodeString)"Bad offset returned by TESTZONES[" + i + "] at "
                        + dateStr + "(wall/kDaylight/kDaylight) - Got: "
                        + rawOffset + "/" + dstOffset
                        + " Expected: " + OFFSETS3[m][0] + "/" + OFFSETS3[m][1]);
            }
        }
    }

    // Test getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
    // int32_t& rawOffset, int32_t& dstOffset, UErroCode& status)
    // with nonExistingTimeOpt=kFormer/duplicatedTimeOpt=kLatter
    for (int32_t i = 0; i < NUM_TIMEZONES; i++) {
        for (int m = 0; m < NUM_DATES; m++) {
            status = U_ZERO_ERROR;
            TESTZONES[i]->getOffsetFromLocal(MILLIS[m], BasicTimeZone::kFormer, BasicTimeZone::kLatter,
                rawOffset, dstOffset, status);
            if (U_FAILURE(status)) {
                errln((UnicodeString)"getOffsetFromLocal with kFormer/kLatter failed for TESTZONES[" + i + "]");
            } else if (rawOffset != OFFSETS2[m][0] || dstOffset != OFFSETS2[m][1]) {
                dateStr.remove();
                df.format(MILLIS[m], dateStr);
                dataerrln((UnicodeString)"Bad offset returned by TESTZONES[" + i + "] at "
                        + dateStr + "(wall/kFormer/kLatter) - Got: "
                        + rawOffset + "/" + dstOffset
                        + " Expected: " + OFFSETS2[m][0] + "/" + OFFSETS2[m][1]);
            }
        }
    }

    // Test getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
    // int32_t& rawOffset, int32_t& dstOffset, UErroCode& status)
    // with nonExistingTimeOpt=kLatter/duplicatedTimeOpt=kFormer
    for (int32_t i = 0; i < NUM_TIMEZONES; i++) {
        for (int m = 0; m < NUM_DATES; m++) {
            status = U_ZERO_ERROR;
            TESTZONES[i]->getOffsetFromLocal(MILLIS[m], BasicTimeZone::kLatter, BasicTimeZone::kFormer,
                rawOffset, dstOffset, status);
            if (U_FAILURE(status)) {
                errln((UnicodeString)"getOffsetFromLocal with kLatter/kFormer failed for TESTZONES[" + i + "]");
            } else if (rawOffset != OFFSETS3[m][0] || dstOffset != OFFSETS3[m][1]) {
                dateStr.remove();
                df.format(MILLIS[m], dateStr);
                dataerrln((UnicodeString)"Bad offset returned by TESTZONES[" + i + "] at "
                        + dateStr + "(wall/kLatter/kFormer) - Got: "
                        + rawOffset + "/" + dstOffset
                        + " Expected: " + OFFSETS3[m][0] + "/" + OFFSETS3[m][1]);
            }
        }
    }

    for (int32_t i = 0; i < NUM_TIMEZONES; i++) {
        delete TESTZONES[i];
    }
    delete utc;
    delete cal;
}

#endif /* #if !UCONFIG_NO_FORMATTING */
Commit	Line	Data
46f4442e A	1	/*
46f4442e A	2	*******************************************************************************
4388f060	3	* Copyright (C) 2007-2011, International Business Machines Corporation and *
46f4442e A	4	* others. All Rights Reserved. *
	5	*******************************************************************************
	6	*/
	7	#include "unicode/utypes.h"
	8
	9	#if !UCONFIG_NO_FORMATTING
	10
	11	#include "tzoffloc.h"
	12
	13	#include "unicode/ucal.h"
	14	#include "unicode/timezone.h"
	15	#include "unicode/calendar.h"
	16	#include "unicode/dtrule.h"
	17	#include "unicode/tzrule.h"
	18	#include "unicode/rbtz.h"
	19	#include "unicode/simpletz.h"
	20	#include "unicode/tzrule.h"
	21	#include "unicode/smpdtfmt.h"
	22	#include "unicode/gregocal.h"
	23
	24	void
	25	TimeZoneOffsetLocalTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /par/ )
	26	{
	27	if (exec) {
	28	logln("TestSuite TimeZoneOffsetLocalTest");
	29	}
	30	switch (index) {
	31	TESTCASE(0, TestGetOffsetAroundTransition);
	32	default: name = ""; break;
	33	}
	34	}
	35
	36	/*
	37	* Testing getOffset APIs around rule transition by local standard/wall time.
	38	*/
	39	void
	40	TimeZoneOffsetLocalTest::TestGetOffsetAroundTransition() {
	41	const int32_t NUM_DATES = 10;
	42	const int32_t NUM_TIMEZONES = 3;
	43
	44	const int32_t HOUR = 60601000;
	45	const int32_t MINUTE = 60*1000;
	46
	47	const int32_t DATES[NUM_DATES][6] = {
	48	{2006, UCAL_APRIL, 2, 1, 30, 1HOUR+30MINUTE},
	49	{2006, UCAL_APRIL, 2, 2, 00, 2*HOUR},
	50	{2006, UCAL_APRIL, 2, 2, 30, 2HOUR+30MINUTE},
	51	{2006, UCAL_APRIL, 2, 3, 00, 3*HOUR},
	52	{2006, UCAL_APRIL, 2, 3, 30, 3HOUR+30MINUTE},
	53	{2006, UCAL_OCTOBER, 29, 0, 30, 0HOUR+30MINUTE},
	54	{2006, UCAL_OCTOBER, 29, 1, 00, 1*HOUR},
	55	{2006, UCAL_OCTOBER, 29, 1, 30, 1HOUR+30MINUTE},
	56	{2006, UCAL_OCTOBER, 29, 2, 00, 2*HOUR},
	57	{2006, UCAL_OCTOBER, 29, 2, 30, 2HOUR+30MINUTE},
	58	};
	59
	60	// Expected offsets by int32_t getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
	61	// uint8_t dayOfWeek, int32_t millis, UErrorCode& status)
	62	const int32_t OFFSETS1[NUM_DATES] = {
	63	// April 2, 2006
	64	-8*HOUR,
	65	-7*HOUR,
	66	-7*HOUR,
	67	-7*HOUR,
68	-7*HOUR,
69
70	// October 29, 2006
71	-7*HOUR,
72	-8*HOUR,
73	-8*HOUR,
74	-8*HOUR,
75	-8*HOUR,
76	};
77
78	// Expected offsets by void getOffset(UDate date, UBool local, int32_t& rawOffset,
79	// int32_t& dstOffset, UErrorCode& ec) with local=TRUE
80	// or void getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
81	// int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) with
82	// nonExistingTimeOpt=kStandard/duplicatedTimeOpt=kStandard
83	const int32_t OFFSETS2[NUM_DATES][2] = {
84	// April 2, 2006
85	{-8*HOUR, 0},
86	{-8*HOUR, 0},
87	{-8*HOUR, 0},
88	{-8HOUR, 1HOUR},
89	{-8HOUR, 1HOUR},
90
91	// Oct 29, 2006
92	{-8HOUR, 1HOUR},
93	{-8*HOUR, 0},
94	{-8*HOUR, 0},
95	{-8*HOUR, 0},
96	{-8*HOUR, 0},
97	};
98
99	// Expected offsets by void getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt,
100	// int32_t duplicatedTimeOpt, int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) with
101	// nonExistingTimeOpt=kDaylight/duplicatedTimeOpt=kDaylight
102	const int32_t OFFSETS3[][2] = {
103	// April 2, 2006
104	{-8*HOUR, 0},
105	{-8HOUR, 1HOUR},
106	{-8HOUR, 1HOUR},
107	{-8HOUR, 1HOUR},
108	{-8HOUR, 1HOUR},
109
110	// October 29, 2006
111	{-8HOUR, 1HOUR},
112	{-8HOUR, 1HOUR},
113	{-8HOUR, 1HOUR},
114	{-8*HOUR, 0},
115	{-8*HOUR, 0},
116	};
117
118	UErrorCode status = U_ZERO_ERROR;
119
120	int32_t rawOffset, dstOffset;
121	TimeZone* utc = TimeZone::createTimeZone("UTC");
122	Calendar* cal = Calendar::createInstance(*utc, status);
123	if (U_FAILURE(status)) {
729e4ab9	124	dataerrln("Calendar::createInstance failed: %s", u_errorName(status));
46f4442e A	125	return;
	126	}
	127	cal->clear();
	128
	129	// Set up TimeZone objects - OlsonTimeZone, SimpleTimeZone and RuleBasedTimeZone
	130	BasicTimeZone *TESTZONES[NUM_TIMEZONES];
	131
	132	TESTZONES[0] = (BasicTimeZone*)TimeZone::createTimeZone("America/Los_Angeles");
	133	TESTZONES[1] = new SimpleTimeZone(-8*HOUR, "Simple Pacific Time",
	134	UCAL_APRIL, 1, UCAL_SUNDAY, 2*HOUR,
	135	UCAL_OCTOBER, -1, UCAL_SUNDAY, 2*HOUR, status);
	136	if (U_FAILURE(status)) {
	137	errln("SimpleTimeZone constructor failed");
	138	return;
	139	}
	140
	141	InitialTimeZoneRule *ir = new InitialTimeZoneRule(
	142	"Pacific Standard Time", // Initial time Name
	143	-8*HOUR, // Raw offset
	144	0*HOUR); // DST saving amount
	145
	146	RuleBasedTimeZone *rbPT = new RuleBasedTimeZone("Rule based Pacific Time", ir);
	147
	148	DateTimeRule *dtr;
	149	AnnualTimeZoneRule *atzr;
	150	const int32_t STARTYEAR = 2000;
	151
	152	dtr = new DateTimeRule(UCAL_APRIL, 1, UCAL_SUNDAY,
	153	2*HOUR, DateTimeRule::WALL_TIME); // 1st Sunday in April, at 2AM wall time
	154	atzr = new AnnualTimeZoneRule("Pacific Daylight Time",
	155	-8HOUR / rawOffset /, 1HOUR /* dstSavings */, dtr,
	156	STARTYEAR, AnnualTimeZoneRule::MAX_YEAR);
	157	rbPT->addTransitionRule(atzr, status);
	158	if (U_FAILURE(status)) {
	159	errln("Could not add DST start rule to the RuleBasedTimeZone rbPT");
	160	return;
	161	}
	162
	163	dtr = new DateTimeRule(UCAL_OCTOBER, -1, UCAL_SUNDAY,
	164	2*HOUR, DateTimeRule::WALL_TIME); // last Sunday in October, at 2AM wall time
	165	atzr = new AnnualTimeZoneRule("Pacific Standard Time",
	166	-8HOUR / rawOffset /, 0 / dstSavings */, dtr,
	167	STARTYEAR, AnnualTimeZoneRule::MAX_YEAR);
	168	rbPT->addTransitionRule(atzr, status);
	169	if (U_FAILURE(status)) {
	170	errln("Could not add STD start rule to the RuleBasedTimeZone rbPT");
	171	return;
	172	}
	173
	174	rbPT->complete(status);
	175	if (U_FAILURE(status)) {
	176	errln("complete() failed for RuleBasedTimeZone rbPT");
	177	return;
	178	}
	179
	180	TESTZONES[2] = rbPT;
	181
	182	// Calculate millis
	183	UDate MILLIS[NUM_DATES];
	184	for (int32_t i = 0; i < NUM_DATES; i++) {
	185	cal->clear();
	186	cal->set(DATES[i][0], DATES[i][1], DATES[i][2], DATES[i][3], DATES[i][4]);
	187	MILLIS[i] = cal->getTime(status);
	188	if (U_FAILURE(status)) {
189	errln("cal->getTime failed");
190	return;
191	}
192	}
193
194	SimpleDateFormat df(UnicodeString("yyyy-MM-dd HH:mm:ss"), status);
195	if (U_FAILURE(status)) {
4388f060	196	dataerrln("Failed to initialize a SimpleDateFormat - %s", u_errorName(status));
46f4442e A	197	}
	198	df.setTimeZone(*utc);
	199	UnicodeString dateStr;
	200
	201	// Test getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
	202	// uint8_t dayOfWeek, int32_t millis, UErrorCode& status)
	203	for (int32_t i = 0; i < NUM_TIMEZONES; i++) {
	204	for (int32_t d = 0; d < NUM_DATES; d++) {
	205	status = U_ZERO_ERROR;
	206	int32_t offset = TESTZONES[i]->getOffset(GregorianCalendar::AD, DATES[d][0], DATES[d][1], DATES[d][2],
	207	UCAL_SUNDAY, DATES[d][5], status);
	208	if (U_FAILURE(status)) {
	209	errln((UnicodeString)"getOffset(era,year,month,day,dayOfWeek,millis,status) failed for TESTZONES[" + i + "]");
	210	} else if (offset != OFFSETS1[d]) {
	211	dateStr.remove();
	212	df.format(MILLIS[d], dateStr);
729e4ab9	213	dataerrln((UnicodeString)"Bad offset returned by TESTZONES[" + i + "] at "
46f4442e A	214	+ dateStr + "(standard) - Got: " + offset + " Expected: " + OFFSETS1[d]);
	215	}
	216	}
	217	}
	218
	219	// Test getOffset(UDate date, UBool local, int32_t& rawOffset,
	220	// int32_t& dstOffset, UErrorCode& ec) with local = TRUE
	221	for (int32_t i = 0; i < NUM_TIMEZONES; i++) {
	222	for (int32_t m = 0; m < NUM_DATES; m++) {
	223	status = U_ZERO_ERROR;
	224	TESTZONES[i]->getOffset(MILLIS[m], TRUE, rawOffset, dstOffset, status);
	225	if (U_FAILURE(status)) {
	226	errln((UnicodeString)"getOffset(date,local,rawOfset,dstOffset,ec) failed for TESTZONES[" + i + "]");
	227	} else if (rawOffset != OFFSETS2[m][0] \|\| dstOffset != OFFSETS2[m][1]) {
	228	dateStr.remove();
	229	df.format(MILLIS[m], dateStr);
729e4ab9	230	dataerrln((UnicodeString)"Bad offset returned by TESTZONES[" + i + "] at "
46f4442e A	231	+ dateStr + "(wall) - Got: "
	232	+ rawOffset + "/" + dstOffset
	233	+ " Expected: " + OFFSETS2[m][0] + "/" + OFFSETS2[m][1]);
	234	}
	235	}
	236	}
	237
	238	// Test getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
	239	// int32_t& rawOffset, int32_t& dstOffset, UErroCode& status)
	240	// with nonExistingTimeOpt=kStandard/duplicatedTimeOpt=kStandard
	241	for (int32_t i = 0; i < NUM_TIMEZONES; i++) {
	242	for (int m = 0; m < NUM_DATES; m++) {
	243	status = U_ZERO_ERROR;
	244	TESTZONES[i]->getOffsetFromLocal(MILLIS[m], BasicTimeZone::kStandard, BasicTimeZone::kStandard,
	245	rawOffset, dstOffset, status);
	246	if (U_FAILURE(status)) {
	247	errln((UnicodeString)"getOffsetFromLocal with kStandard/kStandard failed for TESTZONES[" + i + "]");
	248	} else if (rawOffset != OFFSETS2[m][0] \|\| dstOffset != OFFSETS2[m][1]) {
	249	dateStr.remove();
	250	df.format(MILLIS[m], dateStr);
729e4ab9	251	dataerrln((UnicodeString)"Bad offset returned by TESTZONES[" + i + "] at "
46f4442e A	252	+ dateStr + "(wall/kStandard/kStandard) - Got: "
	253	+ rawOffset + "/" + dstOffset
	254	+ " Expected: " + OFFSETS2[m][0] + "/" + OFFSETS2[m][1]);
	255	}
	256	}
	257	}
	258
	259	// Test getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
	260	// int32_t& rawOffset, int32_t& dstOffset, UErroCode& status)
	261	// with nonExistingTimeOpt=kDaylight/duplicatedTimeOpt=kDaylight
	262	for (int32_t i = 0; i < NUM_TIMEZONES; i++) {
	263	for (int m = 0; m < NUM_DATES; m++) {
	264	status = U_ZERO_ERROR;
	265	TESTZONES[i]->getOffsetFromLocal(MILLIS[m], BasicTimeZone::kDaylight, BasicTimeZone::kDaylight,
	266	rawOffset, dstOffset, status);
	267	if (U_FAILURE(status)) {
	268	errln((UnicodeString)"getOffsetFromLocal with kDaylight/kDaylight failed for TESTZONES[" + i + "]");
	269	} else if (rawOffset != OFFSETS3[m][0] \|\| dstOffset != OFFSETS3[m][1]) {
	270	dateStr.remove();
	271	df.format(MILLIS[m], dateStr);
729e4ab9	272	dataerrln((UnicodeString)"Bad offset returned by TESTZONES[" + i + "] at "
46f4442e A	273	+ dateStr + "(wall/kDaylight/kDaylight) - Got: "
	274	+ rawOffset + "/" + dstOffset
	275	+ " Expected: " + OFFSETS3[m][0] + "/" + OFFSETS3[m][1]);
	276	}
	277	}
	278	}
	279
	280	// Test getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
	281	// int32_t& rawOffset, int32_t& dstOffset, UErroCode& status)
	282	// with nonExistingTimeOpt=kFormer/duplicatedTimeOpt=kLatter
	283	for (int32_t i = 0; i < NUM_TIMEZONES; i++) {
	284	for (int m = 0; m < NUM_DATES; m++) {
	285	status = U_ZERO_ERROR;
	286	TESTZONES[i]->getOffsetFromLocal(MILLIS[m], BasicTimeZone::kFormer, BasicTimeZone::kLatter,
	287	rawOffset, dstOffset, status);
	288	if (U_FAILURE(status)) {
	289	errln((UnicodeString)"getOffsetFromLocal with kFormer/kLatter failed for TESTZONES[" + i + "]");
	290	} else if (rawOffset != OFFSETS2[m][0] \|\| dstOffset != OFFSETS2[m][1]) {
	291	dateStr.remove();
	292	df.format(MILLIS[m], dateStr);
729e4ab9	293	dataerrln((UnicodeString)"Bad offset returned by TESTZONES[" + i + "] at "
46f4442e A	294	+ dateStr + "(wall/kFormer/kLatter) - Got: "
	295	+ rawOffset + "/" + dstOffset
	296	+ " Expected: " + OFFSETS2[m][0] + "/" + OFFSETS2[m][1]);
	297	}
	298	}
	299	}
	300
	301	// Test getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
	302	// int32_t& rawOffset, int32_t& dstOffset, UErroCode& status)
	303	// with nonExistingTimeOpt=kLatter/duplicatedTimeOpt=kFormer
	304	for (int32_t i = 0; i < NUM_TIMEZONES; i++) {
	305	for (int m = 0; m < NUM_DATES; m++) {
	306	status = U_ZERO_ERROR;
	307	TESTZONES[i]->getOffsetFromLocal(MILLIS[m], BasicTimeZone::kLatter, BasicTimeZone::kFormer,
	308	rawOffset, dstOffset, status);
	309	if (U_FAILURE(status)) {
	310	errln((UnicodeString)"getOffsetFromLocal with kLatter/kFormer failed for TESTZONES[" + i + "]");
	311	} else if (rawOffset != OFFSETS3[m][0] \|\| dstOffset != OFFSETS3[m][1]) {
	312	dateStr.remove();
	313	df.format(MILLIS[m], dateStr);
729e4ab9	314	dataerrln((UnicodeString)"Bad offset returned by TESTZONES[" + i + "] at "
46f4442e A	315	+ dateStr + "(wall/kLatter/kFormer) - Got: "
	316	+ rawOffset + "/" + dstOffset
	317	+ " Expected: " + OFFSETS3[m][0] + "/" + OFFSETS3[m][1]);
	318	}
	319	}
	320	}
	321
	322	for (int32_t i = 0; i < NUM_TIMEZONES; i++) {
	323	delete TESTZONES[i];
	324	}
	325	delete utc;
	326	delete cal;
	327	}
	328
	329	#endif /* #if !UCONFIG_NO_FORMATTING */