| /* |
| **************************************************************************** |
| * Copyright (c) 1997-2004, International Business Machines Corporation and * |
| * others. All Rights Reserved. * |
| **************************************************************************** |
| */ |
| |
| #include "unicode/utypes.h" |
| |
| #if !UCONFIG_NO_FORMATTING |
| |
| #include "unicode/utmscale.h" |
| |
| #include "cintltst.h" |
| |
| #include <stdlib.h> |
| #include <time.h> |
| |
| #define LOOP_COUNT 10000 |
| |
| static void TestAPI(void); |
| static void TestData(void); |
| static void TestMonkey(void); |
| |
| void addUtmsTest(TestNode** root); |
| |
| void addUtmsTest(TestNode** root) |
| { |
| addTest(root, &TestAPI, "tsformat/utmstest/TestAPI"); |
| addTest(root, &TestData, "tsformat/utmstest/TestData"); |
| addTest(root, &TestMonkey, "tsformat/utmstest/TestMonkey"); |
| } |
| |
| /** |
| * Return a random int64_t where U_INT64_MIN <= ran <= U_INT64_MAX. |
| */ |
| static uint64_t randomInt64(void) |
| { |
| int64_t ran = 0; |
| int32_t i; |
| static UBool initialized = FALSE; |
| |
| if (!initialized) { |
| srand((unsigned)time(NULL)); |
| initialized = TRUE; |
| } |
| |
| /* Assume rand has at least 12 bits of precision */ |
| for (i = 0; i < sizeof(ran); i += 1) { |
| ((char*)&ran)[i] = (char)((rand() & 0x0FF0) >> 4); |
| } |
| |
| return ran; |
| } |
| |
| static int64_t ranInt; |
| static int64_t ranMin; |
| static int64_t ranMax; |
| |
| static void initRandom(int64_t min, int64_t max) |
| { |
| uint64_t interval = max - min; |
| |
| ranMin = min; |
| ranMax = max; |
| ranInt = 0; |
| |
| if (interval < U_INT64_MIN) { |
| ranInt = interval; |
| } |
| } |
| |
| static int64_t randomInRange(void) |
| { |
| int64_t value; |
| |
| if (ranInt != 0) { |
| value = randomInt64() % ranInt; |
| |
| if (value < 0) { |
| value = -value; |
| } |
| |
| value += ranMin; |
| } else { |
| do { |
| value = randomInt64(); |
| } while (value < ranMin || value > ranMax); |
| } |
| |
| return value; |
| } |
| |
| static void roundTripTest(int64_t value, int32_t scale) |
| { |
| UErrorCode status = U_ZERO_ERROR; |
| int64_t rt = utmscale_toInt64(utmscale_fromInt64(value, scale, &status), scale, &status); |
| |
| if (rt != value) { |
| log_err("Round-trip error: time scale = %d, value = %lld, round-trip = %lld.\n", scale, value, rt); |
| } |
| } |
| |
| static void toLimitTest(int64_t toLimit, int64_t fromLimit, int32_t scale) |
| { |
| UErrorCode status = U_ZERO_ERROR; |
| int64_t result = utmscale_toInt64(toLimit, scale, &status); |
| |
| if (result != fromLimit) { |
| log_err("toLimit failure: scale = %d, toLimit = %lld , utmscale_toInt64(toLimit, scale, &status) = %lld, fromLimit = %lld.\n", |
| scale, toLimit, result, fromLimit); |
| } |
| } |
| |
| static void epochOffsetTest(int64_t epochOffset, int64_t units, int32_t scale) |
| { |
| UErrorCode status = U_ZERO_ERROR; |
| int64_t universal = 0; |
| int64_t universalEpoch = epochOffset * units; |
| int64_t local = utmscale_toInt64(universalEpoch, scale, &status); |
| |
| if (local != 0) { |
| log_err("utmscale_toInt64(epochOffset, scale, &status): scale = %d epochOffset = %lld, result = %lld.\n", scale, epochOffset, local); |
| } |
| |
| local = utmscale_toInt64(0, scale, &status); |
| |
| if (local != -epochOffset) { |
| log_err("utmscale_toInt64(0, scale): scale = %d, result = %lld.\n", scale, local); |
| } |
| |
| universal = utmscale_fromInt64(-epochOffset, scale, &status); |
| |
| if (universal != 0) { |
| log_err("from(-epochOffest, scale): scale = %d, epochOffset = %lld, result = %lld.\n", scale, epochOffset, universal); |
| } |
| |
| universal = utmscale_fromInt64(0, scale, &status); |
| |
| if (universal != universalEpoch) { |
| log_err("utmscale_fromInt64(0, scale): scale = %d, result = %lld.\n", scale, universal); |
| } |
| } |
| |
| static void TestEpochOffsets(void) |
| { |
| UErrorCode status = U_ZERO_ERROR; |
| int32_t scale; |
| |
| for (scale = 0; scale < UDTS_MAX_SCALE; scale += 1) { |
| int64_t units = utmscale_getTimeScaleValue(scale, UTSV_UNITS_VALUE, &status); |
| int64_t epochOffset = utmscale_getTimeScaleValue(scale, UTSV_EPOCH_OFFSET_VALUE, &status); |
| |
| epochOffsetTest(epochOffset, units, scale); |
| } |
| } |
| |
| static void TestFromLimits(void) |
| { |
| UErrorCode status = U_ZERO_ERROR; |
| int32_t scale; |
| |
| for (scale = 0; scale < UDTS_MAX_SCALE; scale += 1) { |
| int64_t fromMin = utmscale_getTimeScaleValue(scale, UTSV_FROM_MIN_VALUE, &status); |
| int64_t fromMax = utmscale_getTimeScaleValue(scale, UTSV_FROM_MAX_VALUE, &status); |
| |
| roundTripTest(fromMin, scale); |
| roundTripTest(fromMax, scale); |
| } |
| } |
| |
| static void TestToLimits(void) |
| { |
| UErrorCode status = U_ZERO_ERROR; |
| int32_t scale; |
| |
| for (scale = 0; scale < UDTS_MAX_SCALE; scale += 1) { |
| int64_t fromMin = utmscale_getTimeScaleValue(scale, UTSV_FROM_MIN_VALUE, &status); |
| int64_t fromMax = utmscale_getTimeScaleValue(scale, UTSV_FROM_MAX_VALUE, &status); |
| int64_t toMin = utmscale_getTimeScaleValue(scale, UTSV_TO_MIN_VALUE, &status); |
| int64_t toMax = utmscale_getTimeScaleValue(scale, UTSV_TO_MAX_VALUE, &status); |
| |
| toLimitTest(toMin, fromMin, scale); |
| toLimitTest(toMax, fromMax, scale); |
| } |
| } |
| |
| static void TestFromInt64(void) |
| { |
| int32_t scale; |
| int64_t result; |
| UErrorCode status = U_ZERO_ERROR; |
| |
| result = utmscale_fromInt64(0, -1, &status); |
| if (status != U_ILLEGAL_ARGUMENT_ERROR) { |
| log_err("utmscale_fromInt64(0, -1, status) did not set status to U_ILLEGAL_ARGUMENT_ERROR.\n"); |
| } |
| |
| for (scale = 0; scale < UDTS_MAX_SCALE; scale += 1) { |
| int64_t fromMin, fromMax; |
| |
| status = U_ZERO_ERROR; |
| fromMin = utmscale_getTimeScaleValue(scale, UTSV_FROM_MIN_VALUE, &status); |
| fromMax = utmscale_getTimeScaleValue(scale, UTSV_FROM_MAX_VALUE, &status); |
| |
| status = U_ZERO_ERROR; |
| result = utmscale_fromInt64(0, scale, &status); |
| if (status == U_ILLEGAL_ARGUMENT_ERROR) { |
| log_err("utmscale_fromInt64(0, %d, &status) generated U_ILLEGAL_ARGUMENT_ERROR.\n", scale); |
| } |
| |
| status = U_ZERO_ERROR; |
| result = utmscale_fromInt64(fromMin, scale, &status); |
| if (status == U_ILLEGAL_ARGUMENT_ERROR) { |
| log_err("utmscale_fromInt64(fromMin, %d, &status) generated U_ILLEGAL_ARGUMENT_ERROR.\n", scale); |
| } |
| |
| if (fromMin > U_INT64_MIN) { |
| status = U_ZERO_ERROR; |
| result = utmscale_fromInt64(fromMin - 1, scale, &status); |
| if (status != U_ILLEGAL_ARGUMENT_ERROR) { |
| log_err("utmscale_fromInt64(fromMin - 1, %d, &status) did not generate U_ILLEGAL_ARGUMENT_ERROR.\n", scale); |
| } |
| } |
| |
| status = U_ZERO_ERROR; |
| result = utmscale_fromInt64(fromMax, scale, &status); |
| if (status == U_ILLEGAL_ARGUMENT_ERROR) { |
| log_err("utmscale_fromInt64(fromMax, %d, &status) generated U_ILLEGAL_ARGUMENT_ERROR.\n", scale); |
| } |
| |
| if (fromMax < U_INT64_MAX) { |
| status = U_ZERO_ERROR; |
| result = utmscale_fromInt64(fromMax + 1, scale, &status); |
| if (status != U_ILLEGAL_ARGUMENT_ERROR) { |
| log_err("utmscale_fromInt64(fromMax + 1, %d, &status) didn't generate U_ILLEGAL_ARGUMENT_ERROR.\n", scale); |
| } |
| } |
| } |
| |
| status = U_ZERO_ERROR; |
| result = utmscale_fromInt64(0, UDTS_MAX_SCALE, &status); |
| if (status != U_ILLEGAL_ARGUMENT_ERROR) { |
| log_err("utmscale_fromInt64(0, UDTS_MAX_SCALE, &status) did not generate U_ILLEGAL_ARGUMENT_ERROR.\n"); |
| } |
| } |
| |
| static void TestToInt64(void) |
| { |
| int32_t scale; |
| int64_t result; |
| UErrorCode status = U_ZERO_ERROR; |
| |
| result = utmscale_toInt64(0, -1, &status); |
| if (status != U_ILLEGAL_ARGUMENT_ERROR) { |
| log_err("utmscale_toInt64(0, -1, &status) did not generate U_ILLEGAL_ARGUMENT_ERROR.\n"); |
| } |
| |
| for (scale = 0; scale < UDTS_MAX_SCALE; scale += 1) { |
| int64_t toMin, toMax; |
| |
| status = U_ZERO_ERROR; |
| toMin = utmscale_getTimeScaleValue(scale, UTSV_TO_MIN_VALUE, &status); |
| toMax = utmscale_getTimeScaleValue(scale, UTSV_TO_MAX_VALUE, &status); |
| |
| status = U_ZERO_ERROR; |
| result = utmscale_toInt64(0, scale, &status); |
| if (status == U_ILLEGAL_ARGUMENT_ERROR) { |
| log_err("utmscale_toInt64(0, %d, &status) generated U_ILLEGAL_ARGUMENT_ERROR.\n", scale); |
| } |
| |
| status = U_ZERO_ERROR; |
| result = utmscale_toInt64(toMin, scale, &status); |
| if (status == U_ILLEGAL_ARGUMENT_ERROR) { |
| log_err("utmscale_toInt64(toMin, %d, &status) generated U_ILLEGAL_ARGUMENT_ERROR.\n", scale); |
| } |
| |
| if (toMin > U_INT64_MIN) { |
| status = U_ZERO_ERROR; |
| result = utmscale_toInt64(toMin - 1, scale, &status); |
| if (status != U_ILLEGAL_ARGUMENT_ERROR) { |
| log_err("utmscale_toInt64(toMin - 1, %d, &status) did not generate U_ILLEGAL_ARGUMENT_ERROR.\n", scale); |
| } |
| } |
| |
| |
| status = U_ZERO_ERROR; |
| result = utmscale_toInt64(toMax, scale, &status); |
| if (status == U_ILLEGAL_ARGUMENT_ERROR) { |
| log_err("utmscale_toInt64(toMax, %d, &status) generated U_ILLEGAL_ARGUMENT_ERROR.\n", scale); |
| } |
| |
| if (toMax < U_INT64_MAX) { |
| status = U_ZERO_ERROR; |
| result = utmscale_toInt64(toMax + 1, scale, &status); |
| if (status != U_ILLEGAL_ARGUMENT_ERROR) { |
| log_err("utmscale_toInt64(toMax + 1, %d, &status) did not generate U_ILLEGAL_ARGUMENT_ERROR.\n", scale); |
| } |
| } |
| } |
| |
| status = U_ZERO_ERROR; |
| result = utmscale_toInt64(0, UDTS_MAX_SCALE, &status); |
| if (status != U_ILLEGAL_ARGUMENT_ERROR) { |
| log_err("utmscale_toInt64(0, UDTS_MAX_SCALE, &status) did not generate U_ILLEGAL_ARGUMENT_ERROR.\n"); |
| } |
| } |
| |
| static void TestAPI(void) |
| { |
| TestFromInt64(); |
| TestToInt64(); |
| } |
| |
| static void TestData(void) |
| { |
| TestEpochOffsets(); |
| TestFromLimits(); |
| TestToLimits(); |
| } |
| |
| static void TestMonkey(void) |
| { |
| int32_t scale; |
| UErrorCode status = U_ZERO_ERROR; |
| |
| for (scale = 0; scale < UDTS_MAX_SCALE; scale += 1) { |
| int64_t fromMin = utmscale_getTimeScaleValue(scale, UTSV_FROM_MIN_VALUE, &status); |
| int64_t fromMax = utmscale_getTimeScaleValue(scale, UTSV_FROM_MAX_VALUE, &status); |
| int32_t i; |
| |
| initRandom(fromMin, fromMax); |
| |
| for (i = 0; i < LOOP_COUNT; i += 1) { |
| int64_t value = randomInRange(); |
| |
| roundTripTest(value, scale); |
| } |
| } |
| } |
| |
| #endif /* #if !UCONFIG_NO_FORMATTING */ |