source/test/intltest/tzoffloc.cpp - Issue 2435373002: Delete source/test

Side by Side Diff: source/test/intltest/tzoffloc.cpp

Issue 2435373002: Delete source/test (Closed)

Patch Set: Created 4 years, 1 month ago

Use n/p to move between diff chunks; N/P to move between comments.

Jump to:

OLD	NEW
	(Empty)
1 /*

2 *******************************************************************************

3 * Copyright (C) 2007-2011, International Business Machines Corporation and *

4 * others. All Rights Reserved. *

5 *******************************************************************************

6 */

7 #include "unicode/utypes.h"

8

9 #if !UCONFIG_NO_FORMATTING

10

11 #include "tzoffloc.h"

12

13 #include "unicode/ucal.h"

14 #include "unicode/timezone.h"

15 #include "unicode/calendar.h"

16 #include "unicode/dtrule.h"

17 #include "unicode/tzrule.h"

18 #include "unicode/rbtz.h"

19 #include "unicode/simpletz.h"

20 #include "unicode/tzrule.h"

21 #include "unicode/smpdtfmt.h"

22 #include "unicode/gregocal.h"

23

24 void

25 TimeZoneOffsetLocalTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /par/ )

26 {

27 if (exec) {

28 logln("TestSuite TimeZoneOffsetLocalTest");

29 }

30 switch (index) {

31 TESTCASE(0, TestGetOffsetAroundTransition);

32 default: name = ""; break;

33 }

34 }

35

36 /*

37 * Testing getOffset APIs around rule transition by local standard/wall time.

38 */

39 void

