示例#1
0
static void TestFromInt64(void)
{
    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((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, (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, (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) {
            status = U_ZERO_ERROR;
            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, (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, (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) {
        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((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, (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, (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, (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, (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, (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) {
        log_err("utmscale_toInt64(0, UDTS_MAX_SCALE, &status) did not generate U_ILLEGAL_ARGUMENT_ERROR.\n");
    }
}
示例#3
0
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((UDateTimeScale)scale, UTSV_UNITS_VALUE, &status);
        int64_t epochOffset = utmscale_getTimeScaleValue((UDateTimeScale)scale, UTSV_EPOCH_OFFSET_VALUE, &status);

        epochOffsetTest(epochOffset, units, (UDateTimeScale)scale);
    }
}
示例#4
0
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((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);
    }
}
示例#5
0
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((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, (UDateTimeScale)scale);
        }
    }
}