icuSources/test/cintltst/utmstest.c

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