/*
****************************************************************************
- * Copyright (c) 1997-2006, International Business Machines Corporation and *
+ * Copyright (c) 1997-2014, International Business Machines Corporation and *
* others. All Rights Reserved. *
****************************************************************************
*/
#include "unicode/ucal.h"
#include "cintltst.h"
+#include "cmemory.h"
#include <stdlib.h>
#include <time.h>
-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
-
#define LOOP_COUNT 10000
static void TestAPI(void);
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) {
+
+ /* Verify that we don't have a huge interval. */
+ if (interval < (uint64_t)U_INT64_MAX) {
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)
+
+static void roundTripTest(int64_t value, UDateTimeScale 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)
+static void toLimitTest(int64_t toLimit, int64_t fromLimit, UDateTimeScale 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)
+static void epochOffsetTest(int64_t epochOffset, int64_t units, UDateTimeScale 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);
}
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);
+ int64_t units = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV_UNITS_VALUE, &status);
+ int64_t epochOffset = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV_EPOCH_OFFSET_VALUE, &status);
+
+ epochOffsetTest(epochOffset, units, (UDateTimeScale)scale);
}
}
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);
+ int64_t fromMin = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV_FROM_MIN_VALUE, &status);
+ int64_t fromMax = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV_FROM_MAX_VALUE, &status);
+
+ roundTripTest(fromMin, (UDateTimeScale)scale);
+ roundTripTest(fromMax, (UDateTimeScale)scale);
}
}
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);
+ int64_t fromMin = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV_FROM_MIN_VALUE, &status);
+ int64_t fromMax = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV_FROM_MAX_VALUE, &status);
+ int64_t toMin = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV_TO_MIN_VALUE, &status);
+ int64_t toMax = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV_TO_MAX_VALUE, &status);
+
+ toLimitTest(toMin, fromMin, (UDateTimeScale)scale);
+ toLimitTest(toMax, fromMax, (UDateTimeScale)scale);
}
}
int32_t scale;
int64_t result;
UErrorCode status = U_ZERO_ERROR;
-
+
result = utmscale_fromInt64(0, -1, &status);
+ (void)result; /* Suppress set but not used warning. */
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);
-
+ fromMin = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV_FROM_MIN_VALUE, &status);
+ fromMax = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV_FROM_MAX_VALUE, &status);
+
status = U_ZERO_ERROR;
- result = utmscale_fromInt64(0, scale, &status);
+ result = utmscale_fromInt64(0, (UDateTimeScale)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);
+ result = utmscale_fromInt64(fromMin, (UDateTimeScale)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) {
+
+ if (fromMin > U_INT64_MIN) {
status = U_ZERO_ERROR;
- result = utmscale_fromInt64(fromMin - 1, scale, &status);
+ result = utmscale_fromInt64(fromMin - 1, (UDateTimeScale)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);
+ result = utmscale_fromInt64(fromMax, (UDateTimeScale)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);
+ result = utmscale_fromInt64(fromMax + 1, (UDateTimeScale)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) {
int32_t scale;
int64_t result;
UErrorCode status = U_ZERO_ERROR;
-
+
result = utmscale_toInt64(0, -1, &status);
+ (void)result; /* suppress set but not used warning. */
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);
+ toMin = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV_TO_MIN_VALUE, &status);
+ toMax = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV_TO_MAX_VALUE, &status);
status = U_ZERO_ERROR;
- result = utmscale_toInt64(0, scale, &status);
+ result = utmscale_toInt64(0, (UDateTimeScale)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);
+ result = utmscale_toInt64(toMin, (UDateTimeScale)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);
+ result = utmscale_toInt64(toMin - 1, (UDateTimeScale)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);
+ result = utmscale_toInt64(toMax, (UDateTimeScale)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);
+ result = utmscale_toInt64(toMax + 1, (UDateTimeScale)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) {
{
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);
+ int64_t fromMin = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV_FROM_MIN_VALUE, &status);
+ int64_t fromMax = utmscale_getTimeScaleValue((UDateTimeScale)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);
+
+ roundTripTest(value, (UDateTimeScale)scale);
}
}
}
cal = ucal_open(utc, -1, "", UCAL_GREGORIAN, &errorCode);
ucal_setGregorianChange(cal, -1000000 * (dayMillis * (UDate)1), &errorCode);
if(U_FAILURE(errorCode)) {
- log_err("ucal_open(UTC/proleptic Gregorian) failed: %s\n", u_errorName(errorCode));
+ log_data_err("ucal_open(UTC/proleptic Gregorian) failed: %s - (Are you missing data?)\n", u_errorName(errorCode));
ucal_close(cal);
return;
}
- for(i = 0; i < LENGTHOF(dotNetDateTimeTicks); ++i) {
+ for(i = 0; i < UPRV_LENGTHOF(dotNetDateTimeTicks); ++i) {
/* Test conversion from .Net/Universal time to ICU time. */
dt = dotNetDateTimeTicks + i;
millis = utmscale_toInt64(dt->ticks, UDTS_ICU4C_TIME, &errorCode);
projects / apple / icu.git / blobdiff