]> git.saurik.com Git - apple/icu.git/blob - icuSources/test/intltest/tzrulets.cpp
projects / apple / icu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ICU-461.13.tar.gz
[apple/icu.git] / icuSources / test / intltest / tzrulets.cpp
1 /*
2 *******************************************************************************
3 * Copyright (C) 2007-2010, International Business Machines Corporation and *
4 * others. All Rights Reserved. *
5 *******************************************************************************
6 */
7
8 #include "unicode/utypes.h"
9
10 #if !UCONFIG_NO_FORMATTING
11
12 #include "unicode/dtrule.h"
13 #include "unicode/tzrule.h"
14 #include "unicode/rbtz.h"
15 #include "unicode/simpletz.h"
16 #include "unicode/tzrule.h"
17 #include "unicode/calendar.h"
18 #include "unicode/gregocal.h"
19 #include "unicode/ucal.h"
20 #include "unicode/unistr.h"
21 #include "unicode/ustring.h"
22 #include "unicode/tztrans.h"
23 #include "unicode/vtzone.h"
24 #include "tzrulets.h"
25 #include "zrule.h"
26 #include "ztrans.h"
27 #include "vzone.h"
28 #include "cmemory.h"
29
30 #define CASE(id,test) case id: name = #test; if (exec) { logln(#test "---"); logln((UnicodeString)""); test(); } break
31 #define HOUR (60*60*1000)
32
33 static const UVersionInfo ICU_453 = {4,5,3,0};
34
35 static const char *const TESTZIDS[] = {
36 "AGT",
37 "America/New_York",
38 "America/Los_Angeles",
39 "America/Indiana/Indianapolis",
40 "America/Havana",
41 "Europe/Lisbon",
42 "Europe/Paris",
43 "Asia/Tokyo",
44 "Asia/Sakhalin",
45 "Africa/Cairo",
46 "Africa/Windhoek",
47 "Australia/Sydney",
48 "Etc/GMT+8"
49 };
50
51 static UBool hasEquivalentTransitions(/*const*/ BasicTimeZone& tz1, /*const*/BasicTimeZone& tz2,
52 UDate start, UDate end,
53 UBool ignoreDstAmount, int32_t maxTransitionTimeDelta,
54 UErrorCode& status);
55
56 class TestZIDEnumeration : public StringEnumeration {
57 public:
58 TestZIDEnumeration(UBool all = FALSE);
59 ~TestZIDEnumeration();
60
61 virtual int32_t count(UErrorCode& /*status*/) const {
62 return len;
63 }
64 virtual const UnicodeString *snext(UErrorCode& status);
65 virtual void reset(UErrorCode& status);
66 static inline UClassID getStaticClassID() {
67 return (UClassID)&fgClassID;
68 }
69 virtual UClassID getDynamicClassID() const {
70 return getStaticClassID();
71 }
72 private:
73 static const char fgClassID;
74 int32_t idx;
75 int32_t len;
76 StringEnumeration *tzenum;
77 };
78
79 const char TestZIDEnumeration::fgClassID = 0;
80
81 TestZIDEnumeration::TestZIDEnumeration(UBool all)
82 : idx(0) {
83 UErrorCode status = U_ZERO_ERROR;
84 if (all) {
85 tzenum = TimeZone::createEnumeration();
86 len = tzenum->count(status);
87 } else {
88 tzenum = NULL;
89 len = (int32_t)sizeof(TESTZIDS)/sizeof(TESTZIDS[0]);
90 }
91 }
92
93 TestZIDEnumeration::~TestZIDEnumeration() {
94 if (tzenum != NULL) {
95 delete tzenum;
96 }
97 }
98
99 const UnicodeString*
100 TestZIDEnumeration::snext(UErrorCode& status) {
101 if (tzenum != NULL) {
102 return tzenum->snext(status);
103 } else if (U_SUCCESS(status) && idx < len) {
104 unistr = UnicodeString(TESTZIDS[idx++], "");
105 return &unistr;
106 }
107 return NULL;
108 }
109
110 void
111 TestZIDEnumeration::reset(UErrorCode& status) {
112 if (tzenum != NULL) {
113 tzenum->reset(status);
114 } else {
115 idx = 0;
116 }
117 }
118
119
120 void TimeZoneRuleTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
121 {
122 if (exec) {
123 logln("TestSuite TestTimeZoneRule");
124 }
125 switch (index) {
126 CASE(0, TestSimpleRuleBasedTimeZone);
127 CASE(1, TestHistoricalRuleBasedTimeZone);
128 CASE(2, TestOlsonTransition);
129 CASE(3, TestRBTZTransition);
130 CASE(4, TestHasEquivalentTransitions);
131 CASE(5, TestVTimeZoneRoundTrip);
132 CASE(6, TestVTimeZoneRoundTripPartial);
133 CASE(7, TestVTimeZoneSimpleWrite);
134 CASE(8, TestVTimeZoneHeaderProps);
135 CASE(9, TestGetSimpleRules);
136 CASE(10, TestTimeZoneRuleCoverage);
137 CASE(11, TestSimpleTimeZoneCoverage);
138 CASE(12, TestVTimeZoneCoverage);
139 CASE(13, TestVTimeZoneParse);
140 CASE(14, TestT6216);
141 CASE(15, TestT6669);
142 CASE(16, TestVTimeZoneWrapper);
143 default: name = ""; break;
144 }
145 }
146
147 /*
148 * Compare SimpleTimeZone with equivalent RBTZ
149 */
150 void
151 TimeZoneRuleTest::TestSimpleRuleBasedTimeZone(void) {
152 UErrorCode status = U_ZERO_ERROR;
153 SimpleTimeZone stz(-1*HOUR, "TestSTZ",
154 UCAL_SEPTEMBER, -30, -UCAL_SATURDAY, 1*HOUR, SimpleTimeZone::WALL_TIME,
155 UCAL_FEBRUARY, 2, UCAL_SUNDAY, 1*HOUR, SimpleTimeZone::WALL_TIME,
156 1*HOUR, status);
157 if (U_FAILURE(status)) {
158 errln("FAIL: Couldn't create SimpleTimezone.");
159 }
160
161 DateTimeRule *dtr;
162 AnnualTimeZoneRule *atzr;
163 int32_t STARTYEAR = 2000;
164
165 InitialTimeZoneRule *ir = new InitialTimeZoneRule(
166 "RBTZ_Initial", // Initial time Name
167 -1*HOUR, // Raw offset
168 1*HOUR); // DST saving amount
169
170 // Original rules
171 RuleBasedTimeZone *rbtz1 = new RuleBasedTimeZone("RBTZ1", ir->clone());
172 dtr = new DateTimeRule(UCAL_SEPTEMBER, 30, UCAL_SATURDAY, FALSE,
173 1*HOUR, DateTimeRule::WALL_TIME); // SUN<=30 in September, at 1AM wall time
174 atzr = new AnnualTimeZoneRule("RBTZ_DST1",
175 -1*HOUR /*rawOffset*/, 1*HOUR /*dstSavings*/, dtr,
176 STARTYEAR, AnnualTimeZoneRule::MAX_YEAR);
177 rbtz1->addTransitionRule(atzr, status);
178 if (U_FAILURE(status)) {
179 errln("FAIL: couldn't add AnnualTimeZoneRule 1-1.");
180 }
181 dtr = new DateTimeRule(UCAL_FEBRUARY, 2, UCAL_SUNDAY,
182 1*HOUR, DateTimeRule::WALL_TIME); // 2nd Sunday in February, at 1AM wall time
183 atzr = new AnnualTimeZoneRule("RBTZ_STD1",
184 -1*HOUR /*rawOffset*/, 0 /*dstSavings*/, dtr,
185 STARTYEAR, AnnualTimeZoneRule::MAX_YEAR);
186 rbtz1->addTransitionRule(atzr, status);
187 if (U_FAILURE(status)) {
188 errln("FAIL: couldn't add AnnualTimeZoneRule 1-2.");
189 }
190 rbtz1->complete(status);
191 if (U_FAILURE(status)) {
192 errln("FAIL: couldn't complete RBTZ 1.");
193 }
194
195 // Equivalent, but different date rule type
196 RuleBasedTimeZone *rbtz2 = new RuleBasedTimeZone("RBTZ2", ir->clone());
197 dtr = new DateTimeRule(UCAL_SEPTEMBER, -1, UCAL_SATURDAY,
198 1*HOUR, DateTimeRule::WALL_TIME); // Last Sunday in September at 1AM wall time
199 atzr = new AnnualTimeZoneRule("RBTZ_DST2", -1*HOUR, 1*HOUR, dtr, STARTYEAR, AnnualTimeZoneRule::MAX_YEAR);
200 rbtz2->addTransitionRule(atzr, status);
201 if (U_FAILURE(status)) {
202 errln("FAIL: couldn't add AnnualTimeZoneRule 2-1.");
203 }
204 dtr = new DateTimeRule(UCAL_FEBRUARY, 8, UCAL_SUNDAY, true,
205 1*HOUR, DateTimeRule::WALL_TIME); // SUN>=8 in February, at 1AM wall time
206 atzr = new AnnualTimeZoneRule("RBTZ_STD2", -1*HOUR, 0, dtr, STARTYEAR, AnnualTimeZoneRule::MAX_YEAR);
207 rbtz2->addTransitionRule(atzr, status);
208 if (U_FAILURE(status)) {
209 errln("FAIL: couldn't add AnnualTimeZoneRule 2-2.");
210 }
211 rbtz2->complete(status);
212 if (U_FAILURE(status)) {
213 errln("FAIL: couldn't complete RBTZ 2");
214 }
215
216 // Equivalent, but different time rule type
217 RuleBasedTimeZone *rbtz3 = new RuleBasedTimeZone("RBTZ3", ir->clone());
218 dtr = new DateTimeRule(UCAL_SEPTEMBER, 30, UCAL_SATURDAY, false,
219 2*HOUR, DateTimeRule::UTC_TIME);
220 atzr = new AnnualTimeZoneRule("RBTZ_DST3", -1*HOUR, 1*HOUR, dtr, STARTYEAR, AnnualTimeZoneRule::MAX_YEAR);
221 rbtz3->addTransitionRule(atzr, status);
222 if (U_FAILURE(status)) {
223 errln("FAIL: couldn't add AnnualTimeZoneRule 3-1.");
224 }
225 dtr = new DateTimeRule(UCAL_FEBRUARY, 2, UCAL_SUNDAY,
226 0*HOUR, DateTimeRule::STANDARD_TIME);
227 atzr = new AnnualTimeZoneRule("RBTZ_STD3", -1*HOUR, 0, dtr, STARTYEAR, AnnualTimeZoneRule::MAX_YEAR);
228 rbtz3->addTransitionRule(atzr, status);
229 if (U_FAILURE(status)) {
230 errln("FAIL: couldn't add AnnualTimeZoneRule 3-2.");
231 }
232 rbtz3->complete(status);
233 if (U_FAILURE(status)) {
234 errln("FAIL: couldn't complete RBTZ 3");
235 }
236
237 // Check equivalency for 10 years
238 UDate start = getUTCMillis(STARTYEAR, UCAL_JANUARY, 1);
239 UDate until = getUTCMillis(STARTYEAR + 10, UCAL_JANUARY, 1);
240
241 if (!(stz.hasEquivalentTransitions(*rbtz1, start, until, TRUE, status))) {
242 errln("FAIL: rbtz1 must be equivalent to the SimpleTimeZone in the time range.");
243 }
244 if (U_FAILURE(status)) {
245 errln("FAIL: error returned from hasEquivalentTransitions");
246 }
247 if (!(stz.hasEquivalentTransitions(*rbtz2, start, until, TRUE, status))) {
248 errln("FAIL: rbtz2 must be equivalent to the SimpleTimeZone in the time range.");
249 }
250 if (U_FAILURE(status)) {
251 errln("FAIL: error returned from hasEquivalentTransitions");
252 }
253 if (!(stz.hasEquivalentTransitions(*rbtz3, start, until, TRUE, status))) {
254 errln("FAIL: rbtz3 must be equivalent to the SimpleTimeZone in the time range.");
255 }
256 if (U_FAILURE(status)) {
257 errln("FAIL: error returned from hasEquivalentTransitions");
258 }
259
260 // hasSameRules
261 if (rbtz1->hasSameRules(*rbtz2)) {
262 errln("FAIL: rbtz1 and rbtz2 have different rules, but returned true.");
263 }
264 if (rbtz1->hasSameRules(*rbtz3)) {
265 errln("FAIL: rbtz1 and rbtz3 have different rules, but returned true.");
266 }
267 RuleBasedTimeZone *rbtz1c = (RuleBasedTimeZone*)rbtz1->clone();
268 if (!rbtz1->hasSameRules(*rbtz1c)) {
269 errln("FAIL: Cloned RuleBasedTimeZone must have the same rules with the original.");
270 }
271
272 // getOffset
273 int32_t era, year, month, dayOfMonth, dayOfWeek, millisInDay;
274 UDate time;
275 int32_t offset, dstSavings;
276 UBool dst;
277
278 GregorianCalendar *cal = new GregorianCalendar(status);
279 if (U_FAILURE(status)) {
280 dataerrln("FAIL: Could not create a Gregorian calendar instance.: %s", u_errorName(status));
281 delete rbtz1;
282 delete rbtz2;
283 delete rbtz3;
284 delete rbtz1c;
285 return;
286 }
287 cal->setTimeZone(*rbtz1);
288 cal->clear();
289
290 // Jan 1, 1000 BC
291 cal->set(UCAL_ERA, GregorianCalendar::BC);
292 cal->set(1000, UCAL_JANUARY, 1);
293
294 era = cal->get(UCAL_ERA, status);
295 year = cal->get(UCAL_YEAR, status);
296 month = cal->get(UCAL_MONTH, status);
297 dayOfMonth = cal->get(UCAL_DAY_OF_MONTH, status);
298 dayOfWeek = cal->get(UCAL_DAY_OF_WEEK, status);
299 millisInDay = cal->get(UCAL_MILLISECONDS_IN_DAY, status);
300 time = cal->getTime(status);
301 if (U_FAILURE(status)) {
302 errln("FAIL: Could not get calendar field values.");
303 }
304 offset = rbtz1->getOffset(era, year, month, dayOfMonth, dayOfWeek, millisInDay, status);
305 if (U_FAILURE(status)) {
306 errln("FAIL: getOffset(7 args) failed.");
307 }
308 if (offset != 0) {
309 errln(UnicodeString("FAIL: Invalid time zone offset: ") + offset + " /expected: 0");
310 }
311 dst = rbtz1->inDaylightTime(time, status);
312 if (U_FAILURE(status)) {
313 errln("FAIL: inDaylightTime failed.");
314 }
315 if (!dst) {
316 errln("FAIL: Invalid daylight saving time");
317 }
318 rbtz1->getOffset(time, TRUE, offset, dstSavings, status);
319 if (U_FAILURE(status)) {
320 errln("FAIL: getOffset(5 args) failed.");
321 }
322 if (offset != -3600000) {
323 errln(UnicodeString("FAIL: Invalid time zone raw offset: ") + offset + " /expected: -3600000");
324 }
325 if (dstSavings != 3600000) {
326 errln(UnicodeString("FAIL: Invalid DST amount: ") + dstSavings + " /expected: 3600000");
327 }
328
329 // July 1, 2000, AD
330 cal->set(UCAL_ERA, GregorianCalendar::AD);
331 cal->set(2000, UCAL_JULY, 1);
332
333 era = cal->get(UCAL_ERA, status);
334 year = cal->get(UCAL_YEAR, status);
335 month = cal->get(UCAL_MONTH, status);
336 dayOfMonth = cal->get(UCAL_DAY_OF_MONTH, status);
337 dayOfWeek = cal->get(UCAL_DAY_OF_WEEK, status);
338 millisInDay = cal->get(UCAL_MILLISECONDS_IN_DAY, status);
339 time = cal->getTime(status);
340 if (U_FAILURE(status)) {
341 errln("FAIL: Could not get calendar field values.");
342 }
343 offset = rbtz1->getOffset(era, year, month, dayOfMonth, dayOfWeek, millisInDay, status);
344 if (U_FAILURE(status)) {
345 errln("FAIL: getOffset(7 args) failed.");
346 }
347 if (offset != -3600000) {
348 errln((UnicodeString)"FAIL: Invalid time zone offset: " + offset + " /expected: -3600000");
349 }
350 dst = rbtz1->inDaylightTime(time, status);
351 if (U_FAILURE(status)) {
352 errln("FAIL: inDaylightTime failed.");
353 }
354 if (dst) {
355 errln("FAIL: Invalid daylight saving time");
356 }
357 rbtz1->getOffset(time, TRUE, offset, dstSavings, status);
358 if (U_FAILURE(status)) {
359 errln("FAIL: getOffset(5 args) failed.");
360 }
361 if (offset != -3600000) {
362 errln((UnicodeString)"FAIL: Invalid time zone raw offset: " + offset + " /expected: -3600000");
363 }
364 if (dstSavings != 0) {
365 errln((UnicodeString)"FAIL: Invalid DST amount: " + dstSavings + " /expected: 0");
366 }
367
368 // getRawOffset
369 offset = rbtz1->getRawOffset();
370 if (offset != -1*HOUR) {
371 errln((UnicodeString)"FAIL: Invalid time zone raw offset returned by getRawOffset: "
372 + offset + " /expected: -3600000");
373 }
374
375 // operator=/==/!=
376 RuleBasedTimeZone rbtz0("RBTZ1", ir->clone());
377 if (rbtz0 == *rbtz1 || !(rbtz0 != *rbtz1)) {
378 errln("FAIL: RuleBasedTimeZone rbtz0 is not equal to rbtz1, but got wrong result");
379 }
380 rbtz0 = *rbtz1;
381 if (rbtz0 != *rbtz1 || !(rbtz0 == *rbtz1)) {
382 errln("FAIL: RuleBasedTimeZone rbtz0 is equal to rbtz1, but got wrong result");
383 }
384
385 // setRawOffset
386 const int32_t RAW = -10*HOUR;
387 rbtz0.setRawOffset(RAW);
388 if (rbtz0.getRawOffset() != RAW) {
389 logln("setRawOffset is implemented in RuleBasedTimeZone");
390 }
391
392 // useDaylightTime
393 if (!rbtz1->useDaylightTime()) {
394 errln("FAIL: useDaylightTime returned FALSE");
395 }
396
397 // Try to add 3rd final rule
398 dtr = new DateTimeRule(UCAL_OCTOBER, 15, 1*HOUR, DateTimeRule::WALL_TIME);
399 atzr = new AnnualTimeZoneRule("3RD_ATZ", -1*HOUR, 2*HOUR, dtr, STARTYEAR, AnnualTimeZoneRule::MAX_YEAR);
400 rbtz1->addTransitionRule(atzr, status);
401 if (U_SUCCESS(status)) {
402 errln("FAIL: 3rd final rule must be rejected");
403 } else {
404 delete atzr;
405 }
406
407 // Try to add an initial rule
408 InitialTimeZoneRule *ir1 = new InitialTimeZoneRule("Test Initial", 2*HOUR, 0);
409 rbtz1->addTransitionRule(ir1, status);
410 if (U_SUCCESS(status)) {
411 errln("FAIL: InitialTimeZoneRule must be rejected");
412 } else {
413 delete ir1;
414 }
415
416 delete ir;
417 delete rbtz1;
418 delete rbtz2;
419 delete rbtz3;
420 delete rbtz1c;
421 delete cal;
422 }
423
424 /*
425 * Test equivalency between OlsonTimeZone and custom RBTZ representing the
426 * equivalent rules in a certain time range
427 */
428 void
429 TimeZoneRuleTest::TestHistoricalRuleBasedTimeZone(void) {
430 UErrorCode status = U_ZERO_ERROR;
431
432 // Compare to America/New_York with equivalent RBTZ
433 BasicTimeZone *ny = (BasicTimeZone*)TimeZone::createTimeZone("America/New_York");
434
435 //RBTZ
436 InitialTimeZoneRule *ir = new InitialTimeZoneRule("EST", -5*HOUR, 0);
437 RuleBasedTimeZone *rbtz = new RuleBasedTimeZone("EST5EDT", ir);
438
439 DateTimeRule *dtr;
440 AnnualTimeZoneRule *tzr;
441
442 // Standard time
443 dtr = new DateTimeRule(UCAL_OCTOBER, -1, UCAL_SUNDAY,
444 2*HOUR, DateTimeRule::WALL_TIME); // Last Sunday in October, at 2AM wall time
445 tzr = new AnnualTimeZoneRule("EST", -5*HOUR /*rawOffset*/, 0 /*dstSavings*/, dtr, 1967, 2006);
446 rbtz->addTransitionRule(tzr, status);
447 if (U_FAILURE(status)) {
448 errln("FAIL: couldn't add AnnualTimeZoneRule 1.");
449 }
450
451 dtr = new DateTimeRule(UCAL_NOVEMBER, 1, UCAL_SUNDAY,
452 true, 2*HOUR, DateTimeRule::WALL_TIME); // SUN>=1 in November, at 2AM wall time
453 tzr = new AnnualTimeZoneRule("EST", -5*HOUR, 0, dtr, 2007, AnnualTimeZoneRule::MAX_YEAR);
454 rbtz->addTransitionRule(tzr, status);
455 if (U_FAILURE(status)) {
456 errln("FAIL: couldn't add AnnualTimeZoneRule 2.");
457 }
458
459 // Daylight saving time
460 dtr = new DateTimeRule(UCAL_APRIL, -1, UCAL_SUNDAY,
461 2*HOUR, DateTimeRule::WALL_TIME); // Last Sunday in April, at 2AM wall time
462 tzr = new AnnualTimeZoneRule("EDT", -5*HOUR, 1*HOUR, dtr, 1967, 1973);
463 rbtz->addTransitionRule(tzr, status);
464 if (U_FAILURE(status)) {
465 errln("FAIL: couldn't add AnnualTimeZoneRule 3.");
466 }
467
468 dtr = new DateTimeRule(UCAL_JANUARY, 6,
469 2*HOUR, DateTimeRule::WALL_TIME); // January 6, at 2AM wall time
470 tzr = new AnnualTimeZoneRule("EDT", -5*HOUR, 1*HOUR, dtr, 1974, 1974);
471 rbtz->addTransitionRule(tzr, status);
472 if (U_FAILURE(status)) {
473 errln("FAIL: couldn't add AnnualTimeZoneRule 4.");
474 }
475
476 dtr = new DateTimeRule(UCAL_FEBRUARY, 23,
477 2*HOUR, DateTimeRule::WALL_TIME); // February 23, at 2AM wall time
478 tzr = new AnnualTimeZoneRule("EDT", -5*HOUR, 1*HOUR, dtr, 1975, 1975);
479 rbtz->addTransitionRule(tzr, status);
480 if (U_FAILURE(status)) {
481 errln("FAIL: couldn't add AnnualTimeZoneRule 5.");
482 }
483
484 dtr = new DateTimeRule(UCAL_APRIL, -1, UCAL_SUNDAY,
485 2*HOUR, DateTimeRule::WALL_TIME); // Last Sunday in April, at 2AM wall time
486 tzr = new AnnualTimeZoneRule("EDT", -5*HOUR, 1*HOUR, dtr, 1976, 1986);
487 rbtz->addTransitionRule(tzr, status);
488 if (U_FAILURE(status)) {
489 errln("FAIL: couldn't add AnnualTimeZoneRule 6.");
490 }
491
492 dtr = new DateTimeRule(UCAL_APRIL, 1, UCAL_SUNDAY,
493 true, 2*HOUR, DateTimeRule::WALL_TIME); // SUN>=1 in April, at 2AM wall time
494 tzr = new AnnualTimeZoneRule("EDT", -5*HOUR, 1*HOUR, dtr, 1987, 2006);
495 rbtz->addTransitionRule(tzr, status);
496 if (U_FAILURE(status)) {
497 errln("FAIL: couldn't add AnnualTimeZoneRule 7.");
498 }
499
500 dtr = new DateTimeRule(UCAL_MARCH, 8, UCAL_SUNDAY,
501 true, 2*HOUR, DateTimeRule::WALL_TIME); // SUN>=8 in March, at 2AM wall time
502 tzr = new AnnualTimeZoneRule("EDT", -5*HOUR, 1*HOUR, dtr, 2007, AnnualTimeZoneRule::MAX_YEAR);
503 rbtz->addTransitionRule(tzr, status);
504 if (U_FAILURE(status)) {
505 errln("FAIL: couldn't add AnnualTimeZoneRule 7.");
506 }
507
508 rbtz->complete(status);
509 if (U_FAILURE(status)) {
510 errln("FAIL: couldn't complete RBTZ.");
511 }
512
513 // hasEquivalentTransitions
514 UDate jan1_1950 = getUTCMillis(1950, UCAL_JANUARY, 1);
515 UDate jan1_1967 = getUTCMillis(1971, UCAL_JANUARY, 1);
516 UDate jan1_2010 = getUTCMillis(2010, UCAL_JANUARY, 1);
517
518 if (!ny->hasEquivalentTransitions(*rbtz, jan1_1967, jan1_2010, TRUE, status)) {
519 dataerrln("FAIL: The RBTZ must be equivalent to America/New_York between 1967 and 2010");
520 }
521 if (U_FAILURE(status)) {
522 errln("FAIL: error returned from hasEquivalentTransitions for ny/rbtz 1967-2010");
523 }
524 if (ny->hasEquivalentTransitions(*rbtz, jan1_1950, jan1_2010, TRUE, status)) {
525 errln("FAIL: The RBTZ must not be equivalent to America/New_York between 1950 and 2010");
526 }
527 if (U_FAILURE(status)) {
528 errln("FAIL: error returned from hasEquivalentTransitions for ny/rbtz 1950-2010");
529 }
530
531 // Same with above, but calling RBTZ#hasEquivalentTransitions against OlsonTimeZone
532 if (!rbtz->hasEquivalentTransitions(*ny, jan1_1967, jan1_2010, TRUE, status)) {
533 dataerrln("FAIL: The RBTZ must be equivalent to America/New_York between 1967 and 2010 ");
534 }
535 if (U_FAILURE(status)) {
536 errln("FAIL: error returned from hasEquivalentTransitions for rbtz/ny 1967-2010");
537 }
538 if (rbtz->hasEquivalentTransitions(*ny, jan1_1950, jan1_2010, TRUE, status)) {
539 errln("FAIL: The RBTZ must not be equivalent to America/New_York between 1950 and 2010");
540 }
541 if (U_FAILURE(status)) {
542 errln("FAIL: error returned from hasEquivalentTransitions for rbtz/ny 1950-2010");
543 }
544
545 // TimeZone APIs
546 if (ny->hasSameRules(*rbtz) || rbtz->hasSameRules(*ny)) {
547 errln("FAIL: hasSameRules must return false");
548 }
549 RuleBasedTimeZone *rbtzc = (RuleBasedTimeZone*)rbtz->clone();
550 if (!rbtz->hasSameRules(*rbtzc) || !rbtz->hasEquivalentTransitions(*rbtzc, jan1_1950, jan1_2010, TRUE, status)) {
551 errln("FAIL: hasSameRules/hasEquivalentTransitions must return true for cloned RBTZs");
552 }
553 if (U_FAILURE(status)) {
554 errln("FAIL: error returned from hasEquivalentTransitions for rbtz/rbtzc 1950-2010");
555 }
556
557 UDate times[] = {
558 getUTCMillis(2006, UCAL_MARCH, 15),
559 getUTCMillis(2006, UCAL_NOVEMBER, 1),
560 getUTCMillis(2007, UCAL_MARCH, 15),
561 getUTCMillis(2007, UCAL_NOVEMBER, 1),
562 getUTCMillis(2008, UCAL_MARCH, 15),
563 getUTCMillis(2008, UCAL_NOVEMBER, 1),
564 0
565 };
566 int32_t offset1, dst1;
567 int32_t offset2, dst2;
568
569 for (int i = 0; times[i] != 0; i++) {
570 // Check getOffset - must return the same results for these time data
571 rbtz->getOffset(times[i], FALSE, offset1, dst1, status);
572 if (U_FAILURE(status)) {
573 errln("FAIL: rbtz->getOffset failed");
574 }
575 ny->getOffset(times[i], FALSE, offset2, dst2, status);
576 if (U_FAILURE(status)) {
577 errln("FAIL: ny->getOffset failed");
578 }
579 if (offset1 != offset2 || dst1 != dst2) {
580 dataerrln("FAIL: Incompatible time zone offset/dstSavings for ny and rbtz");
581 }
582
583 // Check inDaylightTime
584 if (rbtz->inDaylightTime(times[i], status) != ny->inDaylightTime(times[i], status)) {
585 dataerrln("FAIL: Incompatible daylight saving time for ny and rbtz");
586 }
587 if (U_FAILURE(status)) {
588 errln("FAIL: inDaylightTime failed");
589 }
590 }
591
592 delete ny;
593 delete rbtz;
594 delete rbtzc;
595 }
596
597 /*
598 * Check if transitions returned by getNextTransition/getPreviousTransition
599 * are actual time transitions.
600 */
601 void
602 TimeZoneRuleTest::TestOlsonTransition(void) {
603
604 const int32_t TESTYEARS[][2] = {
605 {1895, 1905}, // including int32 minimum second
606 {1965, 1975}, // including the epoch
607 {1995, 2015}, // practical year range
608 {0,0}
609 };
610
611 UErrorCode status = U_ZERO_ERROR;
612 TestZIDEnumeration tzenum(!quick);
613 while (TRUE) {
614 const UnicodeString *tzid = tzenum.snext(status);
615 if (tzid == NULL) {
616 break;
617 }
618 if (U_FAILURE(status)) {
619 errln("FAIL: error returned while enumerating timezone IDs.");
620 break;
621 }
622 BasicTimeZone *tz = (BasicTimeZone*)TimeZone::createTimeZone(*tzid);
623 for (int32_t i = 0; TESTYEARS[i][0] != 0 || TESTYEARS[i][1] != 0; i++) {
624 UDate lo = getUTCMillis(TESTYEARS[i][0], UCAL_JANUARY, 1);
625 UDate hi = getUTCMillis(TESTYEARS[i][1], UCAL_JANUARY, 1);
626 verifyTransitions(*tz, lo, hi);
627 }
628 delete tz;
629 }
630 }
631
632 /*
633 * Check if an OlsonTimeZone and its equivalent RBTZ have the exact same
634 * transitions.
635 */
636 void
637 TimeZoneRuleTest::TestRBTZTransition(void) {
638 const int32_t STARTYEARS[] = {
639 1900,
640 1960,
641 1990,
642 2010,
643 0
644 };
645
646 UErrorCode status = U_ZERO_ERROR;
647 TestZIDEnumeration tzenum(!quick);
648 while (TRUE) {
649 const UnicodeString *tzid = tzenum.snext(status);
650 if (tzid == NULL) {
651 break;
652 }
653 if (U_FAILURE(status)) {
654 errln("FAIL: error returned while enumerating timezone IDs.");
655 break;
656 }
657 BasicTimeZone *tz = (BasicTimeZone*)TimeZone::createTimeZone(*tzid);
658 int32_t ruleCount = tz->countTransitionRules(status);
659
660 const InitialTimeZoneRule *initial;
661 const TimeZoneRule **trsrules = new const TimeZoneRule*[ruleCount];
662 tz->getTimeZoneRules(initial, trsrules, ruleCount, status);
663 if (U_FAILURE(status)) {
664 errln((UnicodeString)"FAIL: failed to get the TimeZoneRules from time zone " + *tzid);
665 }
666 RuleBasedTimeZone *rbtz = new RuleBasedTimeZone(*tzid, initial->clone());
667 if (U_FAILURE(status)) {
668 errln((UnicodeString)"FAIL: failed to get the transition rule count from time zone " + *tzid);
669 }
670 for (int32_t i = 0; i < ruleCount; i++) {
671 rbtz->addTransitionRule(trsrules[i]->clone(), status);
672 if (U_FAILURE(status)) {
673 errln((UnicodeString)"FAIL: failed to add a transition rule at index " + i + " to the RBTZ for " + *tzid);
674 }
675 }
676 rbtz->complete(status);
677 if (U_FAILURE(status)) {
678 errln((UnicodeString)"FAIL: complete() failed for the RBTZ for " + *tzid);
679 }
680
681 for (int32_t idx = 0; STARTYEARS[idx] != 0; idx++) {
682 UDate start = getUTCMillis(STARTYEARS[idx], UCAL_JANUARY, 1);
683 UDate until = getUTCMillis(STARTYEARS[idx] + 20, UCAL_JANUARY, 1);
684 // Compare the original OlsonTimeZone with the RBTZ starting the startTime for 20 years
685
686 // Ascending
687 compareTransitionsAscending(*tz, *rbtz, start, until, FALSE);
688 // Ascending/inclusive
689 compareTransitionsAscending(*tz, *rbtz, start + 1, until, TRUE);
690 // Descending
691 compareTransitionsDescending(*tz, *rbtz, start, until, FALSE);
692 // Descending/inclusive
693 compareTransitionsDescending(*tz, *rbtz, start + 1, until, TRUE);
694 }
695 delete [] trsrules;
696 delete rbtz;
697 delete tz;
698 }
699 }
700
701 void
702 TimeZoneRuleTest::TestHasEquivalentTransitions(void) {
703 // America/New_York and America/Indiana/Indianapolis are equivalent
704 // since 2006
705 UErrorCode status = U_ZERO_ERROR;
706 BasicTimeZone *newyork = (BasicTimeZone*)TimeZone::createTimeZone("America/New_York");
707 BasicTimeZone *indianapolis = (BasicTimeZone*)TimeZone::createTimeZone("America/Indiana/Indianapolis");
708 BasicTimeZone *gmt_5 = (BasicTimeZone*)TimeZone::createTimeZone("Etc/GMT+5");
709
710 UDate jan1_1971 = getUTCMillis(1971, UCAL_JANUARY, 1);
711 UDate jan1_2005 = getUTCMillis(2005, UCAL_JANUARY, 1);
712 UDate jan1_2006 = getUTCMillis(2006, UCAL_JANUARY, 1);
713 UDate jan1_2007 = getUTCMillis(2007, UCAL_JANUARY, 1);
714 UDate jan1_2011 = getUTCMillis(2010, UCAL_JANUARY, 1);
715
716 if (newyork->hasEquivalentTransitions(*indianapolis, jan1_2005, jan1_2011, TRUE, status)) {
717 dataerrln("FAIL: New_York is not equivalent to Indianapolis between 2005 and 2010");
718 }
719 if (U_FAILURE(status)) {
720 errln("FAIL: error status is returned from hasEquivalentTransition");
721 }
722 if (!newyork->hasEquivalentTransitions(*indianapolis, jan1_2006, jan1_2011, TRUE, status)) {
723 errln("FAIL: New_York is equivalent to Indianapolis between 2006 and 2010");
724 }
725 if (U_FAILURE(status)) {
726 errln("FAIL: error status is returned from hasEquivalentTransition");
727 }
728
729 if (!indianapolis->hasEquivalentTransitions(*gmt_5, jan1_1971, jan1_2006, TRUE, status)) {
730 errln("FAIL: Indianapolis is equivalent to GMT+5 between 1971 and 2005");
731 }
732 if (U_FAILURE(status)) {
733 errln("FAIL: error status is returned from hasEquivalentTransition");
734 }
735 if (indianapolis->hasEquivalentTransitions(*gmt_5, jan1_1971, jan1_2007, TRUE, status)) {
736 dataerrln("FAIL: Indianapolis is not equivalent to GMT+5 between 1971 and 2006");
737 }
738 if (U_FAILURE(status)) {
739 errln("FAIL: error status is returned from hasEquivalentTransition");
740 }
741
742 // Cloned TimeZone
743 BasicTimeZone *newyork2 = (BasicTimeZone*)newyork->clone();
744 if (!newyork->hasEquivalentTransitions(*newyork2, jan1_1971, jan1_2011, FALSE, status)) {
745 errln("FAIL: Cloned TimeZone must have the same transitions");
746 }
747 if (U_FAILURE(status)) {
748 errln("FAIL: error status is returned from hasEquivalentTransition for newyork/newyork2");
749 }
750 if (!newyork->hasEquivalentTransitions(*newyork2, jan1_1971, jan1_2011, TRUE, status)) {
751 errln("FAIL: Cloned TimeZone must have the same transitions");
752 }
753 if (U_FAILURE(status)) {
754 errln("FAIL: error status is returned from hasEquivalentTransition for newyork/newyork2");
755 }
756
757 // America/New_York and America/Los_Angeles has same DST start rules, but
758 // raw offsets are different
759 BasicTimeZone *losangeles = (BasicTimeZone*)TimeZone::createTimeZone("America/Los_Angeles");
760 if (newyork->hasEquivalentTransitions(*losangeles, jan1_2006, jan1_2011, TRUE, status)) {
761 dataerrln("FAIL: New_York is not equivalent to Los Angeles, but returned true");
762 }
763 if (U_FAILURE(status)) {
764 errln("FAIL: error status is returned from hasEquivalentTransition for newyork/losangeles");
765 }
766
767 delete newyork;
768 delete newyork2;
769 delete indianapolis;
770 delete gmt_5;
771 delete losangeles;
772 }
773
774 /*
775 * Write out time zone rules of OlsonTimeZone into VTIMEZONE format, create a new
776 * VTimeZone from the VTIMEZONE data, then compare transitions
777 */
778 void
779 TimeZoneRuleTest::TestVTimeZoneRoundTrip(void) {
780 UDate startTime = getUTCMillis(1850, UCAL_JANUARY, 1);
781 UDate endTime = getUTCMillis(2050, UCAL_JANUARY, 1);
782
783 UErrorCode status = U_ZERO_ERROR;
784 TestZIDEnumeration tzenum(!quick);
785 while (TRUE) {
786 const UnicodeString *tzid = tzenum.snext(status);
787 if (tzid == NULL) {
788 break;
789 }
790 if (U_FAILURE(status)) {
791 errln("FAIL: error returned while enumerating timezone IDs.");
792 break;
793 }
794 BasicTimeZone *tz = (BasicTimeZone*)TimeZone::createTimeZone(*tzid);
795 VTimeZone *vtz_org = VTimeZone::createVTimeZoneByID(*tzid);
796 vtz_org->setTZURL("http://source.icu-project.org/timezone");
797 vtz_org->setLastModified(Calendar::getNow());
798 VTimeZone *vtz_new = NULL;
799 UnicodeString vtzdata;
800 // Write out VTIMEZONE data
801 vtz_org->write(vtzdata, status);
802 if (U_FAILURE(status)) {
803 errln((UnicodeString)"FAIL: error returned while writing time zone rules for " +
804 *tzid + " into VTIMEZONE format.");
805 } else {
806 // Read VTIMEZONE data
807 vtz_new = VTimeZone::createVTimeZone(vtzdata, status);
808 if (U_FAILURE(status)) {
809 errln((UnicodeString)"FAIL: error returned while reading VTIMEZONE data for " + *tzid);
810 } else {
811 // Write out VTIMEZONE one more time
812 UnicodeString vtzdata1;
813 vtz_new->write(vtzdata1, status);
814 if (U_FAILURE(status)) {
815 errln((UnicodeString)"FAIL: error returned while writing time zone rules for " +
816 *tzid + "(vtz_new) into VTIMEZONE format.");
817 } else {
818 // Make sure VTIMEZONE data is exactly same with the first one
819 if (vtzdata != vtzdata1) {
820 errln((UnicodeString)"FAIL: different VTIMEZONE data after round trip for " + *tzid);
821 }
822 }
823 // Check equivalency after the first transition.
824 // The DST information before the first transition might be lost
825 // because there is no good way to represent the initial time with
826 // VTIMEZONE.
827 int32_t raw1, raw2, dst1, dst2;
828 tz->getOffset(startTime, FALSE, raw1, dst1, status);
829 vtz_new->getOffset(startTime, FALSE, raw2, dst2, status);
830 if (U_FAILURE(status)) {
831 errln("FAIL: error status is returned from getOffset");
832 } else {
833 if (raw1 + dst1 != raw2 + dst2) {
834 errln("FAIL: VTimeZone for " + *tzid +
835 " is not equivalent to its OlsonTimeZone corresponding at "
836 + dateToString(startTime));
837 }
838 TimeZoneTransition trans;
839 UBool avail = tz->getNextTransition(startTime, FALSE, trans);
840 if (avail) {
841 if (!vtz_new->hasEquivalentTransitions(*tz, trans.getTime(),
842 endTime, TRUE, status)) {
843 int32_t maxDelta = 1000;
844 if (!hasEquivalentTransitions(*vtz_new, *tz, trans.getTime() + maxDelta,
845 endTime, TRUE, maxDelta, status)) {
846 errln("FAIL: VTimeZone for " + *tzid +
847 " is not equivalent to its OlsonTimeZone corresponding.");
848 } else {
849 logln("VTimeZone for " + *tzid +
850 " differs from its OlsonTimeZone corresponding with maximum transition time delta - " + maxDelta);
851 }
852 }
853 if (U_FAILURE(status)) {
854 errln("FAIL: error status is returned from hasEquivalentTransition");
855 }
856 }
857 }
858 }
859 if (vtz_new != NULL) {
860 delete vtz_new;
861 vtz_new = NULL;
862 }
863 }
864 delete tz;
865 delete vtz_org;
866 }
867 }
868
869 /*
870 * Write out time zone rules of OlsonTimeZone after a cutover date into VTIMEZONE format,
871 * create a new VTimeZone from the VTIMEZONE data, then compare transitions
872 */
873 void
874 TimeZoneRuleTest::TestVTimeZoneRoundTripPartial(void) {
875 const int32_t STARTYEARS[] = {
876 1900,
877 1950,
878 2020,
879 0
880 };
881 UDate endTime = getUTCMillis(2050, UCAL_JANUARY, 1);
882
883 UErrorCode status = U_ZERO_ERROR;
884 TestZIDEnumeration tzenum(!quick);
885 while (TRUE) {
886 const UnicodeString *tzid = tzenum.snext(status);
887 if (tzid == NULL) {
888 break;
889 }
890 if (U_FAILURE(status)) {
891 errln("FAIL: error returned while enumerating timezone IDs.");
892 break;
893 }
894 BasicTimeZone *tz = (BasicTimeZone*)TimeZone::createTimeZone(*tzid);
895 VTimeZone *vtz_org = VTimeZone::createVTimeZoneByID(*tzid);
896 VTimeZone *vtz_new = NULL;
897 UnicodeString vtzdata;
898
899 for (int32_t i = 0; STARTYEARS[i] != 0; i++) {
900 // Write out VTIMEZONE
901 UDate startTime = getUTCMillis(STARTYEARS[i], UCAL_JANUARY, 1);
902 vtz_org->write(startTime, vtzdata, status);
903 if (U_FAILURE(status)) {
904 errln((UnicodeString)"FAIL: error returned while writing time zone rules for " +
905 *tzid + " into VTIMEZONE format since " + dateToString(startTime));
906 } else {
907 // Read VTIMEZONE data
908 vtz_new = VTimeZone::createVTimeZone(vtzdata, status);
909 if (U_FAILURE(status)) {
910 errln((UnicodeString)"FAIL: error returned while reading VTIMEZONE data for " + *tzid
911 + " since " + dateToString(startTime));
912 } else {
913 // Check equivalency after the first transition.
914 // The DST information before the first transition might be lost
915 // because there is no good way to represent the initial time with
916 // VTIMEZONE.
917 int32_t raw1, raw2, dst1, dst2;
918 tz->getOffset(startTime, FALSE, raw1, dst1, status);
919 vtz_new->getOffset(startTime, FALSE, raw2, dst2, status);
920 if (U_FAILURE(status)) {
921 errln("FAIL: error status is returned from getOffset");
922 } else {
923 if (raw1 + dst1 != raw2 + dst2) {
924 errln("FAIL: VTimeZone for " + *tzid +
925 " is not equivalent to its OlsonTimeZone corresponding at "
926 + dateToString(startTime));
927 }
928 TimeZoneTransition trans;
929 UBool avail = tz->getNextTransition(startTime, FALSE, trans);
930 if (avail) {
931 if (!vtz_new->hasEquivalentTransitions(*tz, trans.getTime(),
932 endTime, TRUE, status)) {
933 int32_t maxDelta = 1000;
934 if (!hasEquivalentTransitions(*vtz_new, *tz, trans.getTime() + maxDelta,
935 endTime, TRUE, maxDelta, status)) {
936 errln("FAIL: VTimeZone for " + *tzid +
937 " is not equivalent to its OlsonTimeZone corresponding.");
938 } else {
939 logln("VTimeZone for " + *tzid +
940 " differs from its OlsonTimeZone corresponding with maximum transition time delta - " + maxDelta);
941 }
942
943 }
944 if (U_FAILURE(status)) {
945 errln("FAIL: error status is returned from hasEquivalentTransition");
946 }
947 }
948 }
949 }
950 }
951 if (vtz_new != NULL) {
952 delete vtz_new;
953 vtz_new = NULL;
954 }
955 }
956 delete tz;
957 delete vtz_org;
958 }
959 }
960
961 /*
962 * Write out simple time zone rules from an OlsonTimeZone at various time into VTIMEZONE
963 * format and create a new VTimeZone from the VTIMEZONE data, then make sure the raw offset
964 * and DST savings are same in these two time zones.
965 */
966 void
967 TimeZoneRuleTest::TestVTimeZoneSimpleWrite(void) {
968 const int32_t TESTDATES[][3] = {
969 {2006, UCAL_JANUARY, 1},
970 {2006, UCAL_MARCH, 15},
971 {2006, UCAL_MARCH, 31},
972 {2006, UCAL_OCTOBER, 25},
973 {2006, UCAL_NOVEMBER, 1},
974 {2006, UCAL_NOVEMBER, 5},
975 {2007, UCAL_JANUARY, 1},
976 {0, 0, 0}
977 };
978
979 UErrorCode status = U_ZERO_ERROR;
980 TestZIDEnumeration tzenum(!quick);
981 while (TRUE) {
982 const UnicodeString *tzid = tzenum.snext(status);
983 if (tzid == NULL) {
984 break;
985 }
986 if (U_FAILURE(status)) {
987 errln("FAIL: error returned while enumerating timezone IDs.");
988 break;
989 }
990 VTimeZone *vtz_org = VTimeZone::createVTimeZoneByID(*tzid);
991 VTimeZone *vtz_new = NULL;
992 UnicodeString vtzdata;
993
994 for (int32_t i = 0; TESTDATES[i][0] != 0; i++) {
995 // Write out VTIMEZONE
996 UDate time = getUTCMillis(TESTDATES[i][0], TESTDATES[i][1], TESTDATES[i][2]);
997 vtz_org->writeSimple(time, vtzdata, status);
998 if (U_FAILURE(status)) {
999 errln((UnicodeString)"FAIL: error returned while writing simple time zone rules for " +
1000 *tzid + " into VTIMEZONE format at " + dateToString(time));
1001 } else {
1002 // Read VTIMEZONE data
1003 vtz_new = VTimeZone::createVTimeZone(vtzdata, status);
1004 if (U_FAILURE(status)) {
1005 errln((UnicodeString)"FAIL: error returned while reading simple VTIMEZONE data for " + *tzid
1006 + " at " + dateToString(time));
1007 } else {
1008 // Check equivalency
1009 int32_t raw0, dst0;
1010 int32_t raw1, dst1;
1011 vtz_org->getOffset(time, FALSE, raw0, dst0, status);
1012 vtz_new->getOffset(time, FALSE, raw1, dst1, status);
1013 if (U_SUCCESS(status)) {
1014 if (raw0 != raw1 || dst0 != dst1) {
1015 errln("FAIL: VTimeZone writeSimple for " + *tzid + " at "
1016 + dateToString(time) + " failed to the round trip.");
1017 }
1018 } else {
1019 errln("FAIL: getOffset returns error status");
1020 }
1021 }
1022 }
1023 if (vtz_new != NULL) {
1024 delete vtz_new;
1025 vtz_new = NULL;
1026 }
1027 }
1028 delete vtz_org;
1029 }
1030 }
1031
1032 /*
1033 * Write out time zone rules of OlsonTimeZone into VTIMEZONE format with RFC2445 header TZURL and
1034 * LAST-MODIFIED, create a new VTimeZone from the VTIMEZONE data to see if the headers are preserved.
1035 */
1036 void
1037 TimeZoneRuleTest::TestVTimeZoneHeaderProps(void) {
1038 const UnicodeString TESTURL1("http://source.icu-project.org");
1039 const UnicodeString TESTURL2("http://www.ibm.com");
1040
1041 UErrorCode status = U_ZERO_ERROR;
1042 UnicodeString tzurl;
1043 UDate lmod;
1044 UDate lastmod = getUTCMillis(2007, UCAL_JUNE, 1);
1045 VTimeZone *vtz = VTimeZone::createVTimeZoneByID("America/Chicago");
1046 vtz->setTZURL(TESTURL1);
1047 vtz->setLastModified(lastmod);
1048
1049 // Roundtrip conversion
1050 UnicodeString vtzdata;
1051 vtz->write(vtzdata, status);
1052 VTimeZone *newvtz1 = NULL;
1053 if (U_FAILURE(status)) {
1054 errln("FAIL: error returned while writing VTIMEZONE data 1");
1055 return;
1056 }
1057 // Create a new one
1058 newvtz1 = VTimeZone::createVTimeZone(vtzdata, status);
1059 if (U_FAILURE(status)) {
1060 errln("FAIL: error returned while loading VTIMEZONE data 1");
1061 } else {
1062 // Check if TZURL and LAST-MODIFIED properties are preserved
1063 newvtz1->getTZURL(tzurl);
1064 if (tzurl != TESTURL1) {
1065 errln("FAIL: TZURL 1 was not preserved");
1066 }
1067 vtz->getLastModified(lmod);
1068 if (lastmod != lmod) {
1069 errln("FAIL: LAST-MODIFIED was not preserved");
1070 }
1071 }
1072
1073 if (U_SUCCESS(status)) {
1074 // Set different tzurl
1075 newvtz1->setTZURL(TESTURL2);
1076
1077 // Second roundtrip, with a cutover
1078 newvtz1->write(vtzdata, status);
1079 if (U_FAILURE(status)) {
1080 errln("FAIL: error returned while writing VTIMEZONE data 2");
1081 } else {
1082 VTimeZone *newvtz2 = VTimeZone::createVTimeZone(vtzdata, status);
1083 if (U_FAILURE(status)) {
1084 errln("FAIL: error returned while loading VTIMEZONE data 2");
1085 } else {
1086 // Check if TZURL and LAST-MODIFIED properties are preserved
1087 newvtz2->getTZURL(tzurl);
1088 if (tzurl != TESTURL2) {
1089 errln("FAIL: TZURL was not preserved in the second roundtrip");
1090 }
1091 vtz->getLastModified(lmod);
1092 if (lastmod != lmod) {
1093 errln("FAIL: LAST-MODIFIED was not preserved in the second roundtrip");
1094 }
1095 }
1096 delete newvtz2;
1097 }
1098 }
1099 delete newvtz1;
1100 delete vtz;
1101 }
1102
1103 /*
1104 * Extract simple rules from an OlsonTimeZone and make sure the rule format matches
1105 * the expected format.
1106 */
1107 void
1108 TimeZoneRuleTest::TestGetSimpleRules(void) {
1109 UDate testTimes[] = {
1110 getUTCMillis(1970, UCAL_JANUARY, 1),
1111 getUTCMillis(2000, UCAL_MARCH, 31),
1112 getUTCMillis(2005, UCAL_JULY, 1),
1113 getUTCMillis(2010, UCAL_NOVEMBER, 1),
1114 };
1115 int32_t numTimes = sizeof(testTimes)/sizeof(UDate);
1116 UErrorCode status = U_ZERO_ERROR;
1117 TestZIDEnumeration tzenum(!quick);
1118 InitialTimeZoneRule *initial;
1119 AnnualTimeZoneRule *std, *dst;
1120 for (int32_t i = 0; i < numTimes ; i++) {
1121 while (TRUE) {
1122 const UnicodeString *tzid = tzenum.snext(status);
1123 if (tzid == NULL) {
1124 break;
1125 }
1126 if (U_FAILURE(status)) {
1127 errln("FAIL: error returned while enumerating timezone IDs.");
1128 break;
1129 }
1130 BasicTimeZone *tz = (BasicTimeZone*)TimeZone::createTimeZone(*tzid);
1131 initial = NULL;
1132 std = dst = NULL;
1133 tz->getSimpleRulesNear(testTimes[i], initial, std, dst, status);
1134 if (U_FAILURE(status)) {
1135 errln("FAIL: getSimpleRules failed.");
1136 break;
1137 }
1138 if (initial == NULL) {
1139 errln("FAIL: initial rule must not be NULL");
1140 break;
1141 } else if (!((std == NULL && dst == NULL) || (std != NULL && dst != NULL))) {
1142 errln("FAIL: invalid std/dst pair.");
1143 break;
1144 }
1145 if (std != NULL) {
1146 const DateTimeRule *dtr = std->getRule();
1147 if (dtr->getDateRuleType() != DateTimeRule::DOW) {
1148 errln("FAIL: simple std rull must use DateTimeRule::DOW as date rule.");
1149 break;
1150 }
1151 if (dtr->getTimeRuleType() != DateTimeRule::WALL_TIME) {
1152 errln("FAIL: simple std rull must use DateTimeRule::WALL_TIME as time rule.");
1153 break;
1154 }
1155 dtr = dst->getRule();
1156 if (dtr->getDateRuleType() != DateTimeRule::DOW) {
1157 errln("FAIL: simple dst rull must use DateTimeRule::DOW as date rule.");
1158 break;
1159 }
1160 if (dtr->getTimeRuleType() != DateTimeRule::WALL_TIME) {
1161 errln("FAIL: simple dst rull must use DateTimeRule::WALL_TIME as time rule.");
1162 break;
1163 }
1164 }
1165 // Create an RBTZ from the rules and compare the offsets at the date
1166 RuleBasedTimeZone *rbtz = new RuleBasedTimeZone(*tzid, initial);
1167 if (std != NULL) {
1168 rbtz->addTransitionRule(std, status);
1169 if (U_FAILURE(status)) {
1170 errln("FAIL: couldn't add std rule.");
1171 }
1172 rbtz->addTransitionRule(dst, status);
1173 if (U_FAILURE(status)) {
1174 errln("FAIL: couldn't add dst rule.");
1175 }
1176 }
1177 rbtz->complete(status);
1178 if (U_FAILURE(status)) {
1179 errln("FAIL: couldn't complete rbtz for " + *tzid);
1180 }
1181
1182 int32_t raw0, dst0, raw1, dst1;
1183 tz->getOffset(testTimes[i], FALSE, raw0, dst0, status);
1184 if (U_FAILURE(status)) {
1185 errln("FAIL: couldn't get offsets from tz for " + *tzid);
1186 }
1187 rbtz->getOffset(testTimes[i], FALSE, raw1, dst1, status);
1188 if (U_FAILURE(status)) {
1189 errln("FAIL: couldn't get offsets from rbtz for " + *tzid);
1190 }
1191 if (raw0 != raw1 || dst0 != dst1) {
1192 errln("FAIL: rbtz created by simple rule does not match the original tz for tzid " + *tzid);
1193 }
1194 delete rbtz;
1195 delete tz;
1196 }
1197 }
1198 }
1199
1200 /*
1201 * API coverage tests for TimeZoneRule
1202 */
1203 void
1204 TimeZoneRuleTest::TestTimeZoneRuleCoverage(void) {
1205 UDate time1 = getUTCMillis(2005, UCAL_JULY, 4);
1206 UDate time2 = getUTCMillis(2015, UCAL_JULY, 4);
1207 UDate time3 = getUTCMillis(1950, UCAL_JULY, 4);
1208
1209 DateTimeRule *dtr1 = new DateTimeRule(UCAL_FEBRUARY, 29, UCAL_SUNDAY, FALSE,
1210 3*HOUR, DateTimeRule::WALL_TIME); // Last Sunday on or before Feb 29, at 3 AM, wall time
1211 DateTimeRule *dtr2 = new DateTimeRule(UCAL_MARCH, 11, 2*HOUR,
1212 DateTimeRule::STANDARD_TIME); // Mar 11, at 2 AM, standard time
1213 DateTimeRule *dtr3 = new DateTimeRule(UCAL_OCTOBER, -1, UCAL_SATURDAY,
1214 6*HOUR, DateTimeRule::UTC_TIME); //Last Saturday in Oct, at 6 AM, UTC
1215 DateTimeRule *dtr4 = new DateTimeRule(UCAL_MARCH, 8, UCAL_SUNDAY, TRUE,
1216 2*HOUR, DateTimeRule::WALL_TIME); // First Sunday on or after Mar 8, at 2 AM, wall time
1217
1218 AnnualTimeZoneRule *a1 = new AnnualTimeZoneRule("a1", -3*HOUR, 1*HOUR, *dtr1,
1219 2000, AnnualTimeZoneRule::MAX_YEAR);
1220 AnnualTimeZoneRule *a2 = new AnnualTimeZoneRule("a2", -3*HOUR, 1*HOUR, *dtr1,
1221 2000, AnnualTimeZoneRule::MAX_YEAR);
1222 AnnualTimeZoneRule *a3 = new AnnualTimeZoneRule("a3", -3*HOUR, 1*HOUR, *dtr1,
1223 2000, 2010);
1224
1225 InitialTimeZoneRule *i1 = new InitialTimeZoneRule("i1", -3*HOUR, 0);
1226 InitialTimeZoneRule *i2 = new InitialTimeZoneRule("i2", -3*HOUR, 0);
1227 InitialTimeZoneRule *i3 = new InitialTimeZoneRule("i3", -3*HOUR, 1*HOUR);
1228
1229 UDate trtimes1[] = {0.0};
1230 UDate trtimes2[] = {0.0, 10000000.0};
1231
1232 TimeArrayTimeZoneRule *t1 = new TimeArrayTimeZoneRule("t1", -3*HOUR, 0, trtimes1, 1, DateTimeRule::UTC_TIME);
1233 TimeArrayTimeZoneRule *t2 = new TimeArrayTimeZoneRule("t2", -3*HOUR, 0, trtimes1, 1, DateTimeRule::UTC_TIME);
1234 TimeArrayTimeZoneRule *t3 = new TimeArrayTimeZoneRule("t3", -3*HOUR, 0, trtimes2, 2, DateTimeRule::UTC_TIME);
1235 TimeArrayTimeZoneRule *t4 = new TimeArrayTimeZoneRule("t4", -3*HOUR, 0, trtimes1, 1, DateTimeRule::STANDARD_TIME);
1236 TimeArrayTimeZoneRule *t5 = new TimeArrayTimeZoneRule("t5", -4*HOUR, 1*HOUR, trtimes1, 1, DateTimeRule::WALL_TIME);
1237
1238 // DateTimeRule::operator=/clone
1239 DateTimeRule dtr0(UCAL_MAY, 31, 2*HOUR, DateTimeRule::WALL_TIME);
1240 if (dtr0 == *dtr1 || !(dtr0 != *dtr1)) {
1241 errln("FAIL: DateTimeRule dtr0 is not equal to dtr1, but got wrong result");
1242 }
1243 dtr0 = *dtr1;
1244 if (dtr0 != *dtr1 || !(dtr0 == *dtr1)) {
1245 errln("FAIL: DateTimeRule dtr0 is equal to dtr1, but got wrong result");
1246 }
1247 DateTimeRule *dtr0c = dtr0.clone();
1248 if (*dtr0c != *dtr1 || !(*dtr0c == *dtr1)) {
1249 errln("FAIL: DateTimeRule dtr0c is equal to dtr1, but got wrong result");
1250 }
1251 delete dtr0c;
1252
1253 // AnnualTimeZonerule::operator=/clone
1254 AnnualTimeZoneRule a0("a0", 5*HOUR, 1*HOUR, *dtr1, 1990, AnnualTimeZoneRule::MAX_YEAR);
1255 if (a0 == *a1 || !(a0 != *a1)) {
1256 errln("FAIL: AnnualTimeZoneRule a0 is not equal to a1, but got wrong result");
1257 }
1258 a0 = *a1;
1259 if (a0 != *a1 || !(a0 == *a1)) {
1260 errln("FAIL: AnnualTimeZoneRule a0 is equal to a1, but got wrong result");
1261 }
1262 AnnualTimeZoneRule *a0c = a0.clone();
1263 if (*a0c != *a1 || !(*a0c == *a1)) {
1264 errln("FAIL: AnnualTimeZoneRule a0c is equal to a1, but got wrong result");
1265 }
1266 delete a0c;
1267
1268 // AnnualTimeZoneRule::getRule
1269 if (*(a1->getRule()) != *(a2->getRule())) {
1270 errln("FAIL: The same DateTimeRule must be returned from AnnualTimeZoneRule a1 and a2");
1271 }
1272
1273 // AnnualTimeZoneRule::getStartYear
1274 int32_t startYear = a1->getStartYear();
1275 if (startYear != 2000) {
1276 errln((UnicodeString)"FAIL: The start year of AnnualTimeZoneRule a1 must be 2000 - returned: " + startYear);
1277 }
1278
1279 // AnnualTimeZoneRule::getEndYear
1280 int32_t endYear = a1->getEndYear();
1281 if (endYear != AnnualTimeZoneRule::MAX_YEAR) {
1282 errln((UnicodeString)"FAIL: The start year of AnnualTimeZoneRule a1 must be MAX_YEAR - returned: " + endYear);
1283 }
1284 endYear = a3->getEndYear();
1285 if (endYear != 2010) {
1286 errln((UnicodeString)"FAIL: The start year of AnnualTimeZoneRule a3 must be 2010 - returned: " + endYear);
1287 }
1288
1289 // AnnualTimeZone::getStartInYear
1290 UBool b1, b2;
1291 UDate d1, d2;
1292 b1 = a1->getStartInYear(2005, -3*HOUR, 0, d1);
1293 b2 = a3->getStartInYear(2005, -3*HOUR, 0, d2);
1294 if (!b1 || !b2 || d1 != d2) {
1295 errln("FAIL: AnnualTimeZoneRule::getStartInYear did not work as expected");
1296 }
1297 b2 = a3->getStartInYear(2015, -3*HOUR, 0, d2);
1298 if (b2) {
1299 errln("FAIL: AnnualTimeZoneRule::getStartInYear returned TRUE for 2015 which is out of rule range");
1300 }
1301
1302 // AnnualTimeZone::getFirstStart
1303 b1 = a1->getFirstStart(-3*HOUR, 0, d1);
1304 b2 = a1->getFirstStart(-4*HOUR, 1*HOUR, d2);
1305 if (!b1 || !b2 || d1 != d2) {
1306 errln("FAIL: The same start time should be returned by getFirstStart");
1307 }
1308
1309 // AnnualTimeZone::getFinalStart
1310 b1 = a1->getFinalStart(-3*HOUR, 0, d1);
1311 if (b1) {
1312 errln("FAIL: getFinalStart returned TRUE for a1");
1313 }
1314 b1 = a1->getStartInYear(2010, -3*HOUR, 0, d1);
1315 b2 = a3->getFinalStart(-3*HOUR, 0, d2);
1316 if (!b1 || !b2 || d1 != d2) {
1317 errln("FAIL: Bad date is returned by getFinalStart");
1318 }
1319
1320 // AnnualTimeZone::getNextStart / getPreviousStart
1321 b1 = a1->getNextStart(time1, -3*HOUR, 0, FALSE, d1);
1322 if (!b1) {
1323 errln("FAIL: getNextStart returned FALSE for ai");
1324 } else {
1325 b2 = a1->getPreviousStart(d1, -3*HOUR, 0, TRUE, d2);
1326 if (!b2 || d1 != d2) {
1327 errln("FAIL: Bad Date is returned by getPreviousStart");
1328 }
1329 }
1330 b1 = a3->getNextStart(time2, -3*HOUR, 0, FALSE, d1);
1331 if (b1) {
1332 dataerrln("FAIL: getNextStart must return FALSE when no start time is available after the base time");
1333 }
1334 b1 = a3->getFinalStart(-3*HOUR, 0, d1);
1335 b2 = a3->getPreviousStart(time2, -3*HOUR, 0, FALSE, d2);
1336 if (!b1 || !b2 || d1 != d2) {
1337 dataerrln("FAIL: getPreviousStart does not match with getFinalStart after the end year");
1338 }
1339
1340 // AnnualTimeZone::isEquavalentTo
1341 if (!a1->isEquivalentTo(*a2)) {
1342 errln("FAIL: AnnualTimeZoneRule a1 is equivalent to a2, but returned FALSE");
1343 }
1344 if (a1->isEquivalentTo(*a3)) {
1345 errln("FAIL: AnnualTimeZoneRule a1 is not equivalent to a3, but returned TRUE");
1346 }
1347 if (!a1->isEquivalentTo(*a1)) {
1348 errln("FAIL: AnnualTimeZoneRule a1 is equivalent to itself, but returned FALSE");
1349 }
1350 if (a1->isEquivalentTo(*t1)) {
1351 errln("FAIL: AnnualTimeZoneRule is not equivalent to TimeArrayTimeZoneRule, but returned TRUE");
1352 }
1353
1354 // InitialTimezoneRule::operator=/clone
1355 InitialTimeZoneRule i0("i0", 10*HOUR, 0);
1356 if (i0 == *i1 || !(i0 != *i1)) {
1357 errln("FAIL: InitialTimeZoneRule i0 is not equal to i1, but got wrong result");
1358 }
1359 i0 = *i1;
1360 if (i0 != *i1 || !(i0 == *i1)) {
1361 errln("FAIL: InitialTimeZoneRule i0 is equal to i1, but got wrong result");
1362 }
1363 InitialTimeZoneRule *i0c = i0.clone();
1364 if (*i0c != *i1 || !(*i0c == *i1)) {
1365 errln("FAIL: InitialTimeZoneRule i0c is equal to i1, but got wrong result");
1366 }
1367 delete i0c;
1368
1369 // InitialTimeZoneRule::isEquivalentRule
1370 if (!i1->isEquivalentTo(*i2)) {
1371 errln("FAIL: InitialTimeZoneRule i1 is equivalent to i2, but returned FALSE");
1372 }
1373 if (i1->isEquivalentTo(*i3)) {
1374 errln("FAIL: InitialTimeZoneRule i1 is not equivalent to i3, but returned TRUE");
1375 }
1376 if (i1->isEquivalentTo(*a1)) {
1377 errln("FAIL: An InitialTimeZoneRule is not equivalent to an AnnualTimeZoneRule, but returned TRUE");
1378 }
1379
1380 // InitialTimeZoneRule::getFirstStart/getFinalStart/getNextStart/getPreviousStart
1381 b1 = i1->getFirstStart(0, 0, d1);
1382 if (b1) {
1383 errln("FAIL: InitialTimeZone::getFirstStart returned TRUE");
1384 }
1385 b1 = i1->getFinalStart(0, 0, d1);
1386 if (b1) {
1387 errln("FAIL: InitialTimeZone::getFinalStart returned TRUE");
1388 }
1389 b1 = i1->getNextStart(time1, 0, 0, FALSE, d1);
1390 if (b1) {
1391 errln("FAIL: InitialTimeZone::getNextStart returned TRUE");
1392 }
1393 b1 = i1->getPreviousStart(time1, 0, 0, FALSE, d1);
1394 if (b1) {
1395 errln("FAIL: InitialTimeZone::getPreviousStart returned TRUE");
1396 }
1397
1398 // TimeArrayTimeZoneRule::operator=/clone
1399 TimeArrayTimeZoneRule t0("t0", 4*HOUR, 0, trtimes1, 1, DateTimeRule::UTC_TIME);
1400 if (t0 == *t1 || !(t0 != *t1)) {
1401 errln("FAIL: TimeArrayTimeZoneRule t0 is not equal to t1, but got wrong result");
1402 }
1403 t0 = *t1;
1404 if (t0 != *t1 || !(t0 == *t1)) {
1405 errln("FAIL: TimeArrayTimeZoneRule t0 is equal to t1, but got wrong result");
1406 }
1407 TimeArrayTimeZoneRule *t0c = t0.clone();
1408 if (*t0c != *t1 || !(*t0c == *t1)) {
1409 errln("FAIL: TimeArrayTimeZoneRule t0c is equal to t1, but got wrong result");
1410 }
1411 delete t0c;
1412
1413 // TimeArrayTimeZoneRule::countStartTimes
1414 if (t1->countStartTimes() != 1) {
1415 errln("FAIL: Bad start time count is returned by TimeArrayTimeZoneRule::countStartTimes");
1416 }
1417
1418 // TimeArrayTimeZoneRule::getStartTimeAt
1419 b1 = t1->getStartTimeAt(-1, d1);
1420 if (b1) {
1421 errln("FAIL: TimeArrayTimeZoneRule::getStartTimeAt returned TRUE for index -1");
1422 }
1423 b1 = t1->getStartTimeAt(0, d1);
1424 if (!b1 || d1 != trtimes1[0]) {
1425 errln("FAIL: TimeArrayTimeZoneRule::getStartTimeAt returned incorrect result for index 0");
1426 }
1427 b1 = t1->getStartTimeAt(1, d1);
1428 if (b1) {
1429 errln("FAIL: TimeArrayTimeZoneRule::getStartTimeAt returned TRUE for index 1");
1430 }
1431
1432 // TimeArrayTimeZoneRule::getTimeType
1433 if (t1->getTimeType() != DateTimeRule::UTC_TIME) {
1434 errln("FAIL: TimeArrayTimeZoneRule t1 uses UTC_TIME, but different type is returned");
1435 }
1436 if (t4->getTimeType() != DateTimeRule::STANDARD_TIME) {
1437 errln("FAIL: TimeArrayTimeZoneRule t4 uses STANDARD_TIME, but different type is returned");
1438 }
1439 if (t5->getTimeType() != DateTimeRule::WALL_TIME) {
1440 errln("FAIL: TimeArrayTimeZoneRule t5 uses WALL_TIME, but different type is returned");
1441 }
1442
1443 // TimeArrayTimeZoneRule::getFirstStart/getFinalStart
1444 b1 = t1->getFirstStart(0, 0, d1);
1445 if (!b1 || d1 != trtimes1[0]) {
1446 errln("FAIL: Bad first start time returned from TimeArrayTimeZoneRule t1");
1447 }
1448 b1 = t1->getFinalStart(0, 0, d1);
1449 if (!b1 || d1 != trtimes1[0]) {
1450 errln("FAIL: Bad final start time returned from TimeArrayTimeZoneRule t1");
1451 }
1452 b1 = t4->getFirstStart(-4*HOUR, 1*HOUR, d1);
1453 if (!b1 || d1 != (trtimes1[0] + 4*HOUR)) {
1454 errln("FAIL: Bad first start time returned from TimeArrayTimeZoneRule t4");
1455 }
1456 b1 = t5->getFirstStart(-4*HOUR, 1*HOUR, d1);
1457 if (!b1 || d1 != (trtimes1[0] + 3*HOUR)) {
1458 errln("FAIL: Bad first start time returned from TimeArrayTimeZoneRule t5");
1459 }
1460
1461 // TimeArrayTimeZoneRule::getNextStart/getPreviousStart
1462 b1 = t3->getNextStart(time1, -3*HOUR, 1*HOUR, FALSE, d1);
1463 if (b1) {
1464 dataerrln("FAIL: getNextStart returned TRUE after the final transition for t3");
1465 }
1466 b1 = t3->getPreviousStart(time1, -3*HOUR, 1*HOUR, FALSE, d1);
1467 if (!b1 || d1 != trtimes2[1]) {
1468 dataerrln("FAIL: Bad start time returned by getPreviousStart for t3");
1469 } else {
1470 b2 = t3->getPreviousStart(d1, -3*HOUR, 1*HOUR, FALSE, d2);
1471 if (!b2 || d2 != trtimes2[0]) {
1472 errln("FAIL: Bad start time returned by getPreviousStart for t3");
1473 }
1474 }
1475 b1 = t3->getPreviousStart(time3, -3*HOUR, 1*HOUR, FALSE, d1); //time3 - year 1950, no result expected
1476 if (b1) {
1477 errln("FAIL: getPreviousStart returned TRUE before the first transition for t3");
1478 }
1479
1480 // TimeArrayTimeZoneRule::isEquivalentTo
1481 if (!t1->isEquivalentTo(*t2)) {
1482 errln("FAIL: TimeArrayTimeZoneRule t1 is equivalent to t2, but returned FALSE");
1483 }
1484 if (t1->isEquivalentTo(*t3)) {
1485 errln("FAIL: TimeArrayTimeZoneRule t1 is not equivalent to t3, but returned TRUE");
1486 }
1487 if (t1->isEquivalentTo(*t4)) {
1488 errln("FAIL: TimeArrayTimeZoneRule t1 is not equivalent to t4, but returned TRUE");
1489 }
1490 if (t1->isEquivalentTo(*a1)) {
1491 errln("FAIL: TimeArrayTimeZoneRule is not equivalent to AnnualTimeZoneRule, but returned TRUE");
1492 }
1493
1494 delete dtr1;
1495 delete dtr2;
1496 delete dtr3;
1497 delete dtr4;
1498 delete a1;
1499 delete a2;
1500 delete a3;
1501 delete i1;
1502 delete i2;
1503 delete i3;
1504 delete t1;
1505 delete t2;
1506 delete t3;
1507 delete t4;
1508 delete t5;
1509 }
1510
1511 /*
1512 * API coverage test for BasicTimeZone APIs in SimpleTimeZone
1513 */
1514 void
1515 TimeZoneRuleTest::TestSimpleTimeZoneCoverage(void) {
1516 UDate time1 = getUTCMillis(1990, UCAL_JUNE, 1);
1517 UDate time2 = getUTCMillis(2000, UCAL_JUNE, 1);
1518
1519 TimeZoneTransition tzt1, tzt2;
1520 UBool avail1, avail2;
1521 UErrorCode status = U_ZERO_ERROR;
1522 const TimeZoneRule *trrules[2];
1523 const InitialTimeZoneRule *ir = NULL;
1524 int32_t numTzRules;
1525
1526 // BasicTimeZone API implementation in SimpleTimeZone
1527 SimpleTimeZone *stz1 = new SimpleTimeZone(-5*HOUR, "GMT-5");
1528
1529 avail1 = stz1->getNextTransition(time1, FALSE, tzt1);
1530 if (avail1) {
1531 errln("FAIL: No transition must be returned by getNextTranstion for SimpleTimeZone with no DST rule");
1532 }
1533 avail1 = stz1->getPreviousTransition(time1, FALSE, tzt1);
1534 if (avail1) {
1535 errln("FAIL: No transition must be returned by getPreviousTransition for SimpleTimeZone with no DST rule");
1536 }
1537
1538 numTzRules = stz1->countTransitionRules(status);
1539 if (U_FAILURE(status)) {
1540 errln("FAIL: countTransitionRules failed");
1541 }
1542 if (numTzRules != 0) {
1543 errln((UnicodeString)"FAIL: countTransitionRules returned " + numTzRules);
1544 }
1545 numTzRules = 2;
1546 stz1->getTimeZoneRules(ir, trrules, numTzRules, status);
1547 if (U_FAILURE(status)) {
1548 errln("FAIL: getTimeZoneRules failed");
1549 }
1550 if (numTzRules != 0) {
1551 errln("FAIL: Incorrect transition rule count");
1552 }
1553 if (ir == NULL || ir->getRawOffset() != stz1->getRawOffset()) {
1554 errln("FAIL: Bad initial time zone rule");
1555 }
1556
1557 // Set DST rule
1558 stz1->setStartRule(UCAL_MARCH, 11, 2*HOUR, status); // March 11
1559 stz1->setEndRule(UCAL_NOVEMBER, 1, UCAL_SUNDAY, 2*HOUR, status); // First Sunday in November
1560 if (U_FAILURE(status)) {
1561 errln("FAIL: Failed to set DST rules in a SimpleTimeZone");
1562 }
1563
1564 avail1 = stz1->getNextTransition(time1, FALSE, tzt1);
1565 if (!avail1) {
1566 errln("FAIL: Non-null transition must be returned by getNextTranstion for SimpleTimeZone with a DST rule");
1567 }
1568 avail1 = stz1->getPreviousTransition(time1, FALSE, tzt1);
1569 if (!avail1) {
1570 errln("FAIL: Non-null transition must be returned by getPreviousTransition for SimpleTimeZone with a DST rule");
1571 }
1572
1573 numTzRules = stz1->countTransitionRules(status);
1574 if (U_FAILURE(status)) {
1575 errln("FAIL: countTransitionRules failed");
1576 }
1577 if (numTzRules != 2) {
1578 errln((UnicodeString)"FAIL: countTransitionRules returned " + numTzRules);
1579 }
1580
1581 numTzRules = 2;
1582 trrules[0] = NULL;
1583 trrules[1] = NULL;
1584 stz1->getTimeZoneRules(ir, trrules, numTzRules, status);
1585 if (U_FAILURE(status)) {
1586 errln("FAIL: getTimeZoneRules failed");
1587 }
1588 if (numTzRules != 2) {
1589 errln("FAIL: Incorrect transition rule count");
1590 }
1591 if (ir == NULL || ir->getRawOffset() != stz1->getRawOffset()) {
1592 errln("FAIL: Bad initial time zone rule");
1593 }
1594 if (trrules[0] == NULL || trrules[0]->getRawOffset() != stz1->getRawOffset()) {
1595 errln("FAIL: Bad transition rule 0");
1596 }
1597 if (trrules[1] == NULL || trrules[1]->getRawOffset() != stz1->getRawOffset()) {
1598 errln("FAIL: Bad transition rule 1");
1599 }
1600
1601 // Set DST start year
1602 stz1->setStartYear(2007);
1603 avail1 = stz1->getPreviousTransition(time1, FALSE, tzt1);
1604 if (avail1) {
1605 errln("FAIL: No transition must be returned before 1990");
1606 }
1607 avail1 = stz1->getNextTransition(time1, FALSE, tzt1); // transition after 1990-06-01
1608 avail2 = stz1->getNextTransition(time2, FALSE, tzt2); // transition after 2000-06-01
1609 if (!avail1 || !avail2 || tzt1 != tzt2) {
1610 errln("FAIL: Bad transition returned by SimpleTimeZone::getNextTransition");
1611 }
1612 delete stz1;
1613 }
1614
1615 /*
1616 * API coverage test for VTimeZone
1617 */
1618 void
1619 TimeZoneRuleTest::TestVTimeZoneCoverage(void) {
1620 UErrorCode status = U_ZERO_ERROR;
1621 UnicodeString TZID("Europe/Moscow");
1622
1623 BasicTimeZone *otz = (BasicTimeZone*)TimeZone::createTimeZone(TZID);
1624 VTimeZone *vtz = VTimeZone::createVTimeZoneByID(TZID);
1625
1626 // getOffset(era, year, month, day, dayOfWeek, milliseconds, ec)
1627 int32_t offset1 = otz->getOffset(GregorianCalendar::AD, 2007, UCAL_JULY, 1, UCAL_SUNDAY, 0, status);
1628 if (U_FAILURE(status)) {
1629 errln("FAIL: getOffset(7 args) failed for otz");
1630 }
1631 int32_t offset2 = vtz->getOffset(GregorianCalendar::AD, 2007, UCAL_JULY, 1, UCAL_SUNDAY, 0, status);
1632 if (U_FAILURE(status)) {
1633 errln("FAIL: getOffset(7 args) failed for vtz");
1634 }
1635 if (offset1 != offset2) {
1636 errln("FAIL: getOffset(7 args) returned different results in VTimeZone and OlsonTimeZone");
1637 }
1638
1639 // getOffset(era, year, month, day, dayOfWeek, milliseconds, monthLength, ec)
1640 offset1 = otz->getOffset(GregorianCalendar::AD, 2007, UCAL_JULY, 1, UCAL_SUNDAY, 0, 31, status);
1641 if (U_FAILURE(status)) {
1642 errln("FAIL: getOffset(8 args) failed for otz");
1643 }
1644 offset2 = vtz->getOffset(GregorianCalendar::AD, 2007, UCAL_JULY, 1, UCAL_SUNDAY, 0, 31, status);
1645 if (U_FAILURE(status)) {
1646 errln("FAIL: getOffset(8 args) failed for vtz");
1647 }
1648 if (offset1 != offset2) {
1649 errln("FAIL: getOffset(8 args) returned different results in VTimeZone and OlsonTimeZone");
1650 }
1651
1652
1653 // getOffset(date, local, rawOffset, dstOffset, ec)
1654 UDate t = Calendar::getNow();
1655 int32_t rawOffset1, dstSavings1;
1656 int32_t rawOffset2, dstSavings2;
1657
1658 otz->getOffset(t, FALSE, rawOffset1, dstSavings1, status);
1659 if (U_FAILURE(status)) {
1660 errln("FAIL: getOffset(5 args) failed for otz");
1661 }
1662 vtz->getOffset(t, FALSE, rawOffset2, dstSavings2, status);
1663 if (U_FAILURE(status)) {
1664 errln("FAIL: getOffset(5 args) failed for vtz");
1665 }
1666 if (rawOffset1 != rawOffset2 || dstSavings1 != dstSavings2) {
1667 errln("FAIL: getOffset(long,boolean,int[]) returned different results in VTimeZone and OlsonTimeZone");
1668 }
1669
1670 // getRawOffset
1671 if (otz->getRawOffset() != vtz->getRawOffset()) {
1672 errln("FAIL: getRawOffset returned different results in VTimeZone and OlsonTimeZone");
1673 }
1674
1675 // inDaylightTime
1676 UBool inDst1, inDst2;
1677 inDst1 = otz->inDaylightTime(t, status);
1678 if (U_FAILURE(status)) {
1679 dataerrln("FAIL: inDaylightTime failed for otz: %s", u_errorName(status));
1680 }
1681 inDst2 = vtz->inDaylightTime(t, status);
1682 if (U_FAILURE(status)) {
1683 dataerrln("FAIL: inDaylightTime failed for vtz: %s", u_errorName(status));
1684 }
1685 if (inDst1 != inDst2) {
1686 errln("FAIL: inDaylightTime returned different results in VTimeZone and OlsonTimeZone");
1687 }
1688
1689 // useDaylightTime
1690 if (otz->useDaylightTime() != vtz->useDaylightTime()) {
1691 errln("FAIL: useDaylightTime returned different results in VTimeZone and OlsonTimeZone");
1692 }
1693
1694 // setRawOffset
1695 const int32_t RAW = -10*HOUR;
1696 VTimeZone *tmpvtz = (VTimeZone*)vtz->clone();
1697 tmpvtz->setRawOffset(RAW);
1698 if (tmpvtz->getRawOffset() != RAW) {
1699 logln("setRawOffset is implemented in VTimeZone");
1700 }
1701
1702 // hasSameRules
1703 UBool bSame = otz->hasSameRules(*vtz);
1704 logln((UnicodeString)"OlsonTimeZone::hasSameRules(VTimeZone) should return FALSE always for now - actual: " + bSame);
1705
1706 // getTZURL/setTZURL
1707 UnicodeString TZURL("http://icu-project.org/timezone");
1708 UnicodeString url;
1709 if (vtz->getTZURL(url)) {
1710 errln("FAIL: getTZURL returned TRUE");
1711 }
1712 vtz->setTZURL(TZURL);
1713 if (!vtz->getTZURL(url) || url != TZURL) {
1714 errln("FAIL: URL returned by getTZURL does not match the one set by setTZURL");
1715 }
1716
1717 // getLastModified/setLastModified
1718 UDate lastmod;
1719 if (vtz->getLastModified(lastmod)) {
1720 errln("FAIL: getLastModified returned TRUE");
1721 }
1722 vtz->setLastModified(t);
1723 if (!vtz->getLastModified(lastmod) || lastmod != t) {
1724 errln("FAIL: Date returned by getLastModified does not match the one set by setLastModified");
1725 }
1726
1727 // getNextTransition/getPreviousTransition
1728 UDate base = getUTCMillis(2007, UCAL_JULY, 1);
1729 TimeZoneTransition tzt1, tzt2;
1730 UBool btr1 = otz->getNextTransition(base, TRUE, tzt1);
1731 UBool btr2 = vtz->getNextTransition(base, TRUE, tzt2);
1732 if (!btr1 || !btr2 || tzt1 != tzt2) {
1733 dataerrln("FAIL: getNextTransition returned different results in VTimeZone and OlsonTimeZone");
1734 }
1735 btr1 = otz->getPreviousTransition(base, FALSE, tzt1);
1736 btr2 = vtz->getPreviousTransition(base, FALSE, tzt2);
1737 if (!btr1 || !btr2 || tzt1 != tzt2) {
1738 dataerrln("FAIL: getPreviousTransition returned different results in VTimeZone and OlsonTimeZone");
1739 }
1740
1741 // TimeZoneTransition constructor/clone
1742 TimeZoneTransition *tzt1c = tzt1.clone();
1743 if (*tzt1c != tzt1 || !(*tzt1c == tzt1)) {
1744 errln("FAIL: TimeZoneTransition tzt1c is equal to tzt1, but got wrong result");
1745 }
1746 delete tzt1c;
1747 TimeZoneTransition tzt3(tzt1);
1748 if (tzt3 != tzt1 || !(tzt3 == tzt1)) {
1749 errln("FAIL: TimeZoneTransition tzt3 is equal to tzt1, but got wrong result");
1750 }
1751
1752 // hasEquivalentTransitions
1753 UDate time1 = getUTCMillis(1950, UCAL_JANUARY, 1);
1754 UDate time2 = getUTCMillis(2020, UCAL_JANUARY, 1);
1755 UBool equiv = vtz->hasEquivalentTransitions(*otz, time1, time2, FALSE, status);
1756 if (U_FAILURE(status)) {
1757 dataerrln("FAIL: hasEquivalentTransitions failed for vtz/otz: %s", u_errorName(status));
1758 }
1759 if (!equiv) {
1760 dataerrln("FAIL: hasEquivalentTransitons returned false for the same time zone");
1761 }
1762
1763 // operator=/operator==/operator!=
1764 VTimeZone *vtz1 = VTimeZone::createVTimeZoneByID("America/Los_Angeles");
1765 if (*vtz1 == *vtz || !(*vtz1 != *vtz)) {
1766 errln("FAIL: VTimeZone vtz1 is not equal to vtz, but got wrong result");
1767 }
1768 *vtz1 = *vtz;
1769 if (*vtz1 != *vtz || !(*vtz1 == *vtz)) {
1770 errln("FAIL: VTimeZone vtz1 is equal to vtz, but got wrong result");
1771 }
1772
1773 // Creation from BasicTimeZone
1774 //
1775 status = U_ZERO_ERROR;
1776 VTimeZone *vtzFromBasic = NULL;
1777 SimpleTimeZone *simpleTZ = new SimpleTimeZone(28800000, "Asia/Singapore");
1778 simpleTZ->setStartYear(1970);
1779 simpleTZ->setStartRule(0, // month
1780 1, // day of week
1781 0, // time
1782 status);
1783 simpleTZ->setEndRule(1, 1, 0, status);
1784 if (U_FAILURE(status)) {
1785 errln("File %s, line %d, failed with status = %s", __FILE__, __LINE__, u_errorName(status));
1786 goto end_basic_tz_test;
1787 }
1788 vtzFromBasic = VTimeZone::createVTimeZoneFromBasicTimeZone(*simpleTZ, status);
1789 if (U_FAILURE(status) || vtzFromBasic == NULL) {
1790 dataerrln("File %s, line %d, failed with status = %s", __FILE__, __LINE__, u_errorName(status));
1791 goto end_basic_tz_test;
1792 }
1793
1794 // delete the source time zone, to make sure there are no dependencies on it.
1795 delete simpleTZ;
1796
1797 // Create another simple time zone w the same rules, and check that it is the
1798 // same as the test VTimeZone created above.
1799 {
1800 SimpleTimeZone simpleTZ2(28800000, "Asia/Singapore");
1801 simpleTZ2.setStartYear(1970);
1802 simpleTZ2.setStartRule(0, // month
1803 1, // day of week
1804 0, // time
1805 status);
1806 simpleTZ2.setEndRule(1, 1, 0, status);
1807 if (U_FAILURE(status)) {
1808 errln("File %s, line %d, failed with status = %s", __FILE__, __LINE__, u_errorName(status));
1809 goto end_basic_tz_test;
1810 }
1811 if (vtzFromBasic->hasSameRules(simpleTZ2) == FALSE) {
1812 errln("File %s, line %d, failed hasSameRules() ", __FILE__, __LINE__);
1813 goto end_basic_tz_test;
1814 }
1815 }
1816 end_basic_tz_test:
1817 delete vtzFromBasic;
1818
1819 delete otz;
1820 delete vtz;
1821 delete tmpvtz;
1822 delete vtz1;
1823 }
1824
1825
1826 void
1827 TimeZoneRuleTest::TestVTimeZoneParse(void) {
1828 UErrorCode status = U_ZERO_ERROR;
1829
1830 // Trying to create VTimeZone from empty data
1831 UnicodeString emptyData;
1832 VTimeZone *empty = VTimeZone::createVTimeZone(emptyData, status);
1833 if (U_SUCCESS(status) || empty != NULL) {
1834 delete empty;
1835 errln("FAIL: Non-null VTimeZone is returned for empty VTIMEZONE data");
1836 }
1837 status = U_ZERO_ERROR;
1838
1839 // Create VTimeZone for Asia/Tokyo
1840 UnicodeString asiaTokyoID("Asia/Tokyo");
1841 static const UChar asiaTokyo[] = {
1842 /* "BEGIN:VTIMEZONE\x0D\x0A" */
1843 0x42,0x45,0x47,0x49,0x4E,0x3A,0x56,0x54,0x49,0x4D,0x45,0x5A,0x4F,0x4E,0x45,0x0D,0x0A,
1844 /* "TZID:Asia\x0D\x0A" */
1845 0x54,0x5A,0x49,0x44,0x3A,0x41,0x73,0x69,0x61,0x0D,0x0A,
1846 /* "\x09/Tokyo\x0D\x0A" */
1847 0x09,0x2F,0x54,0x6F,0x6B,0x79,0x6F,0x0D,0x0A,
1848 /* "BEGIN:STANDARD\x0D\x0A" */
1849 0x42,0x45,0x47,0x49,0x4E,0x3A,0x53,0x54,0x41,0x4E,0x44,0x41,0x52,0x44,0x0D,0x0A,
1850 /* "TZOFFSETFROM:+0900\x0D\x0A" */
1851 0x54,0x5A,0x4F,0x46,0x46,0x53,0x45,0x54,0x46,0x52,0x4F,0x4D,0x3A,0x2B,0x30,0x39,0x30,0x30,0x0D,0x0A,
1852 /* "TZOFFSETTO:+0900\x0D\x0A" */
1853 0x54,0x5A,0x4F,0x46,0x46,0x53,0x45,0x54,0x54,0x4F,0x3A,0x2B,0x30,0x39,0x30,0x30,0x0D,0x0A,
1854 /* "TZNAME:JST\x0D\x0A" */
1855 0x54,0x5A,0x4E,0x41,0x4D,0x45,0x3A,0x4A,0x53,0x54,0x0D,0x0A,
1856 /* "DTSTART:19700101\x0D\x0A" */
1857 0x44,0x54,0x53,0x54,0x41,0x52,0x54,0x3A,0x31,0x39,0x37,0x30,0x30,0x31,0x30,0x31,0x0D,0x0A,
1858 /* " T000000\x0D\x0A" */
1859 0x20,0x54,0x30,0x30,0x30,0x30,0x30,0x30,0x0D,0x0A,
1860 /* "END:STANDARD\x0D\x0A" */
1861 0x45,0x4E,0x44,0x3A,0x53,0x54,0x41,0x4E,0x44,0x41,0x52,0x44,0x0D,0x0A,
1862 /* "END:VTIMEZONE" */
1863 0x45,0x4E,0x44,0x3A,0x56,0x54,0x49,0x4D,0x45,0x5A,0x4F,0x4E,0x45,
1864 0
1865 };
1866 VTimeZone *tokyo = VTimeZone::createVTimeZone(asiaTokyo, status);
1867 if (U_FAILURE(status) || tokyo == NULL) {
1868 errln("FAIL: Failed to create a VTimeZone tokyo");
1869 } else {
1870 // Check ID
1871 UnicodeString tzid;
1872 tokyo->getID(tzid);
1873 if (tzid != asiaTokyoID) {
1874 errln((UnicodeString)"FAIL: Invalid TZID: " + tzid);
1875 }
1876 // Make sure offsets are correct
1877 int32_t rawOffset, dstSavings;
1878 tokyo->getOffset(Calendar::getNow(), FALSE, rawOffset, dstSavings, status);
1879 if (U_FAILURE(status)) {
1880 errln("FAIL: getOffset failed for tokyo");
1881 }
1882 if (rawOffset != 9*HOUR || dstSavings != 0) {
1883 errln("FAIL: Bad offsets returned by a VTimeZone created for Tokyo");
1884 }
1885 }
1886 delete tokyo;
1887
1888 // Create VTimeZone from VTIMEZONE data
1889 static const UChar fooData[] = {
1890 /* "BEGIN:VCALENDAR\x0D\x0A" */
1891 0x42,0x45,0x47,0x49,0x4E,0x3A,0x56,0x43,0x41,0x4C,0x45,0x4E,0x44,0x41,0x52,0x0D,0x0A,
1892 /* "BEGIN:VTIMEZONE\x0D\x0A" */
1893 0x42,0x45,0x47,0x49,0x4E,0x3A,0x56,0x54,0x49,0x4D,0x45,0x5A,0x4F,0x4E,0x45,0x0D,0x0A,
1894 /* "TZID:FOO\x0D\x0A" */
1895 0x54,0x5A,0x49,0x44,0x3A,0x46,0x4F,0x4F,0x0D,0x0A,
1896 /* "BEGIN:STANDARD\x0D\x0A" */
1897 0x42,0x45,0x47,0x49,0x4E,0x3A,0x53,0x54,0x41,0x4E,0x44,0x41,0x52,0x44,0x0D,0x0A,
1898 /* "TZOFFSETFROM:-0700\x0D\x0A" */
1899 0x54,0x5A,0x4F,0x46,0x46,0x53,0x45,0x54,0x46,0x52,0x4F,0x4D,0x3A,0x2D,0x30,0x37,0x30,0x30,0x0D,0x0A,
1900 /* "TZOFFSETTO:-0800\x0D\x0A" */
1901 0x54,0x5A,0x4F,0x46,0x46,0x53,0x45,0x54,0x54,0x4F,0x3A,0x2D,0x30,0x38,0x30,0x30,0x0D,0x0A,
1902 /* "TZNAME:FST\x0D\x0A" */
1903 0x54,0x5A,0x4E,0x41,0x4D,0x45,0x3A,0x46,0x53,0x54,0x0D,0x0A,
1904 /* "DTSTART:20071010T010000\x0D\x0A" */
1905 0x44,0x54,0x53,0x54,0x41,0x52,0x54,0x3A,0x32,0x30,0x30,0x37,0x31,0x30,0x31,0x30,0x54,0x30,0x31,0x30,0x30,0x30,0x30,0x0D,0x0A,
1906 /* "RRULE:FREQ=YEARLY;BYDAY=WE;BYMONTHDAY=10,11,12,13,14,15,16;BYMONTH=10\x0D\x0A" */
1907 0x52,0x52,0x55,0x4C,0x45,0x3A,0x46,0x52,0x45,0x51,0x3D,0x59,0x45,0x41,0x52,0x4C,0x59,0x3B,0x42,0x59,0x44,0x41,0x59,0x3D,0x57,0x45,0x3B,0x42,0x59,0x4D,0x4F,0x4E,0x54,0x48,0x44,0x41,0x59,0x3D,0x31,0x30,0x2C,0x31,0x31,0x2C,0x31,0x32,0x2C,0x31,0x33,0x2C,0x31,0x34,0x2C,0x31,0x35,0x2C,0x31,0x36,0x3B,0x42,0x59,0x4D,0x4F,0x4E,0x54,0x48,0x3D,0x31,0x30,0x0D,0x0A,
1908 /* "END:STANDARD\x0D\x0A" */
1909 0x45,0x4E,0x44,0x3A,0x53,0x54,0x41,0x4E,0x44,0x41,0x52,0x44,0x0D,0x0A,
1910 /* "BEGIN:DAYLIGHT\x0D\x0A" */
1911 0x42,0x45,0x47,0x49,0x4E,0x3A,0x44,0x41,0x59,0x4C,0x49,0x47,0x48,0x54,0x0D,0x0A,
1912 /* "TZOFFSETFROM:-0800\x0D\x0A" */
1913 0x54,0x5A,0x4F,0x46,0x46,0x53,0x45,0x54,0x46,0x52,0x4F,0x4D,0x3A,0x2D,0x30,0x38,0x30,0x30,0x0D,0x0A,
1914 /* "TZOFFSETTO:-0700\x0D\x0A" */
1915 0x54,0x5A,0x4F,0x46,0x46,0x53,0x45,0x54,0x54,0x4F,0x3A,0x2D,0x30,0x37,0x30,0x30,0x0D,0x0A,
1916 /* "TZNAME:FDT\x0D\x0A" */
1917 0x54,0x5A,0x4E,0x41,0x4D,0x45,0x3A,0x46,0x44,0x54,0x0D,0x0A,
1918 /* "DTSTART:20070415T010000\x0D\x0A" */
1919 0x44,0x54,0x53,0x54,0x41,0x52,0x54,0x3A,0x32,0x30,0x30,0x37,0x30,0x34,0x31,0x35,0x54,0x30,0x31,0x30,0x30,0x30,0x30,0x0D,0x0A,
1920 /* "RRULE:FREQ=YEARLY;BYMONTHDAY=15;BYMONTH=4\x0D\x0A" */
1921 0x52,0x52,0x55,0x4C,0x45,0x3A,0x46,0x52,0x45,0x51,0x3D,0x59,0x45,0x41,0x52,0x4C,0x59,0x3B,0x42,0x59,0x4D,0x4F,0x4E,0x54,0x48,0x44,0x41,0x59,0x3D,0x31,0x35,0x3B,0x42,0x59,0x4D,0x4F,0x4E,0x54,0x48,0x3D,0x34,0x0D,0x0A,
1922 /* "END:DAYLIGHT\x0D\x0A" */
1923 0x45,0x4E,0x44,0x3A,0x44,0x41,0x59,0x4C,0x49,0x47,0x48,0x54,0x0D,0x0A,
1924 /* "END:VTIMEZONE\x0D\x0A" */
1925 0x45,0x4E,0x44,0x3A,0x56,0x54,0x49,0x4D,0x45,0x5A,0x4F,0x4E,0x45,0x0D,0x0A,
1926 /* "END:VCALENDAR" */
1927 0x45,0x4E,0x44,0x3A,0x56,0x43,0x41,0x4C,0x45,0x4E,0x44,0x41,0x52,
1928 0
1929 };
1930
1931 VTimeZone *foo = VTimeZone::createVTimeZone(fooData, status);
1932 if (U_FAILURE(status) || foo == NULL) {
1933 errln("FAIL: Failed to create a VTimeZone foo");
1934 } else {
1935 // Write VTIMEZONE data
1936 UnicodeString fooData2;
1937 foo->write(getUTCMillis(2005, UCAL_JANUARY, 1), fooData2, status);
1938 if (U_FAILURE(status)) {
1939 errln("FAIL: Failed to write VTIMEZONE data for foo");
1940 }
1941 logln(fooData2);
1942 }
1943 delete foo;
1944 }
1945
1946 void
1947 TimeZoneRuleTest::TestT6216(void) {
1948 // Test case in #6216
1949 static const UChar tokyoTZ[] = {
1950 /* "BEGIN:VCALENDAR\r\n" */
1951 0x42,0x45,0x47,0x49,0x4e,0x3a,0x56,0x43,0x41,0x4c,0x45,0x4e,0x44,0x41,0x52,0x0d,0x0a,
1952 /* "VERSION:2.0\r\n" */
1953 0x56,0x45,0x52,0x53,0x49,0x4f,0x4e,0x3a,0x32,0x2e,0x30,0x0d,0x0a,
1954 /* "PRODID:-//PYVOBJECT//NONSGML Version 1//EN\r\n" */
1955 0x50,0x52,0x4f,0x44,0x49,0x44,0x3a,0x2d,0x2f,0x2f,0x50,0x59,0x56,0x4f,0x42,0x4a,0x45,0x43,0x54,0x2f,0x2f,0x4e,0x4f,0x4e,0x53,0x47,0x4d,0x4c,0x20,0x56,0x65,0x72,0x73,0x69,0x6f,0x6e,0x20,0x31,0x2f,0x2f,0x45,0x4e,0x0d,0x0a,
1956 /* "BEGIN:VTIMEZONE\r\n" */
1957 0x42,0x45,0x47,0x49,0x4e,0x3a,0x56,0x54,0x49,0x4d,0x45,0x5a,0x4f,0x4e,0x45,0x0d,0x0a,
1958 /* "TZID:Asia/Tokyo\r\n" */
1959 0x54,0x5a,0x49,0x44,0x3a,0x41,0x73,0x69,0x61,0x2f,0x54,0x6f,0x6b,0x79,0x6f,0x0d,0x0a,
1960 /* "BEGIN:STANDARD\r\n" */
1961 0x42,0x45,0x47,0x49,0x4e,0x3a,0x53,0x54,0x41,0x4e,0x44,0x41,0x52,0x44,0x0d,0x0a,
1962 /* "DTSTART:20000101T000000\r\n" */
1963 0x44,0x54,0x53,0x54,0x41,0x52,0x54,0x3a,0x32,0x30,0x30,0x30,0x30,0x31,0x30,0x31,0x54,0x30,0x30,0x30,0x30,0x30,0x30,0x0d,0x0a,
1964 /* "RRULE:FREQ=YEARLY;BYMONTH=1\r\n" */
1965 0x52,0x52,0x55,0x4c,0x45,0x3a,0x46,0x52,0x45,0x51,0x3d,0x59,0x45,0x41,0x52,0x4c,0x59,0x3b,0x42,0x59,0x4d,0x4f,0x4e,0x54,0x48,0x3d,0x31,0x0d,0x0a,
1966 /* "TZNAME:Asia/Tokyo\r\n" */
1967 0x54,0x5a,0x4e,0x41,0x4d,0x45,0x3a,0x41,0x73,0x69,0x61,0x2f,0x54,0x6f,0x6b,0x79,0x6f,0x0d,0x0a,
1968 /* "TZOFFSETFROM:+0900\r\n" */
1969 0x54,0x5a,0x4f,0x46,0x46,0x53,0x45,0x54,0x46,0x52,0x4f,0x4d,0x3a,0x2b,0x30,0x39,0x30,0x30,0x0d,0x0a,
1970 /* "TZOFFSETTO:+0900\r\n" */
1971 0x54,0x5a,0x4f,0x46,0x46,0x53,0x45,0x54,0x54,0x4f,0x3a,0x2b,0x30,0x39,0x30,0x30,0x0d,0x0a,
1972 /* "END:STANDARD\r\n" */
1973 0x45,0x4e,0x44,0x3a,0x53,0x54,0x41,0x4e,0x44,0x41,0x52,0x44,0x0d,0x0a,
1974 /* "END:VTIMEZONE\r\n" */
1975 0x45,0x4e,0x44,0x3a,0x56,0x54,0x49,0x4d,0x45,0x5a,0x4f,0x4e,0x45,0x0d,0x0a,
1976 /* "END:VCALENDAR" */
1977 0x45,0x4e,0x44,0x3a,0x56,0x43,0x41,0x4c,0x45,0x4e,0x44,0x41,0x52,0x0d,0x0a,
1978 0
1979 };
1980 // Single final rule, overlapping with another
1981 static const UChar finalOverlap[] = {
1982 /* "BEGIN:VCALENDAR\r\n" */
1983 0x42,0x45,0x47,0x49,0x4e,0x3a,0x56,0x43,0x41,0x4c,0x45,0x4e,0x44,0x41,0x52,0x0d,0x0a,
1984 /* "BEGIN:VTIMEZONE\r\n" */
1985 0x42,0x45,0x47,0x49,0x4e,0x3a,0x56,0x54,0x49,0x4d,0x45,0x5a,0x4f,0x4e,0x45,0x0d,0x0a,
1986 /* "TZID:FinalOverlap\r\n" */
1987 0x54,0x5a,0x49,0x44,0x3a,0x46,0x69,0x6e,0x61,0x6c,0x4f,0x76,0x65,0x72,0x6c,0x61,0x70,0x0d,0x0a,
1988 /* "BEGIN:STANDARD\r\n" */
1989 0x42,0x45,0x47,0x49,0x4e,0x3a,0x53,0x54,0x41,0x4e,0x44,0x41,0x52,0x44,0x0d,0x0a,
1990 /* "TZOFFSETFROM:-0200\r\n" */
1991 0x54,0x5a,0x4f,0x46,0x46,0x53,0x45,0x54,0x46,0x52,0x4f,0x4d,0x3a,0x2d,0x30,0x32,0x30,0x30,0x0d,0x0a,
1992 /* "TZOFFSETTO:-0300\r\n" */
1993 0x54,0x5a,0x4f,0x46,0x46,0x53,0x45,0x54,0x54,0x4f,0x3a,0x2d,0x30,0x33,0x30,0x30,0x0d,0x0a,
1994 /* "TZNAME:STD\r\n" */
1995 0x54,0x5a,0x4e,0x41,0x4d,0x45,0x3a,0x53,0x54,0x44,0x0d,0x0a,
1996 /* "DTSTART:20001029T020000\r\n" */
1997 0x44,0x54,0x53,0x54,0x41,0x52,0x54,0x3a,0x32,0x30,0x30,0x30,0x31,0x30,0x32,0x39,0x54,0x30,0x32,0x30,0x30,0x30,0x30,0x0d,0x0a,
1998 /* "RRULE:FREQ=YEARLY;BYDAY=-1SU;BYMONTH=10\r\n" */
1999 0x52,0x52,0x55,0x4c,0x45,0x3a,0x46,0x52,0x45,0x51,0x3d,0x59,0x45,0x41,0x52,0x4c,0x59,0x3b,0x42,0x59,0x44,0x41,0x59,0x3d,0x2d,0x31,0x53,0x55,0x3b,0x42,0x59,0x4d,0x4f,0x4e,0x54,0x48,0x3d,0x31,0x30,0x0d,0x0a,
2000 /* "END:STANDARD\r\n" */
2001 0x45,0x4e,0x44,0x3a,0x53,0x54,0x41,0x4e,0x44,0x41,0x52,0x44,0x0d,0x0a,
2002 /* "BEGIN:DAYLIGHT\r\n" */
2003 0x42,0x45,0x47,0x49,0x4e,0x3a,0x44,0x41,0x59,0x4c,0x49,0x47,0x48,0x54,0x0d,0x0a,
2004 /* "TZOFFSETFROM:-0300\r\n" */
2005 0x54,0x5a,0x4f,0x46,0x46,0x53,0x45,0x54,0x46,0x52,0x4f,0x4d,0x3a,0x2d,0x30,0x33,0x30,0x30,0x0d,0x0a,
2006 /* "TZOFFSETTO:-0200\r\n" */
2007 0x54,0x5a,0x4f,0x46,0x46,0x53,0x45,0x54,0x54,0x4f,0x3a,0x2d,0x30,0x32,0x30,0x30,0x0d,0x0a,
2008 /* "TZNAME:DST\r\n" */
2009 0x54,0x5a,0x4e,0x41,0x4d,0x45,0x3a,0x44,0x53,0x54,0x0d,0x0a,
2010 /* "DTSTART:19990404T020000\r\n" */
2011 0x44,0x54,0x53,0x54,0x41,0x52,0x54,0x3a,0x31,0x39,0x39,0x39,0x30,0x34,0x30,0x34,0x54,0x30,0x32,0x30,0x30,0x30,0x30,0x0d,0x0a,
2012 /* "RRULE:FREQ=YEARLY;BYDAY=1SU;BYMONTH=4;UNTIL=20050403T040000Z\r\n" */
2013 0x52,0x52,0x55,0x4c,0x45,0x3a,0x46,0x52,0x45,0x51,0x3d,0x59,0x45,0x41,0x52,0x4c,0x59,0x3b,0x42,0x59,0x44,0x41,0x59,0x3d,0x31,0x53,0x55,0x3b,0x42,0x59,0x4d,0x4f,0x4e,0x54,0x48,0x3d,0x34,0x3b,0x55,0x4e,0x54,0x49,0x4c,0x3d,0x32,0x30,0x30,0x35,0x30,0x34,0x30,0x33,0x54,0x30,0x34,0x30,0x30,0x30,0x30,0x5a,0x0d,0x0a,
2014 /* "END:DAYLIGHT\r\n" */
2015 0x45,0x4e,0x44,0x3a,0x44,0x41,0x59,0x4c,0x49,0x47,0x48,0x54,0x0d,0x0a,
2016 /* "END:VTIMEZONE\r\n" */
2017 0x45,0x4e,0x44,0x3a,0x56,0x54,0x49,0x4d,0x45,0x5a,0x4f,0x4e,0x45,0x0d,0x0a,
2018 /* "END:VCALENDAR" */
2019 0x45,0x4e,0x44,0x3a,0x56,0x43,0x41,0x4c,0x45,0x4e,0x44,0x41,0x52,0x0d,0x0a,
2020 0
2021 };
2022 // Single final rule, no overlapping with another
2023 static const UChar finalNonOverlap[] = {
2024 /* "BEGIN:VCALENDAR\r\n" */
2025 0x42,0x45,0x47,0x49,0x4e,0x3a,0x56,0x43,0x41,0x4c,0x45,0x4e,0x44,0x41,0x52,0x0d,0x0a,
2026 /* "BEGIN:VTIMEZONE\r\n" */
2027 0x42,0x45,0x47,0x49,0x4e,0x3a,0x56,0x54,0x49,0x4d,0x45,0x5a,0x4f,0x4e,0x45,0x0d,0x0a,
2028 /* "TZID:FinalNonOverlap\r\n" */
2029 0x54,0x5a,0x49,0x44,0x3a,0x46,0x69,0x6e,0x61,0x6c,0x4e,0x6f,0x6e,0x4f,0x76,0x65,0x72,0x6c,0x61,0x70,0x0d,0x0a,
2030 /* "BEGIN:STANDARD\r\n" */
2031 0x42,0x45,0x47,0x49,0x4e,0x3a,0x53,0x54,0x41,0x4e,0x44,0x41,0x52,0x44,0x0d,0x0a,
2032 /* "TZOFFSETFROM:-0200\r\n" */
2033 0x54,0x5a,0x4f,0x46,0x46,0x53,0x45,0x54,0x46,0x52,0x4f,0x4d,0x3a,0x2d,0x30,0x32,0x30,0x30,0x0d,0x0a,
2034 /* "TZOFFSETTO:-0300\r\n" */
2035 0x54,0x5a,0x4f,0x46,0x46,0x53,0x45,0x54,0x54,0x4f,0x3a,0x2d,0x30,0x33,0x30,0x30,0x0d,0x0a,
2036 /* "TZNAME:STD\r\n" */
2037 0x54,0x5a,0x4e,0x41,0x4d,0x45,0x3a,0x53,0x54,0x44,0x0d,0x0a,
2038 /* "DTSTART:20001029T020000\r\n" */
2039 0x44,0x54,0x53,0x54,0x41,0x52,0x54,0x3a,0x32,0x30,0x30,0x30,0x31,0x30,0x32,0x39,0x54,0x30,0x32,0x30,0x30,0x30,0x30,0x0d,0x0a,
2040 /* "RRULE:FREQ=YEARLY;BYDAY=-1SU;BYMONTH=10;UNTIL=20041031T040000Z\r\n" */
2041 0x52,0x52,0x55,0x4c,0x45,0x3a,0x46,0x52,0x45,0x51,0x3d,0x59,0x45,0x41,0x52,0x4c,0x59,0x3b,0x42,0x59,0x44,0x41,0x59,0x3d,0x2d,0x31,0x53,0x55,0x3b,0x42,0x59,0x4d,0x4f,0x4e,0x54,0x48,0x3d,0x31,0x30,0x3b,0x55,0x4e,0x54,0x49,0x4c,0x3d,0x32,0x30,0x30,0x34,0x31,0x30,0x33,0x31,0x54,0x30,0x34,0x30,0x30,0x30,0x30,0x5a,0x0d,0x0a,
2042 /* "END:STANDARD\r\n" */
2043 0x45,0x4e,0x44,0x3a,0x53,0x54,0x41,0x4e,0x44,0x41,0x52,0x44,0x0d,0x0a,
2044 /* "BEGIN:DAYLIGHT\r\n" */
2045 0x42,0x45,0x47,0x49,0x4e,0x3a,0x44,0x41,0x59,0x4c,0x49,0x47,0x48,0x54,0x0d,0x0a,
2046 /* "TZOFFSETFROM:-0300\r\n" */
2047 0x54,0x5a,0x4f,0x46,0x46,0x53,0x45,0x54,0x46,0x52,0x4f,0x4d,0x3a,0x2d,0x30,0x33,0x30,0x30,0x0d,0x0a,
2048 /* "TZOFFSETTO:-0200\r\n" */
2049 0x54,0x5a,0x4f,0x46,0x46,0x53,0x45,0x54,0x54,0x4f,0x3a,0x2d,0x30,0x32,0x30,0x30,0x0d,0x0a,
2050 /* "TZNAME:DST\r\n" */
2051 0x54,0x5a,0x4e,0x41,0x4d,0x45,0x3a,0x44,0x53,0x54,0x0d,0x0a,
2052 /* "DTSTART:19990404T020000\r\n" */
2053 0x44,0x54,0x53,0x54,0x41,0x52,0x54,0x3a,0x31,0x39,0x39,0x39,0x30,0x34,0x30,0x34,0x54,0x30,0x32,0x30,0x30,0x30,0x30,0x0d,0x0a,
2054 /* "RRULE:FREQ=YEARLY;BYDAY=1SU;BYMONTH=4;UNTIL=20050403T040000Z\r\n" */
2055 0x52,0x52,0x55,0x4c,0x45,0x3a,0x46,0x52,0x45,0x51,0x3d,0x59,0x45,0x41,0x52,0x4c,0x59,0x3b,0x42,0x59,0x44,0x41,0x59,0x3d,0x31,0x53,0x55,0x3b,0x42,0x59,0x4d,0x4f,0x4e,0x54,0x48,0x3d,0x34,0x3b,0x55,0x4e,0x54,0x49,0x4c,0x3d,0x32,0x30,0x30,0x35,0x30,0x34,0x30,0x33,0x54,0x30,0x34,0x30,0x30,0x30,0x30,0x5a,0x0d,0x0a,
2056 /* "END:DAYLIGHT\r\n" */
2057 0x45,0x4e,0x44,0x3a,0x44,0x41,0x59,0x4c,0x49,0x47,0x48,0x54,0x0d,0x0a,
2058 /* "BEGIN:STANDARD\r\n" */
2059 0x42,0x45,0x47,0x49,0x4e,0x3a,0x53,0x54,0x41,0x4e,0x44,0x41,0x52,0x44,0x0d,0x0a,
2060 /* "TZOFFSETFROM:-0200\r\n" */
2061 0x54,0x5a,0x4f,0x46,0x46,0x53,0x45,0x54,0x46,0x52,0x4f,0x4d,0x3a,0x2d,0x30,0x32,0x30,0x30,0x0d,0x0a,
2062 /* "TZOFFSETTO:-0300\r\n" */
2063 0x54,0x5a,0x4f,0x46,0x46,0x53,0x45,0x54,0x54,0x4f,0x3a,0x2d,0x30,0x33,0x30,0x30,0x0d,0x0a,
2064 /* "TZNAME:STDFINAL\r\n" */
2065 0x54,0x5a,0x4e,0x41,0x4d,0x45,0x3a,0x53,0x54,0x44,0x46,0x49,0x4e,0x41,0x4c,0x0d,0x0a,
2066 /* "DTSTART:20071028T020000\r\n" */
2067 0x44,0x54,0x53,0x54,0x41,0x52,0x54,0x3a,0x32,0x30,0x30,0x37,0x31,0x30,0x32,0x38,0x54,0x30,0x32,0x30,0x30,0x30,0x30,0x0d,0x0a,
2068 /* "RRULE:FREQ=YEARLY;BYDAY=-1SU;BYMONTH=10\r\n" */
2069 0x52,0x52,0x55,0x4c,0x45,0x3a,0x46,0x52,0x45,0x51,0x3d,0x59,0x45,0x41,0x52,0x4c,0x59,0x3b,0x42,0x59,0x44,0x41,0x59,0x3d,0x2d,0x31,0x53,0x55,0x3b,0x42,0x59,0x4d,0x4f,0x4e,0x54,0x48,0x3d,0x31,0x30,0x0d,0x0a,
2070 /* "END:STANDARD\r\n" */
2071 0x45,0x4e,0x44,0x3a,0x53,0x54,0x41,0x4e,0x44,0x41,0x52,0x44,0x0d,0x0a,
2072 /* "END:VTIMEZONE\r\n" */
2073 0x45,0x4e,0x44,0x3a,0x56,0x54,0x49,0x4d,0x45,0x5a,0x4f,0x4e,0x45,0x0d,0x0a,
2074 /* "END:VCALENDAR" */
2075 0x45,0x4e,0x44,0x3a,0x56,0x43,0x41,0x4c,0x45,0x4e,0x44,0x41,0x52,0x0d,0x0a,
2076 0
2077 };
2078
2079 static const int32_t TestDates[][3] = {
2080 {1995, UCAL_JANUARY, 1},
2081 {1995, UCAL_JULY, 1},
2082 {2000, UCAL_JANUARY, 1},
2083 {2000, UCAL_JULY, 1},
2084 {2005, UCAL_JANUARY, 1},
2085 {2005, UCAL_JULY, 1},
2086 {2010, UCAL_JANUARY, 1},
2087 {2010, UCAL_JULY, 1},
2088 {0, 0, 0}
2089 };
2090
2091 /*static*/ const UnicodeString TestZones[] = {
2092 UnicodeString(tokyoTZ),
2093 UnicodeString(finalOverlap),
2094 UnicodeString(finalNonOverlap),
2095 UnicodeString()
2096 };
2097
2098 int32_t Expected[][8] = {
2099 // JAN90 JUL90 JAN00 JUL00 JAN05 JUL05 JAN10 JUL10
2100 { 32400000, 32400000, 32400000, 32400000, 32400000, 32400000, 32400000, 32400000},
2101 {-10800000, -10800000, -7200000, -7200000, -10800000, -7200000, -10800000, -10800000},
2102 {-10800000, -10800000, -7200000, -7200000, -10800000, -7200000, -10800000, -10800000}
2103 };
2104
2105 int32_t i, j;
2106
2107 // Get test times
2108 UDate times[sizeof(TestDates) / (3 * sizeof(int32_t))];
2109 int32_t numTimes;
2110
2111 UErrorCode status = U_ZERO_ERROR;
2112 TimeZone *utc = TimeZone::createTimeZone("Etc/GMT");
2113 GregorianCalendar cal(utc, status);
2114 if (U_FAILURE(status)) {
2115 dataerrln("FAIL: Failed to creat a GregorianCalendar: %s", u_errorName(status));
2116 return;
2117 }
2118 for (i = 0; TestDates[i][2] != 0; i++) {
2119 cal.clear();
2120 cal.set(TestDates[i][0], TestDates[i][1], TestDates[i][2]);
2121 times[i] = cal.getTime(status);
2122 if (U_FAILURE(status)) {
2123 errln("FAIL: getTime failed");
2124 return;
2125 }
2126 }
2127 numTimes = i;
2128
2129 // Test offset
2130 for (i = 0; !TestZones[i].isEmpty(); i++) {
2131 VTimeZone *vtz = VTimeZone::createVTimeZone(TestZones[i], status);
2132 if (U_FAILURE(status)) {
2133 errln("FAIL: failed to create VTimeZone");
2134 continue;
2135 }
2136 for (j = 0; j < numTimes; j++) {
2137 int32_t raw, dst;
2138 status = U_ZERO_ERROR;
2139 vtz->getOffset(times[j], FALSE, raw, dst, status);
2140 if (U_FAILURE(status)) {
2141 errln((UnicodeString)"FAIL: getOffset failed for time zone " + i + " at " + times[j]);
2142 }
2143 int32_t offset = raw + dst;
2144 if (offset != Expected[i][j]) {
2145 errln((UnicodeString)"FAIL: Invalid offset at time(" + times[j] + "):" + offset + " Expected:" + Expected[i][j]);
2146 }
2147 }
2148 delete vtz;
2149 }
2150 }
2151
2152 void
2153 TimeZoneRuleTest::TestT6669(void) {
2154 UErrorCode status = U_ZERO_ERROR;
2155 SimpleTimeZone stz(0, "CustomID", UCAL_JANUARY, 1, UCAL_SUNDAY, 0, UCAL_JULY, 1, UCAL_SUNDAY, 0, status);
2156 if (U_FAILURE(status)) {
2157 errln("FAIL: Failed to creat a SimpleTimeZone");
2158 return;
2159 }
2160
2161 UDate t = 1230681600000.0; //2008-12-31T00:00:00
2162 UDate expectedNext = 1231027200000.0; //2009-01-04T00:00:00
2163 UDate expectedPrev = 1215298800000.0; //2008-07-06T00:00:00
2164
2165 TimeZoneTransition tzt;
2166 UBool avail = stz.getNextTransition(t, FALSE, tzt);
2167 if (!avail) {
2168 errln("FAIL: No transition returned by getNextTransition.");
2169 } else if (tzt.getTime() != expectedNext) {
2170 errln((UnicodeString)"FAIL: Wrong transition time returned by getNextTransition - "
2171 + tzt.getTime() + " Expected: " + expectedNext);
2172 }
2173
2174 avail = stz.getPreviousTransition(t, TRUE, tzt);
2175 if (!avail) {
2176 errln("FAIL: No transition returned by getPreviousTransition.");
2177 } else if (tzt.getTime() != expectedPrev) {
2178 errln((UnicodeString)"FAIL: Wrong transition time returned by getPreviousTransition - "
2179 + tzt.getTime() + " Expected: " + expectedPrev);
2180 }
2181 }
2182
2183 void
2184 TimeZoneRuleTest::TestVTimeZoneWrapper(void) {
2185 #if 0
2186 // local variables
2187 UBool b;
2188 UChar * data = NULL;
2189 int32_t length = 0;
2190 int32_t i;
2191 UDate result;
2192 UDate base = 1231027200000.0; //2009-01-04T00:00:00
2193 UErrorCode status;
2194
2195 const char *name = "Test Initial";
2196 UChar uname[20];
2197
2198 UClassID cid1;
2199 UClassID cid2;
2200
2201 ZRule * r;
2202 IZRule* ir1;
2203 IZRule* ir2;
2204 ZTrans* zt1;
2205 ZTrans* zt2;
2206 VZone* v1;
2207 VZone* v2;
2208
2209 uprv_memset(uname, 0, sizeof(uname));
2210 u_uastrcpy(uname, name);
2211
2212 // create rules
2213 ir1 = izrule_open(uname, 13, 2*HOUR, 0);
2214 ir2 = izrule_clone(ir1);
2215
2216 // test equality
2217 b = izrule_equals(ir1, ir2);
2218 b = izrule_isEquivalentTo(ir1, ir2);
2219
2220 // test accessors
2221 izrule_getName(ir1, data, length);
2222 i = izrule_getRawOffset(ir1);
2223 i = izrule_getDSTSavings(ir1);
2224
2225 b = izrule_getFirstStart(ir1, 2*HOUR, 0, result);
2226 b = izrule_getFinalStart(ir1, 2*HOUR, 0, result);
2227 b = izrule_getNextStart(ir1, base , 2*HOUR, 0, true, result);
2228 b = izrule_getPreviousStart(ir1, base, 2*HOUR, 0, true, result);
2229
2230 // test class ids
2231 cid1 = izrule_getStaticClassID(ir1);
2232 cid2 = izrule_getDynamicClassID(ir1);
2233
2234 // test transitions
2235 zt1 = ztrans_open(base, ir1, ir2);
2236 zt2 = ztrans_clone(zt1);
2237 zt2 = ztrans_openEmpty();
2238
2239 // test equality
2240 b = ztrans_equals(zt1, zt2);
2241
2242 // test accessors
2243 result = ztrans_getTime(zt1);
2244 ztrans_setTime(zt1, result);
2245
2246 r = (ZRule*)ztrans_getFrom(zt1);
2247 ztrans_setFrom(zt1, (void*)ir1);
2248 ztrans_adoptFrom(zt1, (void*)ir1);
2249
2250 r = (ZRule*)ztrans_getTo(zt1);
2251 ztrans_setTo(zt1, (void*)ir2);
2252 ztrans_adoptTo(zt1, (void*)ir2);
2253
2254 // test class ids
2255 cid1 = ztrans_getStaticClassID(zt1);
2256 cid2 = ztrans_getDynamicClassID(zt2);
2257
2258 // test vzone
2259 v1 = vzone_openID((UChar*)"America/Chicago", sizeof("America/Chicago"));
2260 v2 = vzone_clone(v1);
2261 //v2 = vzone_openData(const UChar* vtzdata, int32_t vtzdataLength, UErrorCode& status);
2262
2263 // test equality
2264 b = vzone_equals(v1, v2);
2265 b = vzone_hasSameRules(v1, v2);
2266
2267 // test accessors
2268 b = vzone_getTZURL(v1, data, length);
2269 vzone_setTZURL(v1, data, length);
2270
2271 b = vzone_getLastModified(v1, result);
2272 vzone_setLastModified(v1, result);
2273
2274 // test writers
2275 vzone_write(v1, data, length, status);
2276 vzone_writeFromStart(v1, result, data, length, status);
2277 vzone_writeSimple(v1, result, data, length, status);
2278
2279 // test more accessors
2280 i = vzone_getRawOffset(v1);
2281 vzone_setRawOffset(v1, i);
2282
2283 b = vzone_useDaylightTime(v1);
2284 b = vzone_inDaylightTime(v1, result, status);
2285
2286 b = vzone_getNextTransition(v1, result, false, zt1);
2287 b = vzone_getPreviousTransition(v1, result, false, zt1);
2288 i = vzone_countTransitionRules(v1, status);
2289
2290 cid1 = vzone_getStaticClassID(v1);
2291 cid2 = vzone_getDynamicClassID(v1);
2292
2293 // cleanup
2294 vzone_close(v1);
2295 vzone_close(v2);
2296 ztrans_close(zt1);
2297 ztrans_close(zt2);
2298 #endif
2299 }
2300
2301 //----------- private test helpers -------------------------------------------------
2302
2303 UDate
2304 TimeZoneRuleTest::getUTCMillis(int32_t y, int32_t m, int32_t d,
2305 int32_t hr, int32_t min, int32_t sec, int32_t msec) {
2306 UErrorCode status = U_ZERO_ERROR;
2307 const TimeZone *tz = TimeZone::getGMT();
2308 Calendar *cal = Calendar::createInstance(*tz, status);
2309 if (U_FAILURE(status)) {
2310 delete cal;
2311 dataerrln("FAIL: Calendar::createInstance failed: %s", u_errorName(status));
2312 return 0.0;
2313 }
2314 cal->set(y, m, d, hr, min, sec);
2315 cal->set(UCAL_MILLISECOND, msec);
2316 UDate utc = cal->getTime(status);
2317 if (U_FAILURE(status)) {
2318 delete cal;
2319 errln("FAIL: Calendar::getTime failed");
2320 return 0.0;
2321 }
2322 delete cal;
2323 return utc;
2324 }
2325
2326 /*
2327 * Check if a time shift really happens on each transition returned by getNextTransition or
2328 * getPreviousTransition in the specified time range
2329 */
2330 void
2331 TimeZoneRuleTest::verifyTransitions(BasicTimeZone& icutz, UDate start, UDate end) {
2332 UErrorCode status = U_ZERO_ERROR;
2333 UDate time;
2334 int32_t raw, dst, raw0, dst0;
2335 TimeZoneTransition tzt, tzt0;
2336 UBool avail;
2337 UBool first = TRUE;
2338 UnicodeString tzid;
2339
2340 // Ascending
2341 time = start;
2342 while (TRUE) {
2343 avail = icutz.getNextTransition(time, FALSE, tzt);
2344 if (!avail) {
2345 break;
2346 }
2347 time = tzt.getTime();
2348 if (time >= end) {
2349 break;
2350 }
2351 icutz.getOffset(time, FALSE, raw, dst, status);
2352 icutz.getOffset(time - 1, FALSE, raw0, dst0, status);
2353 if (U_FAILURE(status)) {
2354 errln("FAIL: Error in getOffset");
2355 break;
2356 }
2357
2358 if (raw == raw0 && dst == dst0) {
2359 errln((UnicodeString)"FAIL: False transition returned by getNextTransition for "
2360 + icutz.getID(tzid) + " at " + dateToString(time));
2361 }
2362 if (!first &&
2363 (tzt0.getTo()->getRawOffset() != tzt.getFrom()->getRawOffset()
2364 || tzt0.getTo()->getDSTSavings() != tzt.getFrom()->getDSTSavings())) {
2365 errln((UnicodeString)"FAIL: TO rule of the previous transition does not match FROM rule of this transtion at "
2366 + dateToString(time) + " for " + icutz.getID(tzid));
2367 }
2368 tzt0 = tzt;
2369 first = FALSE;
2370 }
2371
2372 // Descending
2373 first = TRUE;
2374 time = end;
2375 while(true) {
2376 avail = icutz.getPreviousTransition(time, FALSE, tzt);
2377 if (!avail) {
2378 break;
2379 }
2380 time = tzt.getTime();
2381 if (time <= start) {
2382 break;
2383 }
2384 icutz.getOffset(time, FALSE, raw, dst, status);
2385 icutz.getOffset(time - 1, FALSE, raw0, dst0, status);
2386 if (U_FAILURE(status)) {
2387 errln("FAIL: Error in getOffset");
2388 break;
2389 }
2390
2391 if (raw == raw0 && dst == dst0) {
2392 errln((UnicodeString)"FAIL: False transition returned by getPreviousTransition for "
2393 + icutz.getID(tzid) + " at " + dateToString(time));
2394 }
2395
2396 if (!first &&
2397 (tzt0.getFrom()->getRawOffset() != tzt.getTo()->getRawOffset()
2398 || tzt0.getFrom()->getDSTSavings() != tzt.getTo()->getDSTSavings())) {
2399 errln((UnicodeString)"FAIL: TO rule of the next transition does not match FROM rule in this transtion at "
2400 + dateToString(time) + " for " + icutz.getID(tzid));
2401 }
2402 tzt0 = tzt;
2403 first = FALSE;
2404 }
2405 }
2406
2407 /*
2408 * Compare all time transitions in 2 time zones in the specified time range in ascending order
2409 */
2410 void
2411 TimeZoneRuleTest::compareTransitionsAscending(BasicTimeZone& z1, BasicTimeZone& z2,
2412 UDate start, UDate end, UBool inclusive) {
2413 UnicodeString zid1, zid2;
2414 TimeZoneTransition tzt1, tzt2;
2415 UBool avail1, avail2;
2416 UBool inRange1, inRange2;
2417
2418 z1.getID(zid1);
2419 z2.getID(zid2);
2420
2421 UDate time = start;
2422 while (TRUE) {
2423 avail1 = z1.getNextTransition(time, inclusive, tzt1);
2424 avail2 = z2.getNextTransition(time, inclusive, tzt2);
2425
2426 inRange1 = inRange2 = FALSE;
2427 if (avail1) {
2428 if (tzt1.getTime() < end || (inclusive && tzt1.getTime() == end)) {
2429 inRange1 = TRUE;
2430 }
2431 }
2432 if (avail2) {
2433 if (tzt2.getTime() < end || (inclusive && tzt2.getTime() == end)) {
2434 inRange2 = TRUE;
2435 }
2436 }
2437 if (!inRange1 && !inRange2) {
2438 // No more transition in the range
2439 break;
2440 }
2441 if (!inRange1) {
2442 errln((UnicodeString)"FAIL: " + zid1 + " does not have any transitions after "
2443 + dateToString(time) + " before " + dateToString(end));
2444 break;
2445 }
2446 if (!inRange2) {
2447 errln((UnicodeString)"FAIL: " + zid2 + " does not have any transitions after "
2448 + dateToString(time) + " before " + dateToString(end));
2449 break;
2450 }
2451 if (tzt1.getTime() != tzt2.getTime()) {
2452 errln((UnicodeString)"FAIL: First transition after " + dateToString(time) + " "
2453 + zid1 + "[" + dateToString(tzt1.getTime()) + "] "
2454 + zid2 + "[" + dateToString(tzt2.getTime()) + "]");
2455 break;
2456 }
2457 time = tzt1.getTime();
2458 if (inclusive) {
2459 time += 1;
2460 }
2461 }
2462 }
2463
2464 /*
2465 * Compare all time transitions in 2 time zones in the specified time range in descending order
2466 */
2467 void
2468 TimeZoneRuleTest::compareTransitionsDescending(BasicTimeZone& z1, BasicTimeZone& z2,
2469 UDate start, UDate end, UBool inclusive) {
2470 UnicodeString zid1, zid2;
2471 TimeZoneTransition tzt1, tzt2;
2472 UBool avail1, avail2;
2473 UBool inRange1, inRange2;
2474
2475 z1.getID(zid1);
2476 z2.getID(zid2);
2477
2478 UDate time = end;
2479 while (TRUE) {
2480 avail1 = z1.getPreviousTransition(time, inclusive, tzt1);
2481 avail2 = z2.getPreviousTransition(time, inclusive, tzt2);
2482
2483 inRange1 = inRange2 = FALSE;
2484 if (avail1) {
2485 if (tzt1.getTime() > start || (inclusive && tzt1.getTime() == start)) {
2486 inRange1 = TRUE;
2487 }
2488 }
2489 if (avail2) {
2490 if (tzt2.getTime() > start || (inclusive && tzt2.getTime() == start)) {
2491 inRange2 = TRUE;
2492 }
2493 }
2494 if (!inRange1 && !inRange2) {
2495 // No more transition in the range
2496 break;
2497 }
2498 if (!inRange1) {
2499 errln((UnicodeString)"FAIL: " + zid1 + " does not have any transitions before "
2500 + dateToString(time) + " after " + dateToString(start));
2501 break;
2502 }
2503 if (!inRange2) {
2504 errln((UnicodeString)"FAIL: " + zid2 + " does not have any transitions before "
2505 + dateToString(time) + " after " + dateToString(start));
2506 break;
2507 }
2508 if (tzt1.getTime() != tzt2.getTime()) {
2509 errln((UnicodeString)"FAIL: Last transition before " + dateToString(time) + " "
2510 + zid1 + "[" + dateToString(tzt1.getTime()) + "] "
2511 + zid2 + "[" + dateToString(tzt2.getTime()) + "]");
2512 break;
2513 }
2514 time = tzt1.getTime();
2515 if (inclusive) {
2516 time -= 1;
2517 }
2518 }
2519 }
2520
2521 // Slightly modified version of BasicTimeZone::hasEquivalentTransitions.
2522 // This version returns TRUE if transition time delta is within the given
2523 // delta range.
2524 static UBool hasEquivalentTransitions(/*const*/ BasicTimeZone& tz1, /*const*/BasicTimeZone& tz2,
2525 UDate start, UDate end,
2526 UBool ignoreDstAmount, int32_t maxTransitionTimeDelta,
2527 UErrorCode& status) {
2528 if (U_FAILURE(status)) {
2529 return FALSE;
2530 }
2531 if (tz1.hasSameRules(tz2)) {
2532 return TRUE;
2533 }
2534 // Check the offsets at the start time
2535 int32_t raw1, raw2, dst1, dst2;
2536 tz1.getOffset(start, FALSE, raw1, dst1, status);
2537 if (U_FAILURE(status)) {
2538 return FALSE;
2539 }
2540 tz2.getOffset(start, FALSE, raw2, dst2, status);
2541 if (U_FAILURE(status)) {
2542 return FALSE;
2543 }
2544 if (ignoreDstAmount) {
2545 if ((raw1 + dst1 != raw2 + dst2)
2546 || (dst1 != 0 && dst2 == 0)
2547 || (dst1 == 0 && dst2 != 0)) {
2548 return FALSE;
2549 }
2550 } else {
2551 if (raw1 != raw2 || dst1 != dst2) {
2552 return FALSE;
2553 }
2554 }
2555 // Check transitions in the range
2556 UDate time = start;
2557 TimeZoneTransition tr1, tr2;
2558 while (TRUE) {
2559 UBool avail1 = tz1.getNextTransition(time, FALSE, tr1);
2560 UBool avail2 = tz2.getNextTransition(time, FALSE, tr2);
2561
2562 if (ignoreDstAmount) {
2563 // Skip a transition which only differ the amount of DST savings
2564 while (TRUE) {
2565 if (avail1
2566 && tr1.getTime() <= end
2567 && (tr1.getFrom()->getRawOffset() + tr1.getFrom()->getDSTSavings()
2568 == tr1.getTo()->getRawOffset() + tr1.getTo()->getDSTSavings())
2569 && (tr1.getFrom()->getDSTSavings() != 0 && tr1.getTo()->getDSTSavings() != 0)) {
2570 tz1.getNextTransition(tr1.getTime(), FALSE, tr1);
2571 } else {
2572 break;
2573 }
2574 }
2575 while (TRUE) {
2576 if (avail2
2577 && tr2.getTime() <= end
2578 && (tr2.getFrom()->getRawOffset() + tr2.getFrom()->getDSTSavings()
2579 == tr2.getTo()->getRawOffset() + tr2.getTo()->getDSTSavings())
2580 && (tr2.getFrom()->getDSTSavings() != 0 && tr2.getTo()->getDSTSavings() != 0)) {
2581 tz2.getNextTransition(tr2.getTime(), FALSE, tr2);
2582 } else {
2583 break;
2584 }
2585 }
2586 }
2587
2588 UBool inRange1 = (avail1 && tr1.getTime() <= end);
2589 UBool inRange2 = (avail2 && tr2.getTime() <= end);
2590 if (!inRange1 && !inRange2) {
2591 // No more transition in the range
2592 break;
2593 }
2594 if (!inRange1 || !inRange2) {
2595 return FALSE;
2596 }
2597 double delta = tr1.getTime() >= tr2.getTime() ? tr1.getTime() - tr2.getTime() : tr2.getTime() - tr1.getTime();
2598 if (delta > (double)maxTransitionTimeDelta) {
2599 return FALSE;
2600 }
2601 if (ignoreDstAmount) {
2602 if (tr1.getTo()->getRawOffset() + tr1.getTo()->getDSTSavings()
2603 != tr2.getTo()->getRawOffset() + tr2.getTo()->getDSTSavings()
2604 || (tr1.getTo()->getDSTSavings() != 0 && tr2.getTo()->getDSTSavings() == 0)
2605 || (tr1.getTo()->getDSTSavings() == 0 && tr2.getTo()->getDSTSavings() != 0)) {
2606 return FALSE;
2607 }
2608 } else {
2609 if (tr1.getTo()->getRawOffset() != tr2.getTo()->getRawOffset() ||
2610 tr1.getTo()->getDSTSavings() != tr2.getTo()->getDSTSavings()) {
2611 return FALSE;
2612 }
2613 }
2614 time = tr1.getTime() > tr2.getTime() ? tr1.getTime() : tr2.getTime();
2615 }
2616 return TRUE;
2617 }
2618
2619
2620 #endif /* #if !UCONFIG_NO_FORMATTING */
2621
2622 //eof
mirror of ICU