[apple/icu.git] / icuSources / test / cintltst / utmstest.c

/*
 ****************************************************************************
 * 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 */
Commit	Line	Data
374ca955 A	1	/*
	2	****************************************************************************
	3	* Copyright (c) 1997-2004, 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
	14	#include "cintltst.h"
	15
	16	#include <stdlib.h>
	17	#include <time.h>
	18
	19	#define LOOP_COUNT 10000
	20
	21	static void TestAPI(void);
	22	static void TestData(void);
	23	static void TestMonkey(void);
	24
	25	void addUtmsTest(TestNode** root);
	26
	27	void addUtmsTest(TestNode** root)
	28	{
	29	addTest(root, &TestAPI, "tsformat/utmstest/TestAPI");
	30	addTest(root, &TestData, "tsformat/utmstest/TestData");
	31	addTest(root, &TestMonkey, "tsformat/utmstest/TestMonkey");
	32	}
	33
	34	/**
	35	* Return a random int64_t where U_INT64_MIN <= ran <= U_INT64_MAX.
	36	*/
	37	static uint64_t randomInt64(void)
	38	{
	39	int64_t ran = 0;
	40	int32_t i;
	41	static UBool initialized = FALSE;
	42
	43	if (!initialized) {
	44	srand((unsigned)time(NULL));
	45	initialized = TRUE;
	46	}
	47
	48	/* Assume rand has at least 12 bits of precision */
	49	for (i = 0; i < sizeof(ran); i += 1) {
	50	((char*)&ran)[i] = (char)((rand() & 0x0FF0) >> 4);
	51	}
	52
	53	return ran;
	54	}
	55
	56	static int64_t ranInt;
	57	static int64_t ranMin;
	58	static int64_t ranMax;
	59
	60	static void initRandom(int64_t min, int64_t max)
	61	{
	62	uint64_t interval = max - min;
	63
	64	ranMin = min;
65	ranMax = max;
66	ranInt = 0;
67
68	if (interval < U_INT64_MIN) {
69	ranInt = interval;
70	}
71	}
72
73	static int64_t randomInRange(void)
74	{
75	int64_t value;
76
77	if (ranInt != 0) {
78	value = randomInt64() % ranInt;
79
80	if (value < 0) {
81	value = -value;
82	}
83
84	value += ranMin;
85	} else {
86	do {
87	value = randomInt64();
88	} while (value < ranMin \|\| value > ranMax);
89	}
90
91	return value;
92	}
93
94	static void roundTripTest(int64_t value, int32_t scale)
95	{
96	UErrorCode status = U_ZERO_ERROR;
97	int64_t rt = utmscale_toInt64(utmscale_fromInt64(value, scale, &status), scale, &status);
98
99	if (rt != value) {
100	log_err("Round-trip error: time scale = %d, value = %lld, round-trip = %lld.\n", scale, value, rt);
101	}
102	}
103
104	static void toLimitTest(int64_t toLimit, int64_t fromLimit, int32_t scale)
105	{
106	UErrorCode status = U_ZERO_ERROR;
107	int64_t result = utmscale_toInt64(toLimit, scale, &status);
108
109	if (result != fromLimit) {
110	log_err("toLimit failure: scale = %d, toLimit = %lld , utmscale_toInt64(toLimit, scale, &status) = %lld, fromLimit = %lld.\n",
111	scale, toLimit, result, fromLimit);
112	}
113	}
114
115	static void epochOffsetTest(int64_t epochOffset, int64_t units, int32_t scale)
116	{
117	UErrorCode status = U_ZERO_ERROR;
118	int64_t universal = 0;
119	int64_t universalEpoch = epochOffset * units;
120	int64_t local = utmscale_toInt64(universalEpoch, scale, &status);
121
122	if (local != 0) {
123	log_err("utmscale_toInt64(epochOffset, scale, &status): scale = %d epochOffset = %lld, result = %lld.\n", scale, epochOffset, local);
124	}
125
126	local = utmscale_toInt64(0, scale, &status);
127
128	if (local != -epochOffset) {
129	log_err("utmscale_toInt64(0, scale): scale = %d, result = %lld.\n", scale, local);
130	}
131
132	universal = utmscale_fromInt64(-epochOffset, scale, &status);
133
134	if (universal != 0) {
135	log_err("from(-epochOffest, scale): scale = %d, epochOffset = %lld, result = %lld.\n", scale, epochOffset, universal);
136	}
137
138	universal = utmscale_fromInt64(0, scale, &status);
139
140	if (universal != universalEpoch) {
141	log_err("utmscale_fromInt64(0, scale): scale = %d, result = %lld.\n", scale, universal);
142	}
143	}
144
145	static void TestEpochOffsets(void)
146	{
147	UErrorCode status = U_ZERO_ERROR;
148	int32_t scale;
149
150	for (scale = 0; scale < UDTS_MAX_SCALE; scale += 1) {
151	int64_t units = utmscale_getTimeScaleValue(scale, UTSV_UNITS_VALUE, &status);
152	int64_t epochOffset = utmscale_getTimeScaleValue(scale, UTSV_EPOCH_OFFSET_VALUE, &status);
153
154	epochOffsetTest(epochOffset, units, scale);
155	}
156	}
157
158	static void TestFromLimits(void)
159	{
160	UErrorCode status = U_ZERO_ERROR;
161	int32_t scale;
162
163	for (scale = 0; scale < UDTS_MAX_SCALE; scale += 1) {
164	int64_t fromMin = utmscale_getTimeScaleValue(scale, UTSV_FROM_MIN_VALUE, &status);
165	int64_t fromMax = utmscale_getTimeScaleValue(scale, UTSV_FROM_MAX_VALUE, &status);
166
167	roundTripTest(fromMin, scale);
168	roundTripTest(fromMax, scale);
169	}
170	}
171
172	static void TestToLimits(void)
173	{
174	UErrorCode status = U_ZERO_ERROR;
175	int32_t scale;
176
177	for (scale = 0; scale < UDTS_MAX_SCALE; scale += 1) {
178	int64_t fromMin = utmscale_getTimeScaleValue(scale, UTSV_FROM_MIN_VALUE, &status);
179	int64_t fromMax = utmscale_getTimeScaleValue(scale, UTSV_FROM_MAX_VALUE, &status);
180	int64_t toMin = utmscale_getTimeScaleValue(scale, UTSV_TO_MIN_VALUE, &status);
181	int64_t toMax = utmscale_getTimeScaleValue(scale, UTSV_TO_MAX_VALUE, &status);
182
183	toLimitTest(toMin, fromMin, scale);
184	toLimitTest(toMax, fromMax, scale);
185	}
186	}
187
188	static void TestFromInt64(void)
189	{
190	int32_t scale;
191	int64_t result;
192	UErrorCode status = U_ZERO_ERROR;
193
194	result = utmscale_fromInt64(0, -1, &status);
195	if (status != U_ILLEGAL_ARGUMENT_ERROR) {
196	log_err("utmscale_fromInt64(0, -1, status) did not set status to U_ILLEGAL_ARGUMENT_ERROR.\n");
197	}
198
199	for (scale = 0; scale < UDTS_MAX_SCALE; scale += 1) {
200	int64_t fromMin, fromMax;
201
202	status = U_ZERO_ERROR;
203	fromMin = utmscale_getTimeScaleValue(scale, UTSV_FROM_MIN_VALUE, &status);
204	fromMax = utmscale_getTimeScaleValue(scale, UTSV_FROM_MAX_VALUE, &status);
205
206	status = U_ZERO_ERROR;
207	result = utmscale_fromInt64(0, scale, &status);
208	if (status == U_ILLEGAL_ARGUMENT_ERROR) {
209	log_err("utmscale_fromInt64(0, %d, &status) generated U_ILLEGAL_ARGUMENT_ERROR.\n", scale);
210	}
211
212	status = U_ZERO_ERROR;
213	result = utmscale_fromInt64(fromMin, scale, &status);
214	if (status == U_ILLEGAL_ARGUMENT_ERROR) {
215	log_err("utmscale_fromInt64(fromMin, %d, &status) generated U_ILLEGAL_ARGUMENT_ERROR.\n", scale);
216	}
217
218	if (fromMin > U_INT64_MIN) {
219	status = U_ZERO_ERROR;
220	result = utmscale_fromInt64(fromMin - 1, scale, &status);
221	if (status != U_ILLEGAL_ARGUMENT_ERROR) {
222	log_err("utmscale_fromInt64(fromMin - 1, %d, &status) did not generate U_ILLEGAL_ARGUMENT_ERROR.\n", scale);
223	}
224	}
225
226	status = U_ZERO_ERROR;
227	result = utmscale_fromInt64(fromMax, scale, &status);
228	if (status == U_ILLEGAL_ARGUMENT_ERROR) {
229	log_err("utmscale_fromInt64(fromMax, %d, &status) generated U_ILLEGAL_ARGUMENT_ERROR.\n", scale);
230	}
231
232	if (fromMax < U_INT64_MAX) {
233	status = U_ZERO_ERROR;
234	result = utmscale_fromInt64(fromMax + 1, scale, &status);
235	if (status != U_ILLEGAL_ARGUMENT_ERROR) {
236	log_err("utmscale_fromInt64(fromMax + 1, %d, &status) didn't generate U_ILLEGAL_ARGUMENT_ERROR.\n", scale);
237	}
238	}
239	}
240
241	status = U_ZERO_ERROR;
242	result = utmscale_fromInt64(0, UDTS_MAX_SCALE, &status);
243	if (status != U_ILLEGAL_ARGUMENT_ERROR) {
244	log_err("utmscale_fromInt64(0, UDTS_MAX_SCALE, &status) did not generate U_ILLEGAL_ARGUMENT_ERROR.\n");
245	}
246	}
247
248	static void TestToInt64(void)
249	{
250	int32_t scale;
251	int64_t result;
252	UErrorCode status = U_ZERO_ERROR;
253
254	result = utmscale_toInt64(0, -1, &status);
255	if (status != U_ILLEGAL_ARGUMENT_ERROR) {
256	log_err("utmscale_toInt64(0, -1, &status) did not generate U_ILLEGAL_ARGUMENT_ERROR.\n");
257	}
258
259	for (scale = 0; scale < UDTS_MAX_SCALE; scale += 1) {
260	int64_t toMin, toMax;
261
262	status = U_ZERO_ERROR;
263	toMin = utmscale_getTimeScaleValue(scale, UTSV_TO_MIN_VALUE, &status);
264	toMax = utmscale_getTimeScaleValue(scale, UTSV_TO_MAX_VALUE, &status);
265
266	status = U_ZERO_ERROR;
267	result = utmscale_toInt64(0, scale, &status);
268	if (status == U_ILLEGAL_ARGUMENT_ERROR) {
269	log_err("utmscale_toInt64(0, %d, &status) generated U_ILLEGAL_ARGUMENT_ERROR.\n", scale);
270	}
271
272	status = U_ZERO_ERROR;
273	result = utmscale_toInt64(toMin, scale, &status);
274	if (status == U_ILLEGAL_ARGUMENT_ERROR) {
275	log_err("utmscale_toInt64(toMin, %d, &status) generated U_ILLEGAL_ARGUMENT_ERROR.\n", scale);
276	}
277
278	if (toMin > U_INT64_MIN) {
279	status = U_ZERO_ERROR;
280	result = utmscale_toInt64(toMin - 1, scale, &status);
281	if (status != U_ILLEGAL_ARGUMENT_ERROR) {
282	log_err("utmscale_toInt64(toMin - 1, %d, &status) did not generate U_ILLEGAL_ARGUMENT_ERROR.\n", scale);
283	}
284	}
285
286
287	status = U_ZERO_ERROR;
288	result = utmscale_toInt64(toMax, scale, &status);
289	if (status == U_ILLEGAL_ARGUMENT_ERROR) {
290	log_err("utmscale_toInt64(toMax, %d, &status) generated U_ILLEGAL_ARGUMENT_ERROR.\n", scale);
291	}
292
293	if (toMax < U_INT64_MAX) {
294	status = U_ZERO_ERROR;
295	result = utmscale_toInt64(toMax + 1, scale, &status);
296	if (status != U_ILLEGAL_ARGUMENT_ERROR) {
297	log_err("utmscale_toInt64(toMax + 1, %d, &status) did not generate U_ILLEGAL_ARGUMENT_ERROR.\n", scale);
298	}
299	}
300	}
301
302	status = U_ZERO_ERROR;
303	result = utmscale_toInt64(0, UDTS_MAX_SCALE, &status);
304	if (status != U_ILLEGAL_ARGUMENT_ERROR) {
305	log_err("utmscale_toInt64(0, UDTS_MAX_SCALE, &status) did not generate U_ILLEGAL_ARGUMENT_ERROR.\n");
306	}
307	}
308
309	static void TestAPI(void)
310	{
311	TestFromInt64();
312	TestToInt64();
313	}
314
315	static void TestData(void)
316	{
317	TestEpochOffsets();
318	TestFromLimits();
319	TestToLimits();
320	}
321
322	static void TestMonkey(void)
323	{
324	int32_t scale;
325	UErrorCode status = U_ZERO_ERROR;
326
327	for (scale = 0; scale < UDTS_MAX_SCALE; scale += 1) {
328	int64_t fromMin = utmscale_getTimeScaleValue(scale, UTSV_FROM_MIN_VALUE, &status);
329	int64_t fromMax = utmscale_getTimeScaleValue(scale, UTSV_FROM_MAX_VALUE, &status);
330	int32_t i;
331
332	initRandom(fromMin, fromMax);
333
334	for (i = 0; i < LOOP_COUNT; i += 1) {
335	int64_t value = randomInRange();
336
337	roundTripTest(value, scale);
338	}
339	}
340	}
341
342	#endif /* #if !UCONFIG_NO_FORMATTING */