| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 **************************************************************************** | |
| 3 * Copyright (c) 1997-2014, 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/utmscale.h" | |
| 13 #include "unicode/ucal.h" | |
| 14 | |
| 15 #include "cintltst.h" | |
| 16 #include "cmemory.h" | |
| 17 | |
| 18 #include <stdlib.h> | |
| 19 #include <time.h> | |
| 20 | |
| 21 #define LOOP_COUNT 10000 | |
| 22 | |
| 23 static void TestAPI(void); | |
| 24 static void TestData(void); | |
| 25 static void TestMonkey(void); | |
| 26 static void TestDotNet(void); | |
| 27 | |
| 28 void addUtmsTest(TestNode** root); | |
| 29 | |
| 30 void addUtmsTest(TestNode** root) | |
| 31 { | |
| 32 addTest(root, &TestAPI, "tsformat/utmstest/TestAPI"); | |
| 33 addTest(root, &TestData, "tsformat/utmstest/TestData"); | |
| 34 addTest(root, &TestMonkey, "tsformat/utmstest/TestMonkey"); | |
| 35 addTest(root, &TestDotNet, "tsformat/utmstest/TestDotNet"); | |
| 36 } | |
| 37 | |
| 38 /** | |
| 39 * Return a random int64_t where U_INT64_MIN <= ran <= U_INT64_MAX. | |
| 40 */ | |
| 41 static uint64_t randomInt64(void) | |
| 42 { | |
| 43 int64_t ran = 0; | |
| 44 int32_t i; | |
| 45 static UBool initialized = FALSE; | |
| 46 | |
| 47 if (!initialized) { | |
| 48 srand((unsigned)time(NULL)); | |
| 49 initialized = TRUE; | |
| 50 } | |
| 51 | |
| 52 /* Assume rand has at least 12 bits of precision */ | |
| 53 for (i = 0; i < sizeof(ran); i += 1) { | |
| 54 ((char*)&ran)[i] = (char)((rand() & 0x0FF0) >> 4); | |
| 55 } | |
| 56 | |
| 57 return ran; | |
| 58 } | |
| 59 | |
| 60 static int64_t ranInt; | |
| 61 static int64_t ranMin; | |
| 62 static int64_t ranMax; | |
| 63 | |
| 64 static void initRandom(int64_t min, int64_t max) | |
| 65 { | |
| 66 uint64_t interval = max - min; | |
| 67 | |
| 68 ranMin = min; | |
| 69 ranMax = max; | |
| 70 ranInt = 0; | |
| 71 | |
| 72 /* Verify that we don't have a huge interval. */ | |
| 73 if (interval < (uint64_t)U_INT64_MAX) { | |
| 74 ranInt = interval; | |
| 75 } | |
| 76 } | |
| 77 | |
| 78 static int64_t randomInRange(void) | |
| 79 { | |
| 80 int64_t value; | |
| 81 | |
| 82 if (ranInt != 0) { | |
| 83 value = randomInt64() % ranInt; | |
| 84 | |
| 85 if (value < 0) { | |
| 86 value = -value; | |
| 87 } | |
| 88 | |
| 89 value += ranMin; | |
| 90 } else { | |
| 91 do { | |
| 92 value = randomInt64(); | |
| 93 } while (value < ranMin || value > ranMax); | |
| 94 } | |
| 95 | |
| 96 return value; | |
| 97 } | |
| 98 | |
| 99 static void roundTripTest(int64_t value, UDateTimeScale scale) | |
| 100 { | |
| 101 UErrorCode status = U_ZERO_ERROR; | |
| 102 int64_t rt = utmscale_toInt64(utmscale_fromInt64(value, scale, &status), sca
le, &status); | |
| 103 | |
| 104 if (rt != value) { | |
| 105 log_err("Round-trip error: time scale = %d, value = %lld, round-trip = %
lld.\n", scale, value, rt); | |
| 106 } | |
| 107 } | |
| 108 | |
| 109 static void toLimitTest(int64_t toLimit, int64_t fromLimit, UDateTimeScale scale
) | |
| 110 { | |
| 111 UErrorCode status = U_ZERO_ERROR; | |
| 112 int64_t result = utmscale_toInt64(toLimit, scale, &status); | |
| 113 | |
| 114 if (result != fromLimit) { | |
| 115 log_err("toLimit failure: scale = %d, toLimit = %lld , utmscale_toInt64(
toLimit, scale, &status) = %lld, fromLimit = %lld.\n", | |
| 116 scale, toLimit, result, fromLimit); | |
| 117 } | |
| 118 } | |
| 119 | |
| 120 static void epochOffsetTest(int64_t epochOffset, int64_t units, UDateTimeScale s
cale) | |
| 121 { | |
| 122 UErrorCode status = U_ZERO_ERROR; | |
| 123 int64_t universal = 0; | |
| 124 int64_t universalEpoch = epochOffset * units; | |
| 125 int64_t local = utmscale_toInt64(universalEpoch, scale, &status); | |
| 126 | |
| 127 if (local != 0) { | |
| 128 log_err("utmscale_toInt64(epochOffset, scale, &status): scale = %d epoch
Offset = %lld, result = %lld.\n", scale, epochOffset, local); | |
| 129 } | |
| 130 | |
| 131 local = utmscale_toInt64(0, scale, &status); | |
| 132 | |
| 133 if (local != -epochOffset) { | |
| 134 log_err("utmscale_toInt64(0, scale): scale = %d, result = %lld.\n", scal
e, local); | |
| 135 } | |
| 136 | |
| 137 universal = utmscale_fromInt64(-epochOffset, scale, &status); | |
| 138 | |
| 139 if (universal != 0) { | |
| 140 log_err("from(-epochOffest, scale): scale = %d, epochOffset = %lld, resu
lt = %lld.\n", scale, epochOffset, universal); | |
| 141 } | |
| 142 | |
| 143 universal = utmscale_fromInt64(0, scale, &status); | |
| 144 | |
| 145 if (universal != universalEpoch) { | |
| 146 log_err("utmscale_fromInt64(0, scale): scale = %d, result = %lld.\n", sc
ale, universal); | |
| 147 } | |
| 148 } | |
| 149 | |
| 150 static void TestEpochOffsets(void) | |
| 151 { | |
| 152 UErrorCode status = U_ZERO_ERROR; | |
| 153 int32_t scale; | |
| 154 | |
| 155 for (scale = 0; scale < UDTS_MAX_SCALE; scale += 1) { | |
| 156 int64_t units = utmscale_getTimeScaleValue((UDateTimeScale)scale,
UTSV_UNITS_VALUE, &status); | |
| 157 int64_t epochOffset = utmscale_getTimeScaleValue((UDateTimeScale)scale,
UTSV_EPOCH_OFFSET_VALUE, &status); | |
| 158 | |
| 159 epochOffsetTest(epochOffset, units, (UDateTimeScale)scale); | |
| 160 } | |
| 161 } | |
| 162 | |
| 163 static void TestFromLimits(void) | |
| 164 { | |
| 165 UErrorCode status = U_ZERO_ERROR; | |
| 166 int32_t scale; | |
| 167 | |
| 168 for (scale = 0; scale < UDTS_MAX_SCALE; scale += 1) { | |
| 169 int64_t fromMin = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV
_FROM_MIN_VALUE, &status); | |
| 170 int64_t fromMax = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV
_FROM_MAX_VALUE, &status); | |
| 171 | |
| 172 roundTripTest(fromMin, (UDateTimeScale)scale); | |
| 173 roundTripTest(fromMax, (UDateTimeScale)scale); | |
| 174 } | |
| 175 } | |
| 176 | |
| 177 static void TestToLimits(void) | |
| 178 { | |
| 179 UErrorCode status = U_ZERO_ERROR; | |
| 180 int32_t scale; | |
| 181 | |
| 182 for (scale = 0; scale < UDTS_MAX_SCALE; scale += 1) { | |
| 183 int64_t fromMin = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV
_FROM_MIN_VALUE, &status); | |
| 184 int64_t fromMax = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV
_FROM_MAX_VALUE, &status); | |
| 185 int64_t toMin = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV
_TO_MIN_VALUE, &status); | |
| 186 int64_t toMax = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV
_TO_MAX_VALUE, &status); | |
| 187 | |
| 188 toLimitTest(toMin, fromMin, (UDateTimeScale)scale); | |
| 189 toLimitTest(toMax, fromMax, (UDateTimeScale)scale); | |
| 190 } | |
| 191 } | |
| 192 | |
| 193 static void TestFromInt64(void) | |
| 194 { | |
| 195 int32_t scale; | |
| 196 int64_t result; | |
| 197 UErrorCode status = U_ZERO_ERROR; | |
| 198 | |
| 199 result = utmscale_fromInt64(0, -1, &status); | |
| 200 (void)result; /* Suppress set but not used warning. */ | |
| 201 if (status != U_ILLEGAL_ARGUMENT_ERROR) { | |
| 202 log_err("utmscale_fromInt64(0, -1, status) did not set status to U_ILLEG
AL_ARGUMENT_ERROR.\n"); | |
| 203 } | |
| 204 | |
| 205 for (scale = 0; scale < UDTS_MAX_SCALE; scale += 1) { | |
| 206 int64_t fromMin, fromMax; | |
| 207 | |
| 208 status = U_ZERO_ERROR; | |
| 209 fromMin = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV_FROM_MI
N_VALUE, &status); | |
| 210 fromMax = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV_FROM_MA
X_VALUE, &status); | |
| 211 | |
| 212 status = U_ZERO_ERROR; | |
| 213 result = utmscale_fromInt64(0, (UDateTimeScale)scale, &status); | |
| 214 if (status == U_ILLEGAL_ARGUMENT_ERROR) { | |
| 215 log_err("utmscale_fromInt64(0, %d, &status) generated U_ILLEGAL_ARGU
MENT_ERROR.\n", scale); | |
| 216 } | |
| 217 | |
| 218 status = U_ZERO_ERROR; | |
| 219 result = utmscale_fromInt64(fromMin, (UDateTimeScale)scale, &status); | |
| 220 if (status == U_ILLEGAL_ARGUMENT_ERROR) { | |
| 221 log_err("utmscale_fromInt64(fromMin, %d, &status) generated U_ILLEGA
L_ARGUMENT_ERROR.\n", scale); | |
| 222 } | |
| 223 | |
| 224 if (fromMin > U_INT64_MIN) { | |
| 225 status = U_ZERO_ERROR; | |
| 226 result = utmscale_fromInt64(fromMin - 1, (UDateTimeScale)scale, &sta
tus); | |
| 227 if (status != U_ILLEGAL_ARGUMENT_ERROR) { | |
| 228 log_err("utmscale_fromInt64(fromMin - 1, %d, &status) did not ge
nerate U_ILLEGAL_ARGUMENT_ERROR.\n", scale); | |
| 229 } | |
| 230 } | |
| 231 | |
| 232 status = U_ZERO_ERROR; | |
| 233 result = utmscale_fromInt64(fromMax, (UDateTimeScale)scale, &status); | |
| 234 if (status == U_ILLEGAL_ARGUMENT_ERROR) { | |
| 235 log_err("utmscale_fromInt64(fromMax, %d, &status) generated U_ILLEGA
L_ARGUMENT_ERROR.\n", scale); | |
| 236 } | |
| 237 | |
| 238 if (fromMax < U_INT64_MAX) { | |
| 239 status = U_ZERO_ERROR; | |
| 240 result = utmscale_fromInt64(fromMax + 1, (UDateTimeScale)scale, &sta
tus); | |
| 241 if (status != U_ILLEGAL_ARGUMENT_ERROR) { | |
| 242 log_err("utmscale_fromInt64(fromMax + 1, %d, &status) didn't gen
erate U_ILLEGAL_ARGUMENT_ERROR.\n", scale); | |
| 243 } | |
| 244 } | |
| 245 } | |
| 246 | |
| 247 status = U_ZERO_ERROR; | |
| 248 result = utmscale_fromInt64(0, UDTS_MAX_SCALE, &status); | |
| 249 if (status != U_ILLEGAL_ARGUMENT_ERROR) { | |
| 250 log_err("utmscale_fromInt64(0, UDTS_MAX_SCALE, &status) did not generate
U_ILLEGAL_ARGUMENT_ERROR.\n"); | |
| 251 } | |
| 252 } | |
| 253 | |
| 254 static void TestToInt64(void) | |
| 255 { | |
| 256 int32_t scale; | |
| 257 int64_t result; | |
| 258 UErrorCode status = U_ZERO_ERROR; | |
| 259 | |
| 260 result = utmscale_toInt64(0, -1, &status); | |
| 261 (void)result; /* suppress set but not used warning. */ | |
| 262 if (status != U_ILLEGAL_ARGUMENT_ERROR) { | |
| 263 log_err("utmscale_toInt64(0, -1, &status) did not generate U_ILLEGAL_ARG
UMENT_ERROR.\n"); | |
| 264 } | |
| 265 | |
| 266 for (scale = 0; scale < UDTS_MAX_SCALE; scale += 1) { | |
| 267 int64_t toMin, toMax; | |
| 268 | |
| 269 status = U_ZERO_ERROR; | |
| 270 toMin = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV_TO_MIN_VA
LUE, &status); | |
| 271 toMax = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV_TO_MAX_VA
LUE, &status); | |
| 272 | |
| 273 status = U_ZERO_ERROR; | |
| 274 result = utmscale_toInt64(0, (UDateTimeScale)scale, &status); | |
| 275 if (status == U_ILLEGAL_ARGUMENT_ERROR) { | |
| 276 log_err("utmscale_toInt64(0, %d, &status) generated U_ILLEGAL_ARGUME
NT_ERROR.\n", scale); | |
| 277 } | |
| 278 | |
| 279 status = U_ZERO_ERROR; | |
| 280 result = utmscale_toInt64(toMin, (UDateTimeScale)scale, &status); | |
| 281 if (status == U_ILLEGAL_ARGUMENT_ERROR) { | |
| 282 log_err("utmscale_toInt64(toMin, %d, &status) generated U_ILLEGAL_AR
GUMENT_ERROR.\n", scale); | |
| 283 } | |
| 284 | |
| 285 if (toMin > U_INT64_MIN) { | |
| 286 status = U_ZERO_ERROR; | |
| 287 result = utmscale_toInt64(toMin - 1, (UDateTimeScale)scale, &status)
; | |
| 288 if (status != U_ILLEGAL_ARGUMENT_ERROR) { | |
| 289 log_err("utmscale_toInt64(toMin - 1, %d, &status) did not genera
te U_ILLEGAL_ARGUMENT_ERROR.\n", scale); | |
| 290 } | |
| 291 } | |
| 292 | |
| 293 | |
| 294 status = U_ZERO_ERROR; | |
| 295 result = utmscale_toInt64(toMax, (UDateTimeScale)scale, &status); | |
| 296 if (status == U_ILLEGAL_ARGUMENT_ERROR) { | |
| 297 log_err("utmscale_toInt64(toMax, %d, &status) generated U_ILLEGAL_AR
GUMENT_ERROR.\n", scale); | |
| 298 } | |
| 299 | |
| 300 if (toMax < U_INT64_MAX) { | |
| 301 status = U_ZERO_ERROR; | |
| 302 result = utmscale_toInt64(toMax + 1, (UDateTimeScale)scale, &status)
; | |
| 303 if (status != U_ILLEGAL_ARGUMENT_ERROR) { | |
| 304 log_err("utmscale_toInt64(toMax + 1, %d, &status) did not genera
te U_ILLEGAL_ARGUMENT_ERROR.\n", scale); | |
| 305 } | |
| 306 } | |
| 307 } | |
| 308 | |
| 309 status = U_ZERO_ERROR; | |
| 310 result = utmscale_toInt64(0, UDTS_MAX_SCALE, &status); | |
| 311 if (status != U_ILLEGAL_ARGUMENT_ERROR) { | |
| 312 log_err("utmscale_toInt64(0, UDTS_MAX_SCALE, &status) did not generate U
_ILLEGAL_ARGUMENT_ERROR.\n"); | |
| 313 } | |
| 314 } | |
| 315 | |
| 316 static void TestAPI(void) | |
| 317 { | |
| 318 TestFromInt64(); | |
| 319 TestToInt64(); | |
| 320 } | |
| 321 | |
| 322 static void TestData(void) | |
| 323 { | |
| 324 TestEpochOffsets(); | |
| 325 TestFromLimits(); | |
| 326 TestToLimits(); | |
| 327 } | |
| 328 | |
| 329 static void TestMonkey(void) | |
| 330 { | |
| 331 int32_t scale; | |
| 332 UErrorCode status = U_ZERO_ERROR; | |
| 333 | |
| 334 for (scale = 0; scale < UDTS_MAX_SCALE; scale += 1) { | |
| 335 int64_t fromMin = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV
_FROM_MIN_VALUE, &status); | |
| 336 int64_t fromMax = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV
_FROM_MAX_VALUE, &status); | |
| 337 int32_t i; | |
| 338 | |
| 339 initRandom(fromMin, fromMax); | |
| 340 | |
| 341 for (i = 0; i < LOOP_COUNT; i += 1) { | |
| 342 int64_t value = randomInRange(); | |
| 343 | |
| 344 roundTripTest(value, (UDateTimeScale)scale); | |
| 345 } | |
| 346 } | |
| 347 } | |
| 348 | |
| 349 struct DotNetDateTimeTicks { | |
| 350 int32_t year; | |
| 351 int32_t month; | |
| 352 int32_t day; | |
| 353 int64_t ticks; | |
| 354 }; | |
| 355 typedef struct DotNetDateTimeTicks DotNetDateTimeTicks; | |
| 356 | |
| 357 /* | |
| 358 * This data was generated by C++.Net code like | |
| 359 * Console::WriteLine(L" {{ {0}, 1, 1, INT64_C({1}) }},", year, DateTime(year
, 1, 1).Ticks); | |
| 360 * with the DateTime constructor taking int values for year, month, and date. | |
| 361 */ | |
| 362 static const DotNetDateTimeTicks dotNetDateTimeTicks[]={ | |
| 363 /* year, month, day, ticks */ | |
| 364 { 100, 1, 1, INT64_C(31241376000000000) }, | |
| 365 { 100, 3, 1, INT64_C(31292352000000000) }, | |
| 366 { 200, 1, 1, INT64_C(62798112000000000) }, | |
| 367 { 200, 3, 1, INT64_C(62849088000000000) }, | |
| 368 { 300, 1, 1, INT64_C(94354848000000000) }, | |
| 369 { 300, 3, 1, INT64_C(94405824000000000) }, | |
| 370 { 400, 1, 1, INT64_C(125911584000000000) }, | |
| 371 { 400, 3, 1, INT64_C(125963424000000000) }, | |
| 372 { 500, 1, 1, INT64_C(157469184000000000) }, | |
| 373 { 500, 3, 1, INT64_C(157520160000000000) }, | |
| 374 { 600, 1, 1, INT64_C(189025920000000000) }, | |
| 375 { 600, 3, 1, INT64_C(189076896000000000) }, | |
| 376 { 700, 1, 1, INT64_C(220582656000000000) }, | |
| 377 { 700, 3, 1, INT64_C(220633632000000000) }, | |
| 378 { 800, 1, 1, INT64_C(252139392000000000) }, | |
| 379 { 800, 3, 1, INT64_C(252191232000000000) }, | |
| 380 { 900, 1, 1, INT64_C(283696992000000000) }, | |
| 381 { 900, 3, 1, INT64_C(283747968000000000) }, | |
| 382 { 1000, 1, 1, INT64_C(315253728000000000) }, | |
| 383 { 1000, 3, 1, INT64_C(315304704000000000) }, | |
| 384 { 1100, 1, 1, INT64_C(346810464000000000) }, | |
| 385 { 1100, 3, 1, INT64_C(346861440000000000) }, | |
| 386 { 1200, 1, 1, INT64_C(378367200000000000) }, | |
| 387 { 1200, 3, 1, INT64_C(378419040000000000) }, | |
| 388 { 1300, 1, 1, INT64_C(409924800000000000) }, | |
| 389 { 1300, 3, 1, INT64_C(409975776000000000) }, | |
| 390 { 1400, 1, 1, INT64_C(441481536000000000) }, | |
| 391 { 1400, 3, 1, INT64_C(441532512000000000) }, | |
| 392 { 1500, 1, 1, INT64_C(473038272000000000) }, | |
| 393 { 1500, 3, 1, INT64_C(473089248000000000) }, | |
| 394 { 1600, 1, 1, INT64_C(504595008000000000) }, | |
| 395 { 1600, 3, 1, INT64_C(504646848000000000) }, | |
| 396 { 1700, 1, 1, INT64_C(536152608000000000) }, | |
| 397 { 1700, 3, 1, INT64_C(536203584000000000) }, | |
| 398 { 1800, 1, 1, INT64_C(567709344000000000) }, | |
| 399 { 1800, 3, 1, INT64_C(567760320000000000) }, | |
| 400 { 1900, 1, 1, INT64_C(599266080000000000) }, | |
| 401 { 1900, 3, 1, INT64_C(599317056000000000) }, | |
| 402 { 2000, 1, 1, INT64_C(630822816000000000) }, | |
| 403 { 2000, 3, 1, INT64_C(630874656000000000) }, | |
| 404 { 2100, 1, 1, INT64_C(662380416000000000) }, | |
| 405 { 2100, 3, 1, INT64_C(662431392000000000) }, | |
| 406 { 2200, 1, 1, INT64_C(693937152000000000) }, | |
| 407 { 2200, 3, 1, INT64_C(693988128000000000) }, | |
| 408 { 2300, 1, 1, INT64_C(725493888000000000) }, | |
| 409 { 2300, 3, 1, INT64_C(725544864000000000) }, | |
| 410 { 2400, 1, 1, INT64_C(757050624000000000) }, | |
| 411 { 2400, 3, 1, INT64_C(757102464000000000) }, | |
| 412 { 2500, 1, 1, INT64_C(788608224000000000) }, | |
| 413 { 2500, 3, 1, INT64_C(788659200000000000) }, | |
| 414 { 2600, 1, 1, INT64_C(820164960000000000) }, | |
| 415 { 2600, 3, 1, INT64_C(820215936000000000) }, | |
| 416 { 2700, 1, 1, INT64_C(851721696000000000) }, | |
| 417 { 2700, 3, 1, INT64_C(851772672000000000) }, | |
| 418 { 2800, 1, 1, INT64_C(883278432000000000) }, | |
| 419 { 2800, 3, 1, INT64_C(883330272000000000) }, | |
| 420 { 2900, 1, 1, INT64_C(914836032000000000) }, | |
| 421 { 2900, 3, 1, INT64_C(914887008000000000) }, | |
| 422 { 3000, 1, 1, INT64_C(946392768000000000) }, | |
| 423 { 3000, 3, 1, INT64_C(946443744000000000) }, | |
| 424 { 1, 1, 1, INT64_C(0) }, | |
| 425 { 1601, 1, 1, INT64_C(504911232000000000) }, | |
| 426 { 1899, 12, 31, INT64_C(599265216000000000) }, | |
| 427 { 1904, 1, 1, INT64_C(600527520000000000) }, | |
| 428 { 1970, 1, 1, INT64_C(621355968000000000) }, | |
| 429 { 2001, 1, 1, INT64_C(631139040000000000) }, | |
| 430 { 9900, 3, 1, INT64_C(3123873216000000000) }, | |
| 431 { 9999, 12, 31, INT64_C(3155378112000000000) } | |
| 432 }; | |
| 433 | |
| 434 /* | |
| 435 * ICU's Universal Time Scale is designed to be tick-for-tick compatible with | |
| 436 * .Net System.DateTime. Verify that this is so for the | |
| 437 * .Net-supported date range (years 1-9999 AD). | |
| 438 * This requires a proleptic Gregorian calendar because that's what .Net uses. | |
| 439 * Proleptic: No Julian/Gregorian switchover, or a switchover before | |
| 440 * any date that we test, that is, before 0001 AD. | |
| 441 */ | |
| 442 static void | |
| 443 TestDotNet() { | |
| 444 static const UChar utc[] = { 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0 };
/* "Etc/GMT" */ | |
| 445 const int32_t dayMillis = 86400 * INT64_C(1000); /* 1 day = 86400 seconds
*/ | |
| 446 const int64_t dayTicks = 86400 * INT64_C(10000000); | |
| 447 const DotNetDateTimeTicks *dt; | |
| 448 UCalendar *cal; | |
| 449 UErrorCode errorCode; | |
| 450 UDate icuDate; | |
| 451 int64_t ticks, millis; | |
| 452 int32_t i; | |
| 453 | |
| 454 /* Open a proleptic Gregorian calendar. */ | |
| 455 errorCode = U_ZERO_ERROR; | |
| 456 cal = ucal_open(utc, -1, "", UCAL_GREGORIAN, &errorCode); | |
| 457 ucal_setGregorianChange(cal, -1000000 * (dayMillis * (UDate)1), &errorCode); | |
| 458 if(U_FAILURE(errorCode)) { | |
| 459 log_data_err("ucal_open(UTC/proleptic Gregorian) failed: %s - (Are you m
issing data?)\n", u_errorName(errorCode)); | |
| 460 ucal_close(cal); | |
| 461 return; | |
| 462 } | |
| 463 for(i = 0; i < UPRV_LENGTHOF(dotNetDateTimeTicks); ++i) { | |
| 464 /* Test conversion from .Net/Universal time to ICU time. */ | |
| 465 dt = dotNetDateTimeTicks + i; | |
| 466 millis = utmscale_toInt64(dt->ticks, UDTS_ICU4C_TIME, &errorCode); | |
| 467 ucal_clear(cal); | |
| 468 ucal_setDate(cal, dt->year, dt->month - 1, dt->day, &errorCode); /* Java
& ICU use January = month 0. */ | |
| 469 icuDate = ucal_getMillis(cal, &errorCode); | |
| 470 if(millis != icuDate) { | |
| 471 /* Print days not millis to stay within printf() range. */ | |
| 472 log_err("utmscale_toInt64(ticks[%d], ICU4C)=%dd != %dd=ucal_getMilli
s(%04d-%02d-%02d)\n", | |
| 473 (int)i, (int)(millis/dayMillis), (int)(icuDate/dayMillis), (
int)dt->year, (int)dt->month, (int)dt->day); | |
| 474 } | |
| 475 | |
| 476 /* Test conversion from ICU time to .Net/Universal time. */ | |
| 477 ticks = utmscale_fromInt64((int64_t)icuDate, UDTS_ICU4C_TIME, &errorCode
); | |
| 478 if(ticks != dt->ticks) { | |
| 479 /* Print days not ticks to stay within printf() range. */ | |
| 480 log_err("utmscale_fromInt64(date[%d], ICU4C)=%dd != %dd=.Net System.
DateTime(%04d-%02d-%02d).Ticks\n", | |
| 481 (int)i, (int)(ticks/dayTicks), (int)(dt->ticks/dayTicks), (i
nt)dt->year, (int)dt->month, (int)dt->day); | |
| 482 } | |
| 483 } | |
| 484 | |
| 485 ucal_close(cal); | |
| 486 } | |
| 487 | |
| 488 #endif /* #if !UCONFIG_NO_FORMATTING */ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2435373002:
Delete source/test (Closed)