40 TimeZoneOffsetLocalTest::TestGetOffsetAroundTransition() {

41 const int32_t NUM_DATES = 10;

42 const int32_t NUM_TIMEZONES = 3;

43

44 const int32_t HOUR = 60601000;

45 const int32_t MINUTE = 60*1000;

46

47 const int32_t DATES[NUM_DATES][6] = {

48 {2006, UCAL_APRIL, 2, 1, 30, 1HOUR+30MINUTE},

49 {2006, UCAL_APRIL, 2, 2, 00, 2*HOUR},

50 {2006, UCAL_APRIL, 2, 2, 30, 2HOUR+30MINUTE},

51 {2006, UCAL_APRIL, 2, 3, 00, 3*HOUR},

52 {2006, UCAL_APRIL, 2, 3, 30, 3HOUR+30MINUTE},

53 {2006, UCAL_OCTOBER, 29, 0, 30, 0HOUR+30MINUTE},

54 {2006, UCAL_OCTOBER, 29, 1, 00, 1*HOUR},

55 {2006, UCAL_OCTOBER, 29, 1, 30, 1HOUR+30MINUTE},

56 {2006, UCAL_OCTOBER, 29, 2, 00, 2*HOUR},

57 {2006, UCAL_OCTOBER, 29, 2, 30, 2HOUR+30MINUTE},

58 };

59

60 // Expected offsets by int32_t getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,

61 // uint8_t dayOfWeek, int32_t millis, UErrorCode& status)

62 const int32_t OFFSETS1[NUM_DATES] = {

63 // April 2, 2006

64 -8*HOUR,

65 -7*HOUR,

66 -7*HOUR,

67 -7*HOUR,

68 -7*HOUR,

69

70 // October 29, 2006

71 -7*HOUR,

72 -8*HOUR,

73 -8*HOUR,

74 -8*HOUR,

75 -8*HOUR,

76 };

77

78 // Expected offsets by void getOffset(UDate date, UBool local, int32_t& rawO ffset,

79 // int32_t& dstOffset, UErrorCode& ec) with local=TRUE

80 // or void getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_ t duplicatedTimeOpt,

81 // int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) with

82 // nonExistingTimeOpt=kStandard/duplicatedTimeOpt=kStandard

83 const int32_t OFFSETS2[NUM_DATES][2] = {

84 // April 2, 2006

85 {-8*HOUR, 0},

86 {-8*HOUR, 0},

87 {-8*HOUR, 0},

88 {-8HOUR, 1HOUR},

89 {-8HOUR, 1HOUR},

90

91 // Oct 29, 2006

92 {-8HOUR, 1HOUR},

93 {-8*HOUR, 0},

94 {-8*HOUR, 0},

95 {-8*HOUR, 0},

96 {-8*HOUR, 0},

97 };

98

99 // Expected offsets by void getOffsetFromLocal(UDate date, int32_t nonExisti ngTimeOpt,

100 // int32_t duplicatedTimeOpt, int32_t& rawOffset, int32_t& dstOffset, UError Code& status) with

101 // nonExistingTimeOpt=kDaylight/duplicatedTimeOpt=kDaylight

102 const int32_t OFFSETS3[][2] = {

103 // April 2, 2006

104 {-8*HOUR, 0},

105 {-8HOUR, 1HOUR},

106 {-8HOUR, 1HOUR},

107 {-8HOUR, 1HOUR},

108 {-8HOUR, 1HOUR},

109

110 // October 29, 2006

111 {-8HOUR, 1HOUR},

112 {-8HOUR, 1HOUR},

113 {-8HOUR, 1HOUR},

114 {-8*HOUR, 0},

115 {-8*HOUR, 0},

116 };

117

118 UErrorCode status = U_ZERO_ERROR;

119

120 int32_t rawOffset, dstOffset;

121 TimeZone* utc = TimeZone::createTimeZone("UTC");

122 Calendar* cal = Calendar::createInstance(*utc, status);

123 if (U_FAILURE(status)) {

124 dataerrln("Calendar::createInstance failed: %s", u_errorName(status));

125 return;

126 }

127 cal->clear();

128

129 // Set up TimeZone objects - OlsonTimeZone, SimpleTimeZone and RuleBasedTime Zone

130 BasicTimeZone *TESTZONES[NUM_TIMEZONES];

131

132 TESTZONES[0] = (BasicTimeZone*)TimeZone::createTimeZone("America/Los_Angeles ");

133 TESTZONES[1] = new SimpleTimeZone(-8*HOUR, "Simple Pacific Time",

134 UCAL_APRIL, 1, UCAL_SUNDAY, 2*HOUR,

135 UCAL_OCTOBER, -1, UCAL_SUNDAY, 2*HOUR, s tatus);

136 if (U_FAILURE(status)) {

137 errln("SimpleTimeZone constructor failed");

138 return;

139 }

140

141 InitialTimeZoneRule *ir = new InitialTimeZoneRule(

142 "Pacific Standard Time", // Initial time Name

143 -8*HOUR, // Raw offset

144 0*HOUR); // DST saving amount

145

146 RuleBasedTimeZone *rbPT = new RuleBasedTimeZone("Rule based Pacific Time", i r);

147

148 DateTimeRule *dtr;

149 AnnualTimeZoneRule *atzr;

150 const int32_t STARTYEAR = 2000;

151

152 dtr = new DateTimeRule(UCAL_APRIL, 1, UCAL_SUNDAY,

153 2*HOUR, DateTimeRule::WALL_TIME); // 1st Sunday in April , at 2AM wall time

154 atzr = new AnnualTimeZoneRule("Pacific Daylight Time",

155 -8HOUR / rawOffset /, 1HOUR /* dstSavings */, dtr,

156 STARTYEAR, AnnualTimeZoneRule::MAX_YEAR);

157 rbPT->addTransitionRule(atzr, status);

158 if (U_FAILURE(status)) {

159 errln("Could not add DST start rule to the RuleBasedTimeZone rbPT");

160 return;

161 }

162

163 dtr = new DateTimeRule(UCAL_OCTOBER, -1, UCAL_SUNDAY,

164 2*HOUR, DateTimeRule::WALL_TIME); // last Sunday in Octo ber, at 2AM wall time

165 atzr = new AnnualTimeZoneRule("Pacific Standard Time",

166 -8HOUR / rawOffset /, 0 / dstSavings */, dtr,

167 STARTYEAR, AnnualTimeZoneRule::MAX_YEAR);

168 rbPT->addTransitionRule(atzr, status);

169 if (U_FAILURE(status)) {

170 errln("Could not add STD start rule to the RuleBasedTimeZone rbPT");

171 return;

172 }

173

174 rbPT->complete(status);

175 if (U_FAILURE(status)) {

176 errln("complete() failed for RuleBasedTimeZone rbPT");

177 return;

178 }

179

180 TESTZONES[2] = rbPT;

181

182 // Calculate millis

183 UDate MILLIS[NUM_DATES];

184 for (int32_t i = 0; i < NUM_DATES; i++) {

185 cal->clear();

186 cal->set(DATES[i][0], DATES[i][1], DATES[i][2], DATES[i][3], DATES[i][4] );

187 MILLIS[i] = cal->getTime(status);

188 if (U_FAILURE(status)) {

189 errln("cal->getTime failed");

190 return;

191 }

192 }

193

194 SimpleDateFormat df(UnicodeString("yyyy-MM-dd HH:mm:ss"), status);

195 if (U_FAILURE(status)) {

196 dataerrln("Failed to initialize a SimpleDateFormat - %s", u_errorName(st atus));

197 }

198 df.setTimeZone(*utc);

199 UnicodeString dateStr;

200

201 // Test getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,

202 // uint8_t dayOfWeek, int32_t millis, UErrorCode& status)

203 for (int32_t i = 0; i < NUM_TIMEZONES; i++) {

204 for (int32_t d = 0; d < NUM_DATES; d++) {

205 status = U_ZERO_ERROR;

206 int32_t offset = TESTZONES[i]->getOffset(GregorianCalendar::AD, DATE S[d][0], DATES[d][1], DATES[d][2],

207 UCAL_SUNDAY, DATES[d][5], status );

208 if (U_FAILURE(status)) {

209 errln((UnicodeString)"getOffset(era,year,month,day,dayOfWeek,mil lis,status) failed for TESTZONES[" + i + "]");

210 } else if (offset != OFFSETS1[d]) {

211 dateStr.remove();

212 df.format(MILLIS[d], dateStr);

213 dataerrln((UnicodeString)"Bad offset returned by TESTZONES[" + i + "] at "

214 + dateStr + "(standard) - Got: " + offset + " Expected: " + OFFSETS1[d]);

215 }

216 }

217 }

218

219 // Test getOffset(UDate date, UBool local, int32_t& rawOffset,

220 // int32_t& dstOffset, UErrorCode& ec) with local = TRUE

221 for (int32_t i = 0; i < NUM_TIMEZONES; i++) {

222 for (int32_t m = 0; m < NUM_DATES; m++) {

223 status = U_ZERO_ERROR;

224 TESTZONES[i]->getOffset(MILLIS[m], TRUE, rawOffset, dstOffset, statu s);

225 if (U_FAILURE(status)) {

226 errln((UnicodeString)"getOffset(date,local,rawOfset,dstOffset,ec ) failed for TESTZONES[" + i + "]");

227 } else if (rawOffset != OFFSETS2[m][0] \|\| dstOffset != OFFSETS2[m][1 ]) {

228 dateStr.remove();

229 df.format(MILLIS[m], dateStr);

230 dataerrln((UnicodeString)"Bad offset returned by TESTZONES[" + i + "] at "

231 + dateStr + "(wall) - Got: "

232 + rawOffset + "/" + dstOffset

233 + " Expected: " + OFFSETS2[m][0] + "/" + OFFSETS2[m][1]) ;

234 }

235 }

236 }

237

238 // Test getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t d uplicatedTimeOpt,

239 // int32_t& rawOffset, int32_t& dstOffset, UErroCode& status)

240 // with nonExistingTimeOpt=kStandard/duplicatedTimeOpt=kStandard

241 for (int32_t i = 0; i < NUM_TIMEZONES; i++) {

242 for (int m = 0; m < NUM_DATES; m++) {

243 status = U_ZERO_ERROR;

244 TESTZONES[i]->getOffsetFromLocal(MILLIS[m], BasicTimeZone::kStandard , BasicTimeZone::kStandard,

245 rawOffset, dstOffset, status);

246 if (U_FAILURE(status)) {

247 errln((UnicodeString)"getOffsetFromLocal with kStandard/kStandar d failed for TESTZONES[" + i + "]");

248 } else if (rawOffset != OFFSETS2[m][0] \|\| dstOffset != OFFSETS2[m][1 ]) {

249 dateStr.remove();

250 df.format(MILLIS[m], dateStr);

251 dataerrln((UnicodeString)"Bad offset returned by TESTZONES[" + i + "] at "

252 + dateStr + "(wall/kStandard/kStandard) - Got: "

253 + rawOffset + "/" + dstOffset

254 + " Expected: " + OFFSETS2[m][0] + "/" + OFFSETS2[m][1]) ;

255 }

256 }

257 }

258

259 // Test getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t d uplicatedTimeOpt,

260 // int32_t& rawOffset, int32_t& dstOffset, UErroCode& status)

261 // with nonExistingTimeOpt=kDaylight/duplicatedTimeOpt=kDaylight

262 for (int32_t i = 0; i < NUM_TIMEZONES; i++) {

263 for (int m = 0; m < NUM_DATES; m++) {

264 status = U_ZERO_ERROR;

265 TESTZONES[i]->getOffsetFromLocal(MILLIS[m], BasicTimeZone::kDaylight , BasicTimeZone::kDaylight,

266 rawOffset, dstOffset, status);

267 if (U_FAILURE(status)) {

268 errln((UnicodeString)"getOffsetFromLocal with kDaylight/kDayligh t failed for TESTZONES[" + i + "]");

269 } else if (rawOffset != OFFSETS3[m][0] \|\| dstOffset != OFFSETS3[m][1 ]) {

270 dateStr.remove();

271 df.format(MILLIS[m], dateStr);

272 dataerrln((UnicodeString)"Bad offset returned by TESTZONES[" + i + "] at "

273 + dateStr + "(wall/kDaylight/kDaylight) - Got: "

274 + rawOffset + "/" + dstOffset

275 + " Expected: " + OFFSETS3[m][0] + "/" + OFFSETS3[m][1]) ;

276 }

277 }

278 }

279

280 // Test getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t d uplicatedTimeOpt,

281 // int32_t& rawOffset, int32_t& dstOffset, UErroCode& status)

282 // with nonExistingTimeOpt=kFormer/duplicatedTimeOpt=kLatter

283 for (int32_t i = 0; i < NUM_TIMEZONES; i++) {

284 for (int m = 0; m < NUM_DATES; m++) {

285 status = U_ZERO_ERROR;

286 TESTZONES[i]->getOffsetFromLocal(MILLIS[m], BasicTimeZone::kFormer, BasicTimeZone::kLatter,

287 rawOffset, dstOffset, status);

288 if (U_FAILURE(status)) {

289 errln((UnicodeString)"getOffsetFromLocal with kFormer/kLatter fa iled for TESTZONES[" + i + "]");

290 } else if (rawOffset != OFFSETS2[m][0] \|\| dstOffset != OFFSETS2[m][1 ]) {

291 dateStr.remove();

292 df.format(MILLIS[m], dateStr);

293 dataerrln((UnicodeString)"Bad offset returned by TESTZONES[" + i + "] at "

294 + dateStr + "(wall/kFormer/kLatter) - Got: "

295 + rawOffset + "/" + dstOffset

296 + " Expected: " + OFFSETS2[m][0] + "/" + OFFSETS2[m][1]) ;

297 }

298 }

299 }

300

301 // Test getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t d uplicatedTimeOpt,

302 // int32_t& rawOffset, int32_t& dstOffset, UErroCode& status)

303 // with nonExistingTimeOpt=kLatter/duplicatedTimeOpt=kFormer

304 for (int32_t i = 0; i < NUM_TIMEZONES; i++) {

305 for (int m = 0; m < NUM_DATES; m++) {

306 status = U_ZERO_ERROR;

307 TESTZONES[i]->getOffsetFromLocal(MILLIS[m], BasicTimeZone::kLatter, BasicTimeZone::kFormer,

308 rawOffset, dstOffset, status);

309 if (U_FAILURE(status)) {

310 errln((UnicodeString)"getOffsetFromLocal with kLatter/kFormer fa iled for TESTZONES[" + i + "]");

311 } else if (rawOffset != OFFSETS3[m][0] \|\| dstOffset != OFFSETS3[m][1 ]) {

312 dateStr.remove();

313 df.format(MILLIS[m], dateStr);

314 dataerrln((UnicodeString)"Bad offset returned by TESTZONES[" + i + "] at "

315 + dateStr + "(wall/kLatter/kFormer) - Got: "

316 + rawOffset + "/" + dstOffset

317 + " Expected: " + OFFSETS3[m][0] + "/" + OFFSETS3[m][1]) ;

318 }

319 }

320 }

321

322 for (int32_t i = 0; i < NUM_TIMEZONES; i++) {

323 delete TESTZONES[i];

324 }

325 delete utc;

326 delete cal;

327 }

328

329 #endif /* #if !UCONFIG_NO_FORMATTING */

OLD	NEW

« no previous file with comments | « source/test/intltest/tzoffloc.h ('k') | source/test/intltest/tzregts.h » ('j') | no next file with comments »