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
23static void TestAPI(void);
24static void TestData(void);
25static void TestMonkey(void);
26static void TestDotNet(void);
27
28void addUtmsTest(TestNode** root);
29
30void 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 */
41static 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
60static int64_t ranInt;
61static int64_t ranMin;
62static int64_t ranMax;
63
64static 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
78static 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
99static 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), scale, &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
109static 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
120static void epochOffsetTest(int64_t epochOffset, int64_t units, UDateTimeScale scale)
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 epochOffset = %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", scale, 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, result = %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", scale, universal);
147    }
148}
149
150static 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
163static 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
177static 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
193static 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_ILLEGAL_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_MIN_VALUE, &status);
210        fromMax = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV_FROM_MAX_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_ARGUMENT_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_ILLEGAL_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, &status);
227            if (status != U_ILLEGAL_ARGUMENT_ERROR) {
228                log_err("utmscale_fromInt64(fromMin - 1, %d, &status) did not generate 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_ILLEGAL_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, &status);
241            if (status != U_ILLEGAL_ARGUMENT_ERROR) {
242                log_err("utmscale_fromInt64(fromMax + 1, %d, &status) didn't generate 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
254static 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_ARGUMENT_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_VALUE, &status);
271        toMax = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV_TO_MAX_VALUE, &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_ARGUMENT_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_ARGUMENT_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 generate 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_ARGUMENT_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 generate 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
316static void TestAPI(void)
317{
318    TestFromInt64();
319    TestToInt64();
320}
321
322static void TestData(void)
323{
324    TestEpochOffsets();
325    TestFromLimits();
326    TestToLimits();
327}
328
329static 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
349struct DotNetDateTimeTicks {
350    int32_t year;
351    int32_t month;
352    int32_t day;
353    int64_t ticks;
354};
355typedef 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 */
362static 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 */
442static void
443TestDotNet() {
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 missing 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_getMillis(%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), (int)dt->year, (int)dt->month, (int)dt->day);
482        }
483    }
484
485    ucal_close(cal);
486}
487
488#endif /* #if !UCONFIG_NO_FORMATTING */
489