Debian Codegraph @

src/test-arith.c

raw
1 /*
2 * Test the lowest-level numeric routines.
3 */
4
5 #include "gauche.h"
6 #include "gauche/priv/configP.h"
7 #include "gauche/priv/arith.h"
8 #include "gauche/scmconst.h"
9
10 #define UMAX SCM_ULONG_MAX
11 #define SMAX LONG_MAX
12 #define SMIN LONG_MIN
13
14 int errcount = 0;
15
16 void message(FILE *out, const char *m, int filler)
17 {
18 int i;
19 fprintf(out, "%s", m);
20 if (filler) {
21 int len = 79 - (int)strlen(m);
22 if (len < 0) len = 5;
23 for (i=0; i<len; i++) putc(filler, out);
24 }
25 putc('\n', out);
26 }
27
28 /*=============================================================
29 * Testing macros in gauche/priv/arith.h
30 */
31
32 #define TEST_SECTION(name) message(stdout, "<" name ">", '-')
33
34 #define TEST5(x_, y_, c_, rexp, cexp, numfmt, opmsg, op) \
35 do { \
36 printf("testing " numfmt opmsg numfmt " c=" numfmt \
37 " expects r=" numfmt ", c=" numfmt " =>", \
38 x_, y_, c_, rexp, cexp); \
39 c = c_; \
40 x = x_; \
41 y = y_; \
42 op(r, c, x, y); \
43 if (r == rexp && c == cexp) { \
44 printf("ok\n"); \
45 } else { \
46 errcount++; \
47 printf("ERROR: got r=" numfmt \
48 ", c=" numfmt "\n", r, c); \
49 } \
50 } while (0)
51
52 #define TESTOV(x_, y_, rexp, cexp, numfmt, opmsg, op) \
53 do { \
54 x = x_; \
55 y = y_; \
56 if (cexp) \
57 printf("testing " numfmt opmsg numfmt \
58 " expects overflow =>", x_, y_); \
59 else \
60 printf("testing " numfmt opmsg numfmt \
61 " expects " numfmt " =>", x_, y_, rexp); \
62 op(r, c, x, y); \
63 if (c) { \
64 if (cexp == c) printf("ok\n"); \
65 else { \
66 errcount++; \
67 printf("ERROR: got r=" numfmt \
68 ", c=" numfmt "\n", r, c); \
69 } \
70 } else { \
71 if (r == rexp) printf("ok\n"); \
72 else { \
73 errcount++; \
74 printf("ERROR: got r=" numfmt "\n", r); \
75 } \
76 } \
77 } while (0)
78
79 /*
80 * UADD
81 */
82 #define TEST_UADD(x_, y_, c_, rexp, cexp) \
83 TEST5(x_, y_, c_, rexp, cexp, "%lu", "+", UADD)
84
85 void test_uadd(void)
86 {
87 u_long r, c, x, y;
88 TEST_SECTION("UADD");
89
90 /* MAX + 0 + 0 => [MAX, 0] */
91 TEST_UADD(UMAX, 0UL, 0UL, UMAX, 0UL);
92 /* MAX + 1 + 0 => [0, 1] */
93 TEST_UADD(UMAX, 1UL, 0UL, 0UL, 1UL);
94 /* MAX + 2 + 0 => [1, 1] */
95 TEST_UADD(UMAX, 2UL, 0UL, 1UL, 1UL);
96 /* MAX + MAX + 0 => [MAX-1, 1] */
97 TEST_UADD(UMAX, UMAX, 0UL, UMAX-1, 1UL);
98 /* MAX/2 + MAX/2 + 0 => [MAX-1, 0] */
99 TEST_UADD(UMAX/2, UMAX/2, 0UL, UMAX-1, 0UL);
100 /* MAX/2 + MAX + 0 => [MAX/2-1, 1] */
101 TEST_UADD(UMAX/2, UMAX, 0UL, UMAX/2-1, 1UL);
102 /* MAX-1 + 0 + 1 => [MAX, 0] */
103 TEST_UADD(UMAX-1, 0UL, 1UL, UMAX, 0UL);
104 /* MAX + 0 + 1 => [0, 1] */
105 TEST_UADD(UMAX, 0UL, 1UL, 0UL, 1UL);
106 /* MAX + 1 + 1 => [1, 1] */
107 TEST_UADD(UMAX, 1UL, 1UL, 1UL, 1UL);
108 /* MAX + MAX + 1 => [MAX, 1] */
109 TEST_UADD(UMAX, UMAX, 1UL, UMAX, 1UL);
110 /* MAX/2 + MAX/2 + 1 => [MAX, 0] */
111 TEST_UADD(UMAX/2, UMAX/2, 1UL, UMAX, 0UL);
112 /* MAX/2 + MAX + 1 => [MAX/2, 1] */
113 TEST_UADD(UMAX/2, UMAX, 1UL, UMAX/2, 1UL);
114 }
115
116 /*
117 * UADDOV
118 */
119 #define TEST_UADDOV(x_, y_, rexp, cexp) \
120 TESTOV(x_, y_, rexp, cexp, "%lu", "+", UADDOV)
121
122 void test_uaddov(void)
123 {
124 u_long r, c, x, y;
125 TEST_SECTION("UADDOV");
126
127 /* MAX + 0 => MAX */
128 TEST_UADDOV(UMAX, 0UL, UMAX, 0UL);
129 /* MAX + 1 => overflow */
130 TEST_UADDOV(UMAX, 1UL, 0UL, 1UL);
131 /* MAX + 2 => overflow */
132 TEST_UADDOV(UMAX, 2UL, 0UL, 1UL);
133 /* MAX + MAX => overflow */
134 TEST_UADDOV(UMAX, UMAX, 0UL, 1UL);
135 /* MAX/2 + MAX/2 => MAX-1, 0 */
136 TEST_UADDOV(UMAX/2, UMAX/2, UMAX-1, 0UL);
137 /* MAX/2 + MAX => overflow */
138 TEST_UADDOV(UMAX/2, UMAX, 0UL, 1UL);
139 /* MAX-1 + 1 => MAX */
140 TEST_UADDOV(UMAX-1, 1UL, UMAX, 0UL);
141 /* MAX-1 + 2 => overflow */
142 TEST_UADDOV(UMAX-1, 2UL, 0UL, 1UL);
143 }
144
145 /*
146 * SADDOV
147 */
148 #define TEST_SADDOV(x_, y_, rexp, cexp) \
149 TESTOV(x_, y_, rexp, cexp, "%ld", "+", SADDOV)
150
151 void test_saddov(void)
152 {
153 long r, c, x, y;
154 TEST_SECTION("SADDOV");
155
156 /* 1 + 1 => 2 */
157 TEST_SADDOV(1L, 1L, 2L, 0L);
158 /* -1 + -1 => -2 */
159 TEST_SADDOV(-1L, -1L, -2L, 0L);
160 /* SMAX + 0 => SMAX */
161 TEST_SADDOV(SMAX, 0L, SMAX, 0L);
162 /* SMAX + 1 => overflow */
163 TEST_SADDOV(SMAX, 1L, 0L, 1L);
164 /* SMAX + 2 => overflow */
165 TEST_SADDOV(SMAX, 2L, 0L, 1L);
166 /* SMAX + -1 => SMAX-1 */
167 TEST_SADDOV(SMAX, -1L, SMAX-1, 0L);
168 /* SMAX + -SMAX => 0 */
169 TEST_SADDOV(SMAX, -SMAX, 0L, 0L);
170 /* SMAX + -SMAX-1 => -1 */
171 TEST_SADDOV(SMAX, -SMAX-1, -1L, 0L);
172 /* SMAX/2 + SMAX/2 => SMAX-1 */
173 TEST_SADDOV(SMAX/2, SMAX/2, SMAX-1, 0L);
174 /* SMAX/2 + -SMAX/2 => 0 */
175 TEST_SADDOV(SMAX/2, -(SMAX/2), 0L, 0L);
176 /* -SMAX/2 + -SMAX/2 => -(SMAX-1) */
177 TEST_SADDOV(-(SMAX/2), -(SMAX/2), -(SMAX-1), 0L);
178 /* 0 + -SMAX => -SMAX */
179 TEST_SADDOV(0L, -SMAX, -SMAX, 0L);
180 /* -1 + -SMAX => SMIN */
181 TEST_SADDOV(-1L, -SMAX, SMIN, 0L);
182 /* -2 + -SMAX => -overflow */
183 TEST_SADDOV(-2L, -SMAX, 0L, -1L);
184 /* -SMAX + -2 => -overflow */
185 TEST_SADDOV(-SMAX, -2L, 0L, -1L);
186 /* -SMAX + -SMAX => -overflow */
187 TEST_SADDOV(-SMAX, -SMAX, 0L, -1L);
188 /* -SMAX + SMIN => -overflow */
189 TEST_SADDOV(-SMAX, SMIN, 0L, -1L);
190 }
191
192 /*
193 * USUB
194 */
195 #define TEST_USUB(x_, y_, c_, rexp, cexp) \
196 TEST5(x_, y_, c_, rexp, cexp, "%lu", "-", USUB)
197
198 void test_usub(void)
199 {
200 u_long r, c, x, y;
201 TEST_SECTION("USUB");
202
203 /* MAX - 0 - 0 => [MAX, 0] */
204 TEST_USUB(UMAX, 0UL, 0UL, UMAX, 0UL);
205 /* MAX - 1 - 0 => [MAX-1, 0] */
206 TEST_USUB(UMAX, 1UL, 0UL, UMAX-1, 0UL);
207 /* 0 - MAX - 0 => [1, 1] */
208 TEST_USUB(0UL, UMAX, 0UL, 1UL, 1UL);
209 /* 1 - MAX - 0 => [2, 1] */
210 TEST_USUB(1UL, UMAX, 0UL, 2UL, 1UL);
211 /* MAX - MAX/2 - 0 => [MAX/2+1, 0] */
212 TEST_USUB(UMAX, UMAX/2, 0UL, UMAX/2+1, 0UL);
213 /* MAX/2 - MAX - 0 => [MAX/2+1, 1] */
214 TEST_USUB(UMAX/2, UMAX, 0UL, UMAX/2+1, 1UL);
215 /* MAX - 0 - 1 => [MAX-1, 0] */
216 TEST_USUB(UMAX, 0UL, 1UL, UMAX-1, 0UL);
217 /* MAX - 1 - 1 => [MAX-2, 0] */
218 TEST_USUB(UMAX, 1UL, 1UL, UMAX-2, 0UL);
219 /* 0 - MAX - 1 => [0, 1] */
220 TEST_USUB(0UL, UMAX, 1UL, 0UL, 1UL);
221 /* 1 - MAX - 1 => [1, 1] */
222 TEST_USUB(1UL, UMAX, 1UL, 1UL, 1UL);
223 /* MAX - MAX/2 - 1 => [MAX/2, 0] */
224 TEST_USUB(UMAX, UMAX/2, 1UL, UMAX/2, 0UL);
225 /* MAX/2 - MAX - 1 => [MAX/2, 1] */
226 TEST_USUB(UMAX/2, UMAX, 1UL, UMAX/2, 1UL);
227 }
228
229 /*
230 * USUBOV
231 */
232 #define TEST_USUBOV(x_, y_, rexp, cexp) \
233 TESTOV(x_, y_, rexp, cexp, "%lu", "-", USUBOV)
234
235 void test_usubov(void)
236 {
237 u_long r, c, x, y;
238 TEST_SECTION("USUBOV");
239
240 /* MAX - 0 => MAX */
241 TEST_USUBOV(UMAX, 0UL, UMAX, 0UL);
242 /* MAX - 1 => MAX-1 */
243 TEST_USUBOV(UMAX, 1UL, UMAX-1, 0UL);
244 /* MAX - MAX => 0 */
245 TEST_USUBOV(UMAX, UMAX, 0UL, 0UL);
246 /* MAX-1 - MAX => overflow */
247 TEST_USUBOV(UMAX-1, UMAX, 0UL, 1UL);
248 /* MAX - MAX-1 => 1 */
249 TEST_USUBOV(UMAX, UMAX-1, 1UL, 0UL);
250 /* 0 - 1 => overflow */
251 TEST_USUBOV(0UL, 1UL, 0UL, 1UL);
252 /* 0 - MAX => overflow */
253 TEST_USUBOV(0UL, UMAX, 0UL, 1UL);
254 }
255
256 /*
257 * SSUBOV
258 */
259 #define TEST_SSUBOV(x_, y_, rexp, cexp) \
260 TESTOV(x_, y_, rexp, cexp, "%ld", "-", SSUBOV)
261
262 void test_ssubov(void)
263 {
264 long r, c, x, y;
265 TEST_SECTION("SSUBOV");
266
267 /* 1 - 1 => 0 */
268 TEST_SSUBOV(1L, 1L, 0L, 0L);
269 /* -1 - -1 => 0 */
270 TEST_SSUBOV(-1L, -1L, 0L, 0L);
271 /* SMAX - 0 => SMAX */
272 TEST_SSUBOV(SMAX, 0L, SMAX, 0L);
273 /* SMAX - 1 => SMAX-1 */
274 TEST_SSUBOV(SMAX, 1L, SMAX-1, 0L);
275 /* SMAX - -1 => overflow */
276 TEST_SSUBOV(SMAX, -1L, 0L, 1L);
277 /* SMAX - -2 => overflow */
278 TEST_SSUBOV(SMAX, -2L, 0L, 1L);
279 /* SMAX - -SMAX => overflow */
280 TEST_SSUBOV(SMAX, -SMAX, 0L, 1L);
281 /* SMAX - SMAX => 0 */
282 TEST_SSUBOV(SMAX, SMAX, 0L, 0L);
283 /* SMAX/2 - -SMAX/2 => SMAX-1 */
284 TEST_SSUBOV(SMAX/2, -(SMAX/2), SMAX-1, 0L);
285 /* SMAX/2 - SMAX/2 => 0 */
286 TEST_SSUBOV(SMAX/2, SMAX/2, 0L, 0L);
287 /* -SMAX/2 - SMAX/2 => 0 */
288 TEST_SSUBOV(-(SMAX/2), SMAX/2, -(SMAX-1), 0L);
289 /* 0 - -SMAX => SMAX */
290 TEST_SSUBOV(0L, -SMAX, SMAX, 0L);
291 /* 1 - -SMAX => overflow */
292 TEST_SSUBOV(1L, -SMAX, 0L, 1L);
293 /* 0 - -SMAX => SMAX */
294 TEST_SSUBOV(0L, -SMAX, SMAX, 0L);
295 /* SMIN - 1 => -overflow */
296 TEST_SSUBOV(SMIN, 1L, 0L, -1L);
297 /* SMIN - -1 => SMIN+1 */
298 TEST_SSUBOV(SMIN, -1L, SMIN+1, 0L);
299 /* -SMAX - -SMAX => 0 */
300 TEST_SSUBOV(-SMAX, -SMAX, 0L, 0L);
301 /* -SMAX - SMIN => 1 */
302 TEST_SSUBOV(-SMAX, SMIN, 1L, 0L);
303 }
304
305 /*
306 * UMUL
307 */
308 #define TEST_UMUL(x_, y_, hiexp, loexp) \
309 do { \
310 printf("testing %lu*%lu expects hi=%lu, lo=%lu =>", x_, y_, \
311 hiexp, loexp); \
312 x = x_; \
313 y = y_; \
314 UMUL(hi, lo, x, y); \
315 if (hi == hiexp && lo == loexp) { \
316 printf("ok\n"); \
317 } else { \
318 errcount++; \
319 printf("ERROR: got hi=%lu, lo=%lu\n", hi, lo); \
320 } \
321 } while (0)
322
323 void test_umul(void)
324 {
325 u_long hi, lo, x, y;
326 TEST_SECTION("UMUL");
327
328 /* MAX * MAX => [MAX-1, 1] */
329 TEST_UMUL(UMAX, UMAX, UMAX-1, 1UL);
330 /* MAX-1 * MAX-1 => [MAX-3, 4] */
331 TEST_UMUL(UMAX-1, UMAX-1, UMAX-3, 4UL);
332 /* MAX/2 * 2 => [0, MAX-1] */
333 TEST_UMUL(UMAX/2, 2UL, 0UL, UMAX-1);
334 /* MAX/2+1 * 2 => [1, 0] */
335 TEST_UMUL(UMAX/2+1, 2UL, 1UL, 0UL);
336 }
337
338 /*
339 * UMULOV
340 */
341 #define TEST_UMULOV(x_, y_, rexp, cexp) \
342 TESTOV(x_, y_, rexp, cexp, "%lu", "*", UMULOV)
343
344 void test_umulov(void)
345 {
346 u_long r, c, x, y;
347 TEST_SECTION("UMULOV");
348
349 /* 0 * 1 => 0 */
350 TEST_UMULOV(0UL, 1UL, 0UL, 0UL);
351 /* 1 * 0 => 0 */
352 TEST_UMULOV(1UL, 0UL, 0UL, 0UL);
353 /* 1 * 1 => 1 */
354 TEST_UMULOV(1UL, 1UL, 1UL, 0UL);
355 /* 1 * UMAX => UMAX */
356 TEST_UMULOV(1UL, UMAX, UMAX, 0UL);
357 /* 2 * UMAX => overflow */
358 TEST_UMULOV(2UL, UMAX, 0UL, 1UL);
359 /* UMAX/2 * 2 => UMAX-1 */
360 TEST_UMULOV(UMAX/2, 2UL, UMAX-1, 0UL);
361 /* UMAX/2 * 3 => overflow */
362 TEST_UMULOV(UMAX/2, 3UL, 0UL, 1UL);
363 /* UMAX>>4 * UMAX>>4 => overflow */
364 TEST_UMULOV((UMAX>>4), (UMAX>>4), 0UL, 1UL);
365 /* UMAX>>8 * UMAX>>8 => overflow */
366 TEST_UMULOV((UMAX>>8), (UMAX>>8), 0UL, 1UL);
367 /* UMAX * UMAX => overflow */
368 TEST_UMULOV(UMAX, UMAX, 0UL, 1UL);
369 /* UMAX-1 * UMAX-1 => overflow */
370 TEST_UMULOV(UMAX-1, UMAX-1, 0UL, 1UL);
371 }
372
373 /*
374 * SMULOV
375 */
376 #define TEST_SMULOV(x_, y_, rexp, cexp) \
377 TESTOV(x_, y_, rexp, cexp, "%ld", "*", SMULOV)
378
379 void test_smulov(void)
380 {
381 long r = 0, c, x, y;
382 TEST_SECTION("SMULOV");
383
384 /* 0 * 1 => 0 */
385 TEST_SMULOV(0L, 1L, 0L, 0L);
386 /* 1 * 0 => 0 */
387 TEST_SMULOV(1L, 0L, 0L, 0L);
388 /* 1 * 1 => 1 */
389 TEST_SMULOV(1L, 1L, 1L, 0L);
390 /* 1 * -1 => -1 */
391 TEST_SMULOV(1L, -1L, -1L, 0L);
392 /* -1 * 1 => -1 */
393 TEST_SMULOV(-1L, 1L, -1L, 0L);
394 /* -1 * -1 => 1 */
395 TEST_SMULOV(-1L, -1L, 1L, 0L);
396 /* 1 * SMAX => SMAX */
397 TEST_SMULOV(1L, SMAX, SMAX, 0L);
398 /* 1 * -SMAX => -SMAX */
399 TEST_SMULOV(1L, -SMAX, -SMAX, 0L);
400 /* -1 * SMAX => -SMAX */
401 TEST_SMULOV(-1L, SMAX, -SMAX, 0L);
402 /* -1 * -SMAX => SMAX */
403 TEST_SMULOV(-1L, -SMAX, SMAX, 0L);
404 /* 1 * SMIN => SMIN */
405 TEST_SMULOV(1L, SMIN, SMIN, 0L);
406 /* -1 * SMIN => overflow */
407 TEST_SMULOV(-1L, SMIN, 0L, 1L);
408 /* 2 * SMAX => overflow */
409 TEST_SMULOV(2L, SMAX, 0L, 1L);
410 /* 2 * -SMAX => -overflow */
411 TEST_SMULOV(2L, -SMAX, 0L, -1L);
412 /* -2 * SMAX => -overflow */
413 TEST_SMULOV(-2L, SMAX, 0L, -1L);
414 /* -2 * -SMAX => overflow */
415 TEST_SMULOV(-2L, -SMAX, 0L, 1L);
416 /* SMAX/2 * 2 => SMAX-1 */
417 TEST_SMULOV(SMAX/2, 2L, SMAX-1, 0L);
418 /* SMAX/2 * -2 => -(SMAX-1) */
419 TEST_SMULOV(SMAX/2, -2L, -(SMAX-1), 0L);
420 /* -SMAX/2 * 2 => -(SMAX-1) */
421 TEST_SMULOV(-(SMAX/2), 2L, -(SMAX-1), 0L);
422 /* -SMAX/2 * -2 => SMAX-1 */
423 TEST_SMULOV(-(SMAX/2), -2L, SMAX-1, 0L);
424 /* SMAX/2+1 * 2 => overflow */
425 TEST_SMULOV(SMAX/2+1, 2L, 0L, 1L);
426 /* SMAX/2+1 * -2 => SMIN */
427 TEST_SMULOV(SMAX/2+1, -2L, SMIN, 0L);
428 /* -(SMAX/2+1) * 2 => SMIN */
429 TEST_SMULOV(-(SMAX/2+1), 2L, SMIN, 0L);
430 /* -(SMAX/2+1) * -2 => overflow */
431 TEST_SMULOV(-(SMAX/2+1), -2L, 0L, 1L);
432 /* SMAX>>4 * SMAX>>4 => overflow */
433 TEST_SMULOV((SMAX>>4), (SMAX>>4), 0L, 1L);
434 /* SMAX>>4 * -SMAX>>4 => -overflow */
435 TEST_SMULOV((SMAX>>4), -(SMAX>>4), 0L, -1L);
436 /* -SMAX>>4 * SMAX>>4 => -overflow */
437 TEST_SMULOV(-(SMAX>>4), (SMAX>>4), 0L, -1L);
438 /* -SMAX>>4 * -SMAX>>4 => overflow */
439 TEST_SMULOV(-(SMAX>>4), -(SMAX>>4), 0L, 1L);
440 /* SMAX>>8 * SMAX>>8 => overflow */
441 TEST_SMULOV((SMAX>>8), (SMAX>>8), 0L, 1L);
442 /* SMAX>>8 * -SMAX>>8 => -overflow */
443 TEST_SMULOV((SMAX>>8), -(SMAX>>8), 0L, -1L);
444 /* -SMAX>>8 * SMAX>>8 => -overflow */
445 TEST_SMULOV(-(SMAX>>8), (SMAX>>8), 0L, -1L);
446 /* -SMAX>>8 * -SMAX>>8 => overflow */
447 TEST_SMULOV(-(SMAX>>8), -(SMAX>>8), 0L, 1L);
448 /* SMAX * SMAX => overflow */
449 TEST_SMULOV(SMAX, SMAX, 0L, 1L);
450 /* SMAX * -SMAX => -overflow */
451 TEST_SMULOV(SMAX, -SMAX, 0L, -1L);
452 /* -SMAX * SMAX => -overflow */
453 TEST_SMULOV(-SMAX, SMAX, 0L, -1L);
454 /* -SMAX * -SMAX => overflow */
455 TEST_SMULOV(-SMAX, -SMAX, 0L, 1L);
456 }
457
458 /*=============================================================
459 * Testing 32/64-bit conversion routines
460 */
461
462 void test_scm_c_scm(const char *msg, ScmObj expect, ScmObj val)
463 {
464 Scm_Printf(SCM_CUROUT, "testing %s, expects %S =>", msg, expect);
465 if (Scm_EqualP(expect, val)) {
466 Scm_Printf(SCM_CUROUT, "ok\n");
467 } else {
468 Scm_Printf(SCM_CUROUT, "ERROR: got %S\n", val);
469 errcount++;
470 }
471 }
472
473 void test_true(const char *msg, int val)
474 {
475 Scm_Printf(SCM_CUROUT, "testing %s, expects TRUE =>", msg);
476 if (val) {
477 Scm_Printf(SCM_CUROUT, "ok\n");
478 } else {
479 Scm_Printf(SCM_CUROUT, "ERROR: got %d\n", val);
480 errcount++;
481 }
482 }
483
484
485
486 void test_32_64(void)
487 {
488 ScmObj vv;
489 int oor;
490
491 TEST_SECTION("integer conversions, non clamping");
492
493 vv = Scm_Add(SCM_2_31, SCM_MAKE_INT(-1));
494 test_scm_c_scm("long roundtrip 2^31-1", vv,
495 Scm_MakeInteger(Scm_GetInteger(vv)));
496 vv = Scm_Add(SCM_2_31, SCM_MAKE_INT(-3));
497 test_scm_c_scm("long roundtrip 2^31-3", vv,
498 Scm_MakeInteger(Scm_GetInteger(vv)));
499 vv = Scm_Negate(SCM_2_31);
500 test_scm_c_scm("long roundtrip -2^31", vv,
501 Scm_MakeInteger(Scm_GetInteger(vv)));
502 vv = Scm_Add(Scm_Negate(SCM_2_31), SCM_MAKE_INT(2));
503 test_scm_c_scm("long roundtrip -2^31+2", vv,
504 Scm_MakeInteger(Scm_GetInteger(vv)));
505 #if SIZEOF_LONG >= 8
506 vv = Scm_Add(SCM_2_63, SCM_MAKE_INT(-1));
507 test_scm_c_scm("long roundtrip 2^63-1", vv,
508 Scm_MakeInteger(Scm_GetInteger(vv)));
509 vv = Scm_Add(SCM_2_63, SCM_MAKE_INT(-3));
510 test_scm_c_scm("long roundtrip 2^63-3", vv,
511 Scm_MakeInteger(Scm_GetInteger(vv)));
512 vv = Scm_Negate(SCM_2_63);
513 test_scm_c_scm("long roundtrip -2^63", vv,
514 Scm_MakeInteger(Scm_GetInteger(vv)));
515 vv = Scm_Add(Scm_Negate(SCM_2_63), SCM_MAKE_INT(2));
516 test_scm_c_scm("long roundtrip -2^63+2", vv,
517 Scm_MakeInteger(Scm_GetInteger(vv)));
518 #endif
519 vv = Scm_Add(SCM_2_32, SCM_MAKE_INT(-1));
520 test_scm_c_scm("u_long roundtrip 2^31-1", vv,
521 Scm_MakeIntegerU(Scm_GetIntegerU(vv)));
522 vv = Scm_Add(SCM_2_32, SCM_MAKE_INT(-3));
523 test_scm_c_scm("u_long roundtrip 2^31-3", vv,
524 Scm_MakeIntegerU(Scm_GetIntegerU(vv)));
525 #if SIZEOF_LONG >= 8
526 vv = Scm_Add(SCM_2_64, SCM_MAKE_INT(-1));
527 test_scm_c_scm("u_long roundtrip 2^64-1", vv,
528 Scm_MakeIntegerU(Scm_GetIntegerU(vv)));
529 vv = Scm_Add(SCM_2_64, SCM_MAKE_INT(-3));
530 test_scm_c_scm("u_long roundtrip 2^64-3", vv,
531 Scm_MakeIntegerU(Scm_GetIntegerU(vv)));
532 #endif
533
534 vv = Scm_Add(SCM_2_31, SCM_MAKE_INT(-1));
535 test_scm_c_scm("int32_t roundtrip 2^31-1", vv,
536 Scm_MakeInteger(Scm_GetInteger32Clamp(vv, 0, NULL)));
537 vv = Scm_Add(SCM_2_31, SCM_MAKE_INT(-3));
538 test_scm_c_scm("int32_t roundtrip 2^31-3", vv,
539 Scm_MakeInteger(Scm_GetInteger32Clamp(vv, 0, NULL)));
540 vv = Scm_Negate(SCM_2_31);
541 test_scm_c_scm("int32_t roundtrip -2^31", vv,
542 Scm_MakeInteger(Scm_GetInteger32Clamp(vv, 0, NULL)));
543 vv = Scm_Add(Scm_Negate(SCM_2_31), SCM_MAKE_INT(2));
544 test_scm_c_scm("int32_t roundtrip -2^31+2", vv,
545 Scm_MakeInteger(Scm_GetInteger32Clamp(vv, 0, NULL)));
546 vv = Scm_Add(SCM_2_32, SCM_MAKE_INT(-1));
547 test_scm_c_scm("uint32_t roundtrip 2^32-1", vv,
548 Scm_MakeIntegerU(Scm_GetIntegerU32Clamp(vv, 0, NULL)));
549 vv = Scm_Add(SCM_2_32, SCM_MAKE_INT(-3));
550 test_scm_c_scm("uint32_t roundtrip 2^32-3", vv,
551 Scm_MakeIntegerU(Scm_GetIntegerU32Clamp(vv, 0, NULL)));
552
553 vv = Scm_Add(SCM_2_31, SCM_MAKE_INT(-1));
554 test_scm_c_scm("int64_t roundtrip 2^31-1", vv,
555 Scm_MakeInteger64(Scm_GetInteger64(vv)));
556 vv = SCM_2_31;
557 test_scm_c_scm("int64_t roundtrip 2^31", vv,
558 Scm_MakeInteger64(Scm_GetInteger64(vv)));
559 vv = Scm_Add(SCM_2_32, SCM_MAKE_INT(-1));
560 test_scm_c_scm("int64_t roundtrip 2^32-1", vv,
561 Scm_MakeInteger64(Scm_GetInteger64(vv)));
562 vv = SCM_2_32;
563 test_scm_c_scm("int64_t roundtrip 2^32", vv,
564 Scm_MakeInteger64(Scm_GetInteger64(vv)));
565
566 vv = Scm_Add(Scm_Negate(SCM_2_31), SCM_MAKE_INT(1));
567 test_scm_c_scm("int64_t roundtrip -2^31+1", vv,
568 Scm_MakeInteger64(Scm_GetInteger64(vv)));
569 vv = Scm_Negate(SCM_2_31);
570 test_scm_c_scm("int64_t roundtrip -2^31", vv,
571 Scm_MakeInteger64(Scm_GetInteger64(vv)));
572 vv = Scm_Add(Scm_Negate(SCM_2_32), SCM_MAKE_INT(1));
573 test_scm_c_scm("int64_t roundtrip -2^32+1", vv,
574 Scm_MakeInteger64(Scm_GetInteger64(vv)));
575 vv = Scm_Negate(SCM_2_32);
576 test_scm_c_scm("int64_t roundtrip -2^32", vv,
577 Scm_MakeInteger64(Scm_GetInteger64(vv)));
578
579
580 vv = Scm_Add(SCM_2_63, SCM_MAKE_INT(-1));
581 test_scm_c_scm("int64_t roundtrip 2^63-1", vv,
582 Scm_MakeInteger64(Scm_GetInteger64(vv)));
583 vv = Scm_Add(SCM_2_63, SCM_MAKE_INT(-3));
584 test_scm_c_scm("int64_t roundtrip 2^63-3", vv,
585 Scm_MakeInteger64(Scm_GetInteger64(vv)));
586 vv = Scm_Negate(SCM_2_63);
587 test_scm_c_scm("int64_t roundtrip -2^63", vv,
588 Scm_MakeInteger64(Scm_GetInteger64(vv)));
589 vv = Scm_Add(Scm_Negate(SCM_2_63), SCM_MAKE_INT(2));
590 test_scm_c_scm("int64_t roundtrip -2^63+2", vv,
591 Scm_MakeInteger64(Scm_GetInteger64(vv)));
592
593 vv = Scm_Add(SCM_2_31, SCM_MAKE_INT(-1));
594 test_scm_c_scm("uint64_t roundtrip 2^31", vv,
595 Scm_MakeIntegerU64(Scm_GetIntegerU64(vv)));
596 vv = SCM_2_31;
597 test_scm_c_scm("uint64_t roundtrip 2^31", vv,
598 Scm_MakeIntegerU64(Scm_GetIntegerU64(vv)));
599 vv = Scm_Add(SCM_2_32, SCM_MAKE_INT(-1));
600 test_scm_c_scm("uint64_t roundtrip 2^32-1", vv,
601 Scm_MakeIntegerU64(Scm_GetIntegerU64(vv)));
602 vv = SCM_2_32;
603 test_scm_c_scm("uint64_t roundtrip 2^32", vv,
604 Scm_MakeIntegerU64(Scm_GetIntegerU64(vv)));
605
606 vv = Scm_Add(SCM_2_64, SCM_MAKE_INT(-1));
607 test_scm_c_scm("uint64_t roundtrip 2^64-1", vv,
608 Scm_MakeIntegerU64(Scm_GetIntegerU64(vv)));
609
610 TEST_SECTION("integer conversions, clamping");
611 vv = SCM_2_32;
612 test_scm_c_scm("int32_t clamp 2^32",
613 Scm_Add(SCM_2_31, SCM_MAKE_INT(-1)),
614 Scm_MakeInteger(Scm_GetInteger32Clamp(vv, SCM_CLAMP_BOTH, NULL)));
615 vv = SCM_2_63;
616 test_scm_c_scm("int32_t clamp 2^63",
617 Scm_Add(SCM_2_31, SCM_MAKE_INT(-1)),
618 Scm_MakeInteger(Scm_GetInteger32Clamp(vv, SCM_CLAMP_BOTH, NULL)));
619 vv = SCM_2_64;
620 test_scm_c_scm("int32_t clamp 2^64",
621 Scm_Add(SCM_2_31, SCM_MAKE_INT(-1)),
622 Scm_MakeInteger(Scm_GetInteger32Clamp(vv, SCM_CLAMP_BOTH, NULL)));
623 vv = Scm_Negate(SCM_2_32);
624 test_scm_c_scm("int32_t clamp -2^32",
625 Scm_Negate(SCM_2_31),
626 Scm_MakeInteger(Scm_GetInteger32Clamp(vv, SCM_CLAMP_BOTH, NULL)));
627 vv = Scm_Negate(SCM_2_63);
628 test_scm_c_scm("int32_t clamp -2^63",
629 Scm_Negate(SCM_2_31),
630 Scm_MakeInteger(Scm_GetInteger32Clamp(vv, SCM_CLAMP_BOTH, NULL)));
631 vv = Scm_Negate(SCM_2_64);
632 test_scm_c_scm("int32_t clamp -2^64",
633 Scm_Negate(SCM_2_31),
634 Scm_MakeInteger(Scm_GetInteger32Clamp(vv, SCM_CLAMP_BOTH, NULL)));
635
636
637 TEST_SECTION("integer conversions, CLAMP_NONE");
638
639 vv = SCM_MAKE_INT(-1);
640 Scm_GetIntegerU64Clamp(vv, SCM_CLAMP_NONE, &oor);
641 test_true("uint64_t oor -1", oor);
642
643 vv = Scm_Add(Scm_Negate(SCM_2_31), SCM_MAKE_INT(1));
644 Scm_GetIntegerU64Clamp(vv, SCM_CLAMP_NONE, &oor);
645 test_true("uint64_t oor -2^31+1", oor);
646
647 vv = Scm_Add(Scm_Negate(SCM_2_32), SCM_MAKE_INT(1));
648 Scm_GetIntegerU64Clamp(vv, SCM_CLAMP_NONE, &oor);
649 test_true("uint64_t oor -2^32+1", oor);
650 }
651
652 /*=============================================================
653 * Testing rounding to machine-word
654 */
655
656 void test_round_ulong_1(u_long expect, ScmObj obj)
657 {
658 Scm_Printf(SCM_CUROUT, "testing Scm_GetIntegerUMod(%S), expects %lu =>",
659 obj, expect);
660 u_long r = Scm_GetIntegerUMod(obj);
661 if (expect == r) {
662 Scm_Printf(SCM_CUROUT, "ok\n");
663 } else {
664 Scm_Printf(SCM_CUROUT, "ERROR: got %lu\n", r);
665 errcount++;
666 }
667 }
668
669 void test_round_ulong()
670 {
671 TEST_SECTION("integers modulo ulong range");
672 test_round_ulong_1(142857, SCM_MAKE_INT(142857));
673 test_round_ulong_1(285714, Scm_Add(Scm_Expt(SCM_MAKE_INT(2),
674 SCM_MAKE_INT(100)),
675 SCM_MAKE_INT(285714)));
676 test_round_ulong_1(UMAX, SCM_MAKE_INT(-1));
677 #if SIZEOF_LONG == 4
678 test_round_ulong_1(571428, Scm_Sub(SCM_MAKE_INT(571428), SCM_2_32));
679 #else /*SIZEOF_LONG > 4 */
680 test_round_ulong_1(571428, Scm_Sub(SCM_MAKE_INT(571428), SCM_2_64));
681 #endif /*SIZEOF_LONG > 4 */
682 }
683
684 /*=============================================================
685 * Testing 16bit floats
686 */
687
688 void test_half(const char *msg, int expect, int val)
689 {
690 Scm_Printf(SCM_CUROUT, "testing %s, expects %04x =>", msg, expect);
691 if (expect == val) {
692 Scm_Printf(SCM_CUROUT, "ok\n");
693 } else {
694 Scm_Printf(SCM_CUROUT, "ERROR: got %04x\n", val);
695 errcount++;
696 }
697 }
698
699 void test_double(const char *msg, double expect, double val)
700 {
701 Scm_Printf(SCM_CUROUT, "testing %s, expects %lg =>", msg, expect);
702 if (expect == val) {
703 Scm_Printf(SCM_CUROUT, "ok\n");
704 } else {
705 Scm_Printf(SCM_CUROUT, "ERROR: got %lg\n", val);
706 errcount++;
707 }
708 }
709
710 void test_f16(void)
711 {
712 double z;
713
714 TEST_SECTION("half floats");
715 test_double("half->double 0", 0.0, Scm_HalfToDouble(0));
716 test_double("half->double 1", 1.0, Scm_HalfToDouble(0x3c00));
717 test_double("half->double -1", -1.0, Scm_HalfToDouble(0xbc00));
718 test_double("half->double 1.5", 1.5, Scm_HalfToDouble(0x3e00));
719 test_double("half->double -1.5", -1.5, Scm_HalfToDouble(0xbe00));
720 test_double("half->double 0.75", 0.75, Scm_HalfToDouble(0x3a00));
721 test_double("half->double 0.875",0.875, Scm_HalfToDouble(0x3b00));
722
723 test_double("half->double all 1", 1.9990234375, Scm_HalfToDouble(0x3fff));
724 test_double("half->double maximum", 65504.0, Scm_HalfToDouble(0x7bff));
725 test_double("half->double normalized min", 6.103515625e-5,
726 Scm_HalfToDouble(0x0400));
727 test_double("half->double denormalized max", 6.097555160522461e-5,
728 Scm_HalfToDouble(0x03ff));
729 test_double("half->double denormalized max-1", 6.091594696044922e-5,
730 Scm_HalfToDouble(0x03fe));
731 test_double("half->double denormalized min", 5.960464477539063e-8,
732 Scm_HalfToDouble(0x0001));
733
734 test_double("half->double inf", SCM_DBL_POSITIVE_INFINITY,
735 Scm_HalfToDouble(0x7c00));
736 test_double("half->double -inf", SCM_DBL_NEGATIVE_INFINITY,
737 Scm_HalfToDouble(0xfc00));
738 z = Scm_HalfToDouble(0xffff);
739 test_true("half->double nan", !(z==z));
740
741
742 test_half("double->half 0", 0, Scm_DoubleToHalf(0.0));
743 test_half("double->half 1", 0x3c00, Scm_DoubleToHalf(1.0));
744 test_half("double->half -1", 0xbc00, Scm_DoubleToHalf(-1.0));
745 test_half("double->half 1.5", 0x3e00, Scm_DoubleToHalf(1.5));
746 test_half("double->half -1.5", 0xbe00, Scm_DoubleToHalf(-1.5));
747 test_half("double->half 0.75", 0x3a00, Scm_DoubleToHalf(0.75));
748 test_half("double->half 0.875",0x3b00, Scm_DoubleToHalf(0.875));
749
750 test_half("double->half all 1", 0x3fff, Scm_DoubleToHalf(1.9990234375));
751 test_half("double->half max", 0x7bff, Scm_DoubleToHalf(65504.0));
752 test_half("double->half normalized min", 0x0400,
753 Scm_DoubleToHalf(6.103515625e-5));
754 test_half("double->half denormalized max", 0x03ff,
755 Scm_DoubleToHalf(6.097555160522461e-5));
756 test_half("double->half denormalized max-1", 0x03fe,
757 Scm_DoubleToHalf(6.091594696044922e-5));
758 test_half("double->half denormalized min", 0x0001,
759 Scm_DoubleToHalf(5.960464477539063e-8));
760
761 test_half("double->half inf", 0x7c00, Scm_DoubleToHalf(SCM_DBL_POSITIVE_INFINITY));
762 test_half("double->half -inf", 0xfc00, Scm_DoubleToHalf(SCM_DBL_NEGATIVE_INFINITY));
763 test_half("double->half nan", 0x7fff, Scm_DoubleToHalf(SCM_DBL_NAN));
764
765 test_half("double->half, rounding", 0x4000,
766 Scm_DoubleToHalf(1.999755859375)); /* m=#b1111111111.11 */
767 test_half("double->half, rounding", 0x4000,
768 Scm_DoubleToHalf(1.99951171875)); /* m=#b1111111111.10 */
769 test_half("double->half, rounding", 0x3fff,
770 Scm_DoubleToHalf(1.999267578125)); /* m=#b1111111111.01 */
771 test_half("double->half, rounding", 0x3fff,
772 Scm_DoubleToHalf(1.998779296875)); /* m=#b1111111110.11 */
773 test_half("double->half, rounding", 0x3ffe,
774 Scm_DoubleToHalf(1.99853515625)); /* m=#b1111111110.10 */
775 test_half("double->half, rounding", 0x3ffe,
776 Scm_DoubleToHalf(1.998291015625)); /* m=#b1111111110.01 */
777 test_half("double->half, rounding to overflow", 0x7c00,
778 Scm_DoubleToHalf(65520.0));
779 test_half("double->half, just below overflow", 0x7bff,
780 Scm_DoubleToHalf(65519.99999999999));
781 test_half("double->half, rounding to overflow", 0xfc00,
782 Scm_DoubleToHalf(-65520.0));
783 test_half("double->half, just below overflow", 0xfbff,
784 Scm_DoubleToHalf(-65519.99999999999));
785 test_half("double->half, rounding to normalized", 0x0400,
786 Scm_DoubleToHalf(6.1005353927612305e-5));
787 test_half("double->half, rounding to denormalized min", 0x0001,
788 Scm_DoubleToHalf(2.980232238770209e-8));
789 test_half("double->half, just below above", 0x0000,
790 Scm_DoubleToHalf(2.9802322387695312e-8));
791 }
792
793 /*=============================================================
794 * main
795 */
796 int main(int argc SCM_UNUSED, char **argv SCM_UNUSED)
797 {
798 const char *testmsg = "Testing integer arithmetic macros ... ";
799
800 Scm_Init(GAUCHE_SIGNATURE);
801
802 fprintf(stderr, "%-65s", testmsg);
803 message(stdout, testmsg, '=');
804
805 test_uadd();
806 test_uaddov();
807 test_saddov();
808 test_usub();
809 test_usubov();
810 test_ssubov();
811 test_umul();
812 test_umulov();
813 test_smulov();
814
815 test_32_64();
816
817 test_round_ulong();
818
819 test_f16();
820
821 if (errcount) {
822 fprintf(stderr, "failed.\n");
823 fprintf(stdout, "failed.\n");
824 } else {
825 fprintf(stderr, "passed.\n");
826 fprintf(stdout, "passed.\n");
827 }
828 return 0;
829 }