icuSources/test/cintltst/utmstest.c

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