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