1;;  Filename : test-number-literal.scm
2;;  About    : unit test for R5RS number literals
3;;
4;;  Copyright (C) 2006 YAMAMOTO Kengo <yamaken AT bp.iij4u.or.jp>
5;;  Copyright (c) 2007-2008 SigScheme Project <uim-en AT googlegroups.com>
6;;
7;;  All rights reserved.
8;;
9;;  Redistribution and use in source and binary forms, with or without
10;;  modification, are permitted provided that the following conditions
11;;  are met:
12;;
13;;  1. Redistributions of source code must retain the above copyright
14;;     notice, this list of conditions and the following disclaimer.
15;;  2. Redistributions in binary form must reproduce the above copyright
16;;     notice, this list of conditions and the following disclaimer in the
17;;     documentation and/or other materials provided with the distribution.
18;;  3. Neither the name of authors nor the names of its contributors
19;;     may be used to endorse or promote products derived from this software
20;;     without specific prior written permission.
21;;
22;;  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
23;;  IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
24;;  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
25;;  PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
26;;  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
27;;  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
28;;  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
29;;  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
30;;  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
31;;  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
32;;  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33
34(require-extension (unittest))
35
36(if (not (symbol-bound? 'number?))
37    (test-skip "R5RS numbers is not enabled"))
38
39(define tn test-name)
40
41
42(tn "integer implicit decimal")
43(assert-equal? (tn) 0  (string-read   "-0"))
44(assert-equal? (tn) 0  (string-read    "0"))
45(assert-equal? (tn) 0  (string-read   "+0"))
46(assert-equal? (tn) 0  (string-read  "-00"))
47(assert-equal? (tn) 0  (string-read   "00"))
48(assert-equal? (tn) 0  (string-read  "+00"))
49(assert-equal? (tn) -9 (string-read   "-9"))
50(assert-equal? (tn) 9  (string-read    "9"))
51(assert-equal? (tn) 9  (string-read   "+9"))
52(assert-equal? (tn) -9 (string-read  "-09"))
53(assert-equal? (tn) 9  (string-read   "09"))
54(assert-equal? (tn) 9  (string-read  "+09"))
55(assert-equal? (tn) 0  (string-eval  "'-0"))
56(assert-equal? (tn) 0  (string-eval   "'0"))
57(assert-equal? (tn) 0  (string-eval  "'+0"))
58(assert-equal? (tn) 0  (string-eval "'-00"))
59(assert-equal? (tn) 0  (string-eval  "'00"))
60(assert-equal? (tn) 0  (string-eval "'+00"))
61(assert-equal? (tn) -9 (string-eval  "'-9"))
62(assert-equal? (tn) 9  (string-eval   "'9"))
63(assert-equal? (tn) 9  (string-eval  "'+9"))
64(assert-equal? (tn) -9 (string-eval "'-09"))
65(assert-equal? (tn) 9  (string-eval  "'09"))
66(assert-equal? (tn) 9  (string-eval "'+09"))
67(assert-equal? (tn)  238975 (string-read  "0238975"))
68(assert-equal? (tn)  238975 (string-read   "238975"))
69(assert-equal? (tn)  238975 (string-read  "+238975"))
70(assert-equal? (tn)  238975 (string-read "+0238975"))
71(assert-equal? (tn) -238975 (string-read  "-238975"))
72(assert-equal? (tn) -238975 (string-read "-0238975"))
73(if (>= fixnum-bits 60)
74    (begin
75      (tn "integer implicit decimal 64-bit")
76      (string-eval "(assert-equal? (tn)  956397711204 (string-read  \"0956397711204\"))")
77      (string-eval "(assert-equal? (tn)  956397711204 (string-read   \"956397711204\"))")
78      (string-eval "(assert-equal? (tn)  956397711204 (string-read  \"+956397711204\"))")
79      (string-eval "(assert-equal? (tn)  956397711204 (string-read \"+0956397711204\"))")
80      (string-eval "(assert-equal? (tn) -956397711204 (string-read  \"-956397711204\"))")
81      (string-eval "(assert-equal? (tn) -956397711204 (string-read \"-0956397711204\"))")))
82(tn "integer explicit decimal")
83(assert-equal? (tn) 0  (string-read   "#d-0"))
84(assert-equal? (tn) 0  (string-read    "#d0"))
85(assert-equal? (tn) 0  (string-read   "#d+0"))
86(assert-equal? (tn) 0  (string-read  "#d-00"))
87(assert-equal? (tn) 0  (string-read   "#d00"))
88(assert-equal? (tn) 0  (string-read  "#d+00"))
89(assert-equal? (tn) -9 (string-read   "#d-9"))
90(assert-equal? (tn) 9  (string-read    "#d9"))
91(assert-equal? (tn) 9  (string-read   "#d+9"))
92(assert-equal? (tn) -9 (string-read  "#d-09"))
93(assert-equal? (tn) 9  (string-read   "#d09"))
94(assert-equal? (tn) 9  (string-read  "#d+09"))
95(assert-equal? (tn) 0  (string-eval  "'#d-0"))
96(assert-equal? (tn) 0  (string-eval   "'#d0"))
97(assert-equal? (tn) 0  (string-eval  "'#d+0"))
98(assert-equal? (tn) 0  (string-eval "'#d-00"))
99(assert-equal? (tn) 0  (string-eval  "'#d00"))
100(assert-equal? (tn) 0  (string-eval "'#d+00"))
101(assert-equal? (tn) -9 (string-eval  "'#d-9"))
102(assert-equal? (tn) 9  (string-eval   "'#d9"))
103(assert-equal? (tn) 9  (string-eval  "'#d+9"))
104(assert-equal? (tn) -9 (string-eval "'#d-09"))
105(assert-equal? (tn) 9  (string-eval  "'#d09"))
106(assert-equal? (tn) 9  (string-eval "'#d+09"))
107(assert-equal? (tn)  238975 (string-read  "#d0238975"))
108(assert-equal? (tn)  238975 (string-read   "#d238975"))
109(assert-equal? (tn)  238975 (string-read  "#d+238975"))
110(assert-equal? (tn)  238975 (string-read "#d+0238975"))
111(assert-equal? (tn) -238975 (string-read  "#d-238975"))
112(assert-equal? (tn) -238975 (string-read "#d-0238975"))
113(if (>= fixnum-bits 60)
114    (begin
115      (tn "integer explicit decimal 64-bit")
116      (string-eval "(assert-equal? (tn)  956397711204 (string-read  \"#d0956397711204\"))")
117      (string-eval "(assert-equal? (tn)  956397711204 (string-read   \"#d956397711204\"))")
118      (string-eval "(assert-equal? (tn)  956397711204 (string-read  \"#d+956397711204\"))")
119      (string-eval "(assert-equal? (tn)  956397711204 (string-read \"#d+0956397711204\"))")
120      (string-eval "(assert-equal? (tn) -956397711204 (string-read  \"#d-956397711204\"))")
121      (string-eval "(assert-equal? (tn) -956397711204 (string-read \"#d-0956397711204\"))")))
122(tn "integer hexadecimal")
123(assert-equal? (tn) 0   (string-read   "#x-0"))
124(assert-equal? (tn) 0   (string-read    "#x0"))
125(assert-equal? (tn) 0   (string-read   "#x+0"))
126(assert-equal? (tn) 0   (string-read  "#x-00"))
127(assert-equal? (tn) 0   (string-read   "#x00"))
128(assert-equal? (tn) 0   (string-read  "#x+00"))
129(assert-equal? (tn) -15 (string-read   "#x-f"))
130(assert-equal? (tn) 15  (string-read    "#xf"))
131(assert-equal? (tn) 15  (string-read   "#x+f"))
132(assert-equal? (tn) -15 (string-read  "#x-0f"))
133(assert-equal? (tn) 15  (string-read   "#x0f"))
134(assert-equal? (tn) 15  (string-read  "#x+0f"))
135(assert-equal? (tn) -15 (string-read   "#x-F"))
136(assert-equal? (tn) 15  (string-read    "#xF"))
137(assert-equal? (tn) 15  (string-read   "#x+F"))
138(assert-equal? (tn) -15 (string-read  "#x-0F"))
139(assert-equal? (tn) 15  (string-read   "#x0F"))
140(assert-equal? (tn) 15  (string-read  "#x+0F"))
141(assert-equal? (tn) 0   (string-eval  "'#x-0"))
142(assert-equal? (tn) 0   (string-eval   "'#x0"))
143(assert-equal? (tn) 0   (string-eval  "'#x+0"))
144(assert-equal? (tn) 0   (string-eval "'#x-00"))
145(assert-equal? (tn) 0   (string-eval  "'#x00"))
146(assert-equal? (tn) 0   (string-eval "'#x+00"))
147(assert-equal? (tn) -15 (string-eval  "'#x-f"))
148(assert-equal? (tn) 15  (string-eval   "'#xf"))
149(assert-equal? (tn) 15  (string-eval  "'#x+f"))
150(assert-equal? (tn) -15 (string-eval "'#x-0f"))
151(assert-equal? (tn) 15  (string-eval  "'#x0f"))
152(assert-equal? (tn) 15  (string-eval "'#x+0f"))
153(assert-equal? (tn) -15 (string-eval  "'#x-F"))
154(assert-equal? (tn) 15  (string-eval   "'#xF"))
155(assert-equal? (tn) 15  (string-eval  "'#x+F"))
156(assert-equal? (tn) -15 (string-eval "'#x-0F"))
157(assert-equal? (tn) 15  (string-eval  "'#x0F"))
158(assert-equal? (tn) 15  (string-eval "'#x+0F"))
159(assert-equal? (tn)  14593330 (string-read  "#x0deAd32"))
160(assert-equal? (tn)  14593330 (string-read   "#xdeAd32"))
161(assert-equal? (tn)  14593330 (string-read  "#x+dEad32"))
162(assert-equal? (tn)  14593330 (string-read "#x+0dEad32"))
163(assert-equal? (tn) -14593330 (string-read  "#x-deaD32"))
164(assert-equal? (tn) -14593330 (string-read "#x-0deaD32"))
165(assert-equal? (tn)   3333805 (string-read   "#x32deAd"))
166(assert-equal? (tn)   3333805 (string-read  "#x+32dEad"))
167(assert-equal? (tn)  -3333805 (string-read  "#x-32deaD"))
168(if (>= fixnum-bits 60)
169    (begin
170      (tn "integer hexadecimal 64-bit")
171      (string-eval "(assert-equal? (tn)  956397711204 (string-read  \"#x0deadbeef64\"))")
172      (string-eval "(assert-equal? (tn)  956397711204 (string-read   \"#xdeadbeef64\"))")
173      (string-eval "(assert-equal? (tn)  956397711204 (string-read  \"#x+deadbeef64\"))")
174      (string-eval "(assert-equal? (tn)  956397711204 (string-read \"#x+0deadbeef64\"))")
175      (string-eval "(assert-equal? (tn) -956397711204 (string-read  \"#x-deadbeef64\"))")
176      (string-eval "(assert-equal? (tn) -956397711204 (string-read \"#x-0deadbeef64\"))")))
177(tn "integer octal")
178(assert-equal? (tn) 0  (string-read   "#o-0"))
179(assert-equal? (tn) 0  (string-read    "#o0"))
180(assert-equal? (tn) 0  (string-read   "#o+0"))
181(assert-equal? (tn) 0  (string-read  "#o-00"))
182(assert-equal? (tn) 0  (string-read   "#o00"))
183(assert-equal? (tn) 0  (string-read  "#o+00"))
184(assert-equal? (tn) -7 (string-read   "#o-7"))
185(assert-equal? (tn) 7  (string-read    "#o7"))
186(assert-equal? (tn) 7  (string-read   "#o+7"))
187(assert-equal? (tn) -7 (string-read  "#o-07"))
188(assert-equal? (tn) 7  (string-read   "#o07"))
189(assert-equal? (tn) 7  (string-read  "#o+07"))
190(assert-equal? (tn) 0  (string-eval  "'#o-0"))
191(assert-equal? (tn) 0  (string-eval   "'#o0"))
192(assert-equal? (tn) 0  (string-eval  "'#o+0"))
193(assert-equal? (tn) 0  (string-eval "'#o-00"))
194(assert-equal? (tn) 0  (string-eval  "'#o00"))
195(assert-equal? (tn) 0  (string-eval "'#o+00"))
196(assert-equal? (tn) -7 (string-eval  "'#o-7"))
197(assert-equal? (tn) 7  (string-eval   "'#o7"))
198(assert-equal? (tn) 7  (string-eval  "'#o+7"))
199(assert-equal? (tn) -7 (string-eval "'#o-07"))
200(assert-equal? (tn) 7  (string-eval  "'#o07"))
201(assert-equal? (tn) 7  (string-eval "'#o+07"))
202(assert-equal? (tn)  1556392 (string-read  "#o05737650"))
203(assert-equal? (tn)  1556392 (string-read   "#o5737650"))
204(assert-equal? (tn)  1556392 (string-read  "#o+5737650"))
205(assert-equal? (tn)  1556392 (string-read "#o+05737650"))
206(assert-equal? (tn) -1556392 (string-read  "#o-5737650"))
207(assert-equal? (tn) -1556392 (string-read "#o-05737650"))
208(if (>= fixnum-bits 60)
209    (begin
210      (tn "integer octal 64-bit")
211      (string-eval "(assert-equal? (tn)  956397711204 (string-read  \"#o015725557567544\"))")
212      (string-eval "(assert-equal? (tn)  956397711204 (string-read   \"#o15725557567544\"))")
213      (string-eval "(assert-equal? (tn)  956397711204 (string-read  \"#o+15725557567544\"))")
214      (string-eval "(assert-equal? (tn)  956397711204 (string-read \"#o+015725557567544\"))")
215      (string-eval "(assert-equal? (tn) -956397711204 (string-read  \"#o-15725557567544\"))")
216      (string-eval "(assert-equal? (tn) -956397711204 (string-read \"#o-015725557567544\"))")))
217(tn "integer binary")
218(assert-equal? (tn) 0  (string-read   "#b-0"))
219(assert-equal? (tn) 0  (string-read    "#b0"))
220(assert-equal? (tn) 0  (string-read   "#b+0"))
221(assert-equal? (tn) 0  (string-read  "#b-00"))
222(assert-equal? (tn) 0  (string-read   "#b00"))
223(assert-equal? (tn) 0  (string-read  "#b+00"))
224(assert-equal? (tn) -1 (string-read   "#b-1"))
225(assert-equal? (tn) 1  (string-read    "#b1"))
226(assert-equal? (tn) 1  (string-read   "#b+1"))
227(assert-equal? (tn) -1 (string-read  "#b-01"))
228(assert-equal? (tn) 1  (string-read   "#b01"))
229(assert-equal? (tn) 1  (string-read  "#b+01"))
230(assert-equal? (tn) 0  (string-eval  "'#b-0"))
231(assert-equal? (tn) 0  (string-eval   "'#b0"))
232(assert-equal? (tn) 0  (string-eval  "'#b+0"))
233(assert-equal? (tn) 0  (string-eval "'#b-00"))
234(assert-equal? (tn) 0  (string-eval  "'#b00"))
235(assert-equal? (tn) 0  (string-eval "'#b+00"))
236(assert-equal? (tn) -1 (string-eval  "'#b-1"))
237(assert-equal? (tn) 1  (string-eval   "'#b1"))
238(assert-equal? (tn) 1  (string-eval  "'#b+1"))
239(assert-equal? (tn) -1 (string-eval "'#b-01"))
240(assert-equal? (tn) 1  (string-eval  "'#b01"))
241(assert-equal? (tn) 1  (string-eval "'#b+01"))
242(assert-equal? (tn)  2990842 (string-read  "#b01011011010001011111010"))
243(assert-equal? (tn)  2990842 (string-read   "#b1011011010001011111010"))
244(assert-equal? (tn)  2990842 (string-read  "#b+1011011010001011111010"))
245(assert-equal? (tn)  2990842 (string-read "#b+01011011010001011111010"))
246(assert-equal? (tn) -2990842 (string-read  "#b-1011011010001011111010"))
247(assert-equal? (tn) -2990842 (string-read "#b-01011011010001011111010"))
248(if (>= fixnum-bits 60)
249    (begin
250      (tn "integer binary 64-bit")
251      (string-eval "(assert-equal? (tn)  956397711204 (string-read  \"#b01101111010101101101111101110111101100100\"))")
252      (string-eval "(assert-equal? (tn)  956397711204 (string-read   \"#b1101111010101101101111101110111101100100\"))")
253      (string-eval "(assert-equal? (tn)  956397711204 (string-read  \"#b+1101111010101101101111101110111101100100\"))")
254      (string-eval "(assert-equal? (tn)  956397711204 (string-read \"#b+01101111010101101101111101110111101100100\"))")
255      (string-eval "(assert-equal? (tn) -956397711204 (string-read  \"#b-1101111010101101101111101110111101100100\"))")
256      (string-eval "(assert-equal? (tn) -956397711204 (string-read \"#b-01101111010101101101111101110111101100100\"))")))
257(case fixnum-bits
258  ((28)
259   (tn "integer limit implicit decimal")
260   (assert-error  (tn) (lambda () (string-read     "-134217729")))
261   (assert-error  (tn) (lambda () (string-read      "134217728")))
262   (assert-error  (tn) (lambda () (string-read     "+134217728")))
263   (assert-error  (tn) (lambda () (string-read    "-0134217729")))
264   (assert-error  (tn) (lambda () (string-read     "0134217728")))
265   (assert-error  (tn) (lambda () (string-read    "+0134217728")))
266   (assert-error  (tn) (lambda () (string-read    "'-134217729")))
267   (assert-error  (tn) (lambda () (string-read     "'134217728")))
268   (assert-error  (tn) (lambda () (string-read    "'+134217728")))
269   (assert-error  (tn) (lambda () (string-read   "'-0134217729")))
270   (assert-error  (tn) (lambda () (string-read    "'0134217728")))
271   (assert-error  (tn) (lambda () (string-read   "'+0134217728")))
272   (assert-true   (tn) (integer?  (string-read     "-134217728")))
273   (assert-true   (tn) (integer?  (string-read      "134217727")))
274   (assert-true   (tn) (integer?  (string-read     "+134217727")))
275   (assert-true   (tn) (integer?  (string-read    "-0134217728")))
276   (assert-true   (tn) (integer?  (string-read     "0134217727")))
277   (assert-true   (tn) (integer?  (string-read    "+0134217727")))
278   (assert-true   (tn) (integer?  (string-eval    "'-134217728")))
279   (assert-true   (tn) (integer?  (string-eval     "'134217727")))
280   (assert-true   (tn) (integer?  (string-eval    "'+134217727")))
281   (assert-true   (tn) (integer?  (string-eval   "'-0134217728")))
282   (assert-true   (tn) (integer?  (string-eval    "'0134217727")))
283   (assert-true   (tn) (integer?  (string-eval   "'+0134217727")))
284   (tn "integer limit explicit decimal")
285   (assert-error  (tn) (lambda () (string-read   "#d-134217729")))
286   (assert-error  (tn) (lambda () (string-read    "#d134217728")))
287   (assert-error  (tn) (lambda () (string-read   "#d+134217728")))
288   (assert-error  (tn) (lambda () (string-read  "#d-0134217729")))
289   (assert-error  (tn) (lambda () (string-read   "#d0134217728")))
290   (assert-error  (tn) (lambda () (string-read  "#d+0134217728")))
291   (assert-error  (tn) (lambda () (string-read  "'#d-134217729")))
292   (assert-error  (tn) (lambda () (string-read   "'#d134217728")))
293   (assert-error  (tn) (lambda () (string-read  "'#d+134217728")))
294   (assert-error  (tn) (lambda () (string-read "'#d-0134217729")))
295   (assert-error  (tn) (lambda () (string-read  "'#d0134217728")))
296   (assert-error  (tn) (lambda () (string-read "'#d+0134217728")))
297   (assert-true   (tn) (integer?  (string-read   "#d-134217728")))
298   (assert-true   (tn) (integer?  (string-read    "#d134217727")))
299   (assert-true   (tn) (integer?  (string-read   "#d+134217727")))
300   (assert-true   (tn) (integer?  (string-read  "#d-0134217728")))
301   (assert-true   (tn) (integer?  (string-read   "#d0134217727")))
302   (assert-true   (tn) (integer?  (string-read  "#d+0134217727")))
303   (assert-true   (tn) (integer?  (string-eval  "'#d-134217728")))
304   (assert-true   (tn) (integer?  (string-eval   "'#d134217727")))
305   (assert-true   (tn) (integer?  (string-eval  "'#d+134217727")))
306   (assert-true   (tn) (integer?  (string-eval "'#d-0134217728")))
307   (assert-true   (tn) (integer?  (string-eval  "'#d0134217727")))
308   (assert-true   (tn) (integer?  (string-eval "'#d+0134217727")))
309   (tn "integer limit hexadecimal")
310   (assert-error  (tn) (lambda () (string-read   "#x-8000001")))
311   (assert-error  (tn) (lambda () (string-read    "#x8000000")))
312   (assert-error  (tn) (lambda () (string-read   "#x+8000000")))
313   (assert-error  (tn) (lambda () (string-read  "#x-08000001")))
314   (assert-error  (tn) (lambda () (string-read   "#x08000000")))
315   (assert-error  (tn) (lambda () (string-read  "#x+08000000")))
316   (assert-error  (tn) (lambda () (string-read  "'#x-8000001")))
317   (assert-error  (tn) (lambda () (string-read   "'#x8000000")))
318   (assert-error  (tn) (lambda () (string-read  "'#x+8000000")))
319   (assert-error  (tn) (lambda () (string-read "'#x-08000001")))
320   (assert-error  (tn) (lambda () (string-read  "'#x08000000")))
321   (assert-error  (tn) (lambda () (string-read "'#x+08000000")))
322   (assert-true   (tn) (integer?  (string-read   "#x-8000000")))
323   (assert-true   (tn) (integer?  (string-read    "#x7ffffff")))
324   (assert-true   (tn) (integer?  (string-read   "#x+7ffffff")))
325   (assert-true   (tn) (integer?  (string-read  "#x-08000000")))
326   (assert-true   (tn) (integer?  (string-read   "#x07ffffff")))
327   (assert-true   (tn) (integer?  (string-read  "#x+07ffffff")))
328   (assert-true   (tn) (integer?  (string-eval  "'#x-8000000")))
329   (assert-true   (tn) (integer?  (string-eval   "'#x7ffffff")))
330   (assert-true   (tn) (integer?  (string-eval  "'#x+7ffffff")))
331   (assert-true   (tn) (integer?  (string-eval "'#x-08000000")))
332   (assert-true   (tn) (integer?  (string-eval  "'#x07ffffff")))
333   (assert-true   (tn) (integer?  (string-eval "'#x+07ffffff")))
334   (tn "integer limit octal")
335   (assert-error  (tn) (lambda () (string-read   "#o-1000000001")))
336   (assert-error  (tn) (lambda () (string-read    "#o1000000000")))
337   (assert-error  (tn) (lambda () (string-read   "#o+1000000000")))
338   (assert-error  (tn) (lambda () (string-read  "#o-01000000001")))
339   (assert-error  (tn) (lambda () (string-read   "#o01000000000")))
340   (assert-error  (tn) (lambda () (string-read  "#o+01000000000")))
341   (assert-error  (tn) (lambda () (string-read  "'#o-1000000001")))
342   (assert-error  (tn) (lambda () (string-read   "'#o1000000000")))
343   (assert-error  (tn) (lambda () (string-read  "'#o+1000000000")))
344   (assert-error  (tn) (lambda () (string-read "'#o-01000000001")))
345   (assert-error  (tn) (lambda () (string-read  "'#o01000000000")))
346   (assert-error  (tn) (lambda () (string-read "'#o+01000000000")))
347   (assert-true   (tn) (integer?  (string-read   "#o-1000000000")))
348   (assert-true   (tn) (integer?  (string-read     "#o777777777")))
349   (assert-true   (tn) (integer?  (string-read    "#o+777777777")))
350   (assert-true   (tn) (integer?  (string-read  "#o-01000000000")))
351   (assert-true   (tn) (integer?  (string-read    "#o0777777777")))
352   (assert-true   (tn) (integer?  (string-read   "#o+0777777777")))
353   (assert-true   (tn) (integer?  (string-eval  "'#o-1000000000")))
354   (assert-true   (tn) (integer?  (string-eval    "'#o777777777")))
355   (assert-true   (tn) (integer?  (string-eval   "'#o+777777777")))
356   (assert-true   (tn) (integer?  (string-eval "'#o-01000000000")))
357   (assert-true   (tn) (integer?  (string-eval   "'#o0777777777")))
358   (assert-true   (tn) (integer?  (string-eval  "'#o+0777777777")))
359   (tn "integer limit binary")
360   (assert-error  (tn) (lambda () (string-read   "#b-1000000000000000000000000001")))
361   (assert-error  (tn) (lambda () (string-read    "#b1000000000000000000000000000")))
362   (assert-error  (tn) (lambda () (string-read   "#b+1000000000000000000000000000")))
363   (assert-error  (tn) (lambda () (string-read  "#b-01000000000000000000000000001")))
364   (assert-error  (tn) (lambda () (string-read   "#b01000000000000000000000000000")))
365   (assert-error  (tn) (lambda () (string-read  "#b+01000000000000000000000000000")))
366   (assert-error  (tn) (lambda () (string-read  "'#b-1000000000000000000000000001")))
367   (assert-error  (tn) (lambda () (string-read   "'#b1000000000000000000000000000")))
368   (assert-error  (tn) (lambda () (string-read  "'#b+1000000000000000000000000000")))
369   (assert-error  (tn) (lambda () (string-read "'#b-01000000000000000000000000001")))
370   (assert-error  (tn) (lambda () (string-read  "'#b01000000000000000000000000000")))
371   (assert-error  (tn) (lambda () (string-read "'#b+01000000000000000000000000000")))
372   (assert-true   (tn) (integer?  (string-read   "#b-1000000000000000000000000000")))
373   (assert-true   (tn) (integer?  (string-read     "#b111111111111111111111111111")))
374   (assert-true   (tn) (integer?  (string-read    "#b+111111111111111111111111111")))
375   (assert-true   (tn) (integer?  (string-read  "#b-01000000000000000000000000000")))
376   (assert-true   (tn) (integer?  (string-read    "#b0111111111111111111111111111")))
377   (assert-true   (tn) (integer?  (string-read   "#b+0111111111111111111111111111")))
378   (assert-true   (tn) (integer?  (string-eval  "'#b-1000000000000000000000000000")))
379   (assert-true   (tn) (integer?  (string-eval    "'#b111111111111111111111111111")))
380   (assert-true   (tn) (integer?  (string-eval   "'#b+111111111111111111111111111")))
381   (assert-true   (tn) (integer?  (string-eval "'#b-01000000000000000000000000000")))
382   (assert-true   (tn) (integer?  (string-eval   "'#b0111111111111111111111111111")))
383   (assert-true   (tn) (integer?  (string-eval  "'#b+0111111111111111111111111111"))))
384  ((32)
385   (tn "integer limit implicit decimal")
386   (assert-error  (tn) (lambda () (string-read     "-2147483649")))
387   (assert-error  (tn) (lambda () (string-read      "2147483648")))
388   (assert-error  (tn) (lambda () (string-read     "+2147483648")))
389   (assert-error  (tn) (lambda () (string-read    "-02147483649")))
390   (assert-error  (tn) (lambda () (string-read     "02147483648")))
391   (assert-error  (tn) (lambda () (string-read    "+02147483648")))
392   (assert-error  (tn) (lambda () (string-read    "'-2147483649")))
393   (assert-error  (tn) (lambda () (string-read     "'2147483648")))
394   (assert-error  (tn) (lambda () (string-read    "'+2147483648")))
395   (assert-error  (tn) (lambda () (string-read   "'-02147483649")))
396   (assert-error  (tn) (lambda () (string-read    "'02147483648")))
397   (assert-error  (tn) (lambda () (string-read   "'+02147483648")))
398   (assert-true   (tn) (integer?  (string-read     "-2147483648")))
399   (assert-true   (tn) (integer?  (string-read      "2147483647")))
400   (assert-true   (tn) (integer?  (string-read     "+2147483647")))
401   (assert-true   (tn) (integer?  (string-read    "-02147483648")))
402   (assert-true   (tn) (integer?  (string-read     "02147483647")))
403   (assert-true   (tn) (integer?  (string-read    "+02147483647")))
404   (assert-true   (tn) (integer?  (string-eval    "'-2147483648")))
405   (assert-true   (tn) (integer?  (string-eval     "'2147483647")))
406   (assert-true   (tn) (integer?  (string-eval    "'+2147483647")))
407   (assert-true   (tn) (integer?  (string-eval   "'-02147483648")))
408   (assert-true   (tn) (integer?  (string-eval    "'02147483647")))
409   (assert-true   (tn) (integer?  (string-eval   "'+02147483647")))
410   (tn "integer limit explicit decimal")
411   (assert-error  (tn) (lambda () (string-read   "#d-2147483649")))
412   (assert-error  (tn) (lambda () (string-read    "#d2147483648")))
413   (assert-error  (tn) (lambda () (string-read   "#d+2147483648")))
414   (assert-error  (tn) (lambda () (string-read  "#d-02147483649")))
415   (assert-error  (tn) (lambda () (string-read   "#d02147483648")))
416   (assert-error  (tn) (lambda () (string-read  "#d+02147483648")))
417   (assert-error  (tn) (lambda () (string-read  "'#d-2147483649")))
418   (assert-error  (tn) (lambda () (string-read   "'#d2147483648")))
419   (assert-error  (tn) (lambda () (string-read  "'#d+2147483648")))
420   (assert-error  (tn) (lambda () (string-read "'#d-02147483649")))
421   (assert-error  (tn) (lambda () (string-read  "'#d02147483648")))
422   (assert-error  (tn) (lambda () (string-read "'#d+02147483648")))
423   (assert-true   (tn) (integer?  (string-read   "#d-2147483648")))
424   (assert-true   (tn) (integer?  (string-read    "#d2147483647")))
425   (assert-true   (tn) (integer?  (string-read   "#d+2147483647")))
426   (assert-true   (tn) (integer?  (string-read  "#d-02147483648")))
427   (assert-true   (tn) (integer?  (string-read   "#d02147483647")))
428   (assert-true   (tn) (integer?  (string-read  "#d+02147483647")))
429   (assert-true   (tn) (integer?  (string-eval  "'#d-2147483648")))
430   (assert-true   (tn) (integer?  (string-eval   "'#d2147483647")))
431   (assert-true   (tn) (integer?  (string-eval  "'#d+2147483647")))
432   (assert-true   (tn) (integer?  (string-eval "'#d-02147483648")))
433   (assert-true   (tn) (integer?  (string-eval  "'#d02147483647")))
434   (assert-true   (tn) (integer?  (string-eval "'#d+02147483647")))
435   (tn "integer limit hexadecimal")
436   (assert-error  (tn) (lambda () (string-read   "#x-80000001")))
437   (assert-error  (tn) (lambda () (string-read    "#x80000000")))
438   (assert-error  (tn) (lambda () (string-read   "#x+80000000")))
439   (assert-error  (tn) (lambda () (string-read  "#x-080000001")))
440   (assert-error  (tn) (lambda () (string-read   "#x080000000")))
441   (assert-error  (tn) (lambda () (string-read  "#x+080000000")))
442   (assert-error  (tn) (lambda () (string-read  "'#x-80000001")))
443   (assert-error  (tn) (lambda () (string-read   "'#x80000000")))
444   (assert-error  (tn) (lambda () (string-read  "'#x+80000000")))
445   (assert-error  (tn) (lambda () (string-read "'#x-080000001")))
446   (assert-error  (tn) (lambda () (string-read  "'#x080000000")))
447   (assert-error  (tn) (lambda () (string-read "'#x+080000000")))
448   (assert-true   (tn) (integer?  (string-read   "#x-80000000")))
449   (assert-true   (tn) (integer?  (string-read    "#x7fffffff")))
450   (assert-true   (tn) (integer?  (string-read   "#x+7fffffff")))
451   (assert-true   (tn) (integer?  (string-read  "#x-080000000")))
452   (assert-true   (tn) (integer?  (string-read   "#x07fffffff")))
453   (assert-true   (tn) (integer?  (string-read  "#x+07fffffff")))
454   (assert-true   (tn) (integer?  (string-eval  "'#x-80000000")))
455   (assert-true   (tn) (integer?  (string-eval   "'#x7fffffff")))
456   (assert-true   (tn) (integer?  (string-eval  "'#x+7fffffff")))
457   (assert-true   (tn) (integer?  (string-eval "'#x-080000000")))
458   (assert-true   (tn) (integer?  (string-eval  "'#x07fffffff")))
459   (assert-true   (tn) (integer?  (string-eval "'#x+07fffffff")))
460   (tn "integer limit octal")
461   (assert-error  (tn) (lambda () (string-read   "#o-20000000001")))
462   (assert-error  (tn) (lambda () (string-read    "#o20000000000")))
463   (assert-error  (tn) (lambda () (string-read   "#o+20000000000")))
464   (assert-error  (tn) (lambda () (string-read  "#o-020000000001")))
465   (assert-error  (tn) (lambda () (string-read   "#o020000000000")))
466   (assert-error  (tn) (lambda () (string-read  "#o+020000000000")))
467   (assert-error  (tn) (lambda () (string-read  "'#o-20000000001")))
468   (assert-error  (tn) (lambda () (string-read   "'#o20000000000")))
469   (assert-error  (tn) (lambda () (string-read  "'#o+20000000000")))
470   (assert-error  (tn) (lambda () (string-read "'#o-020000000001")))
471   (assert-error  (tn) (lambda () (string-read  "'#o020000000000")))
472   (assert-error  (tn) (lambda () (string-read "'#o+020000000000")))
473   (assert-true   (tn) (integer?  (string-read   "#o-20000000000")))
474   (assert-true   (tn) (integer?  (string-read    "#o17777777777")))
475   (assert-true   (tn) (integer?  (string-read   "#o+17777777777")))
476   (assert-true   (tn) (integer?  (string-read  "#o-020000000000")))
477   (assert-true   (tn) (integer?  (string-read   "#o017777777777")))
478   (assert-true   (tn) (integer?  (string-read  "#o+017777777777")))
479   (assert-true   (tn) (integer?  (string-eval  "'#o-20000000000")))
480   (assert-true   (tn) (integer?  (string-eval   "'#o17777777777")))
481   (assert-true   (tn) (integer?  (string-eval  "'#o+17777777777")))
482   (assert-true   (tn) (integer?  (string-eval "'#o-020000000000")))
483   (assert-true   (tn) (integer?  (string-eval  "'#o017777777777")))
484   (assert-true   (tn) (integer?  (string-eval "'#o+017777777777")))
485   (tn "integer limit binary")
486   (assert-error  (tn) (lambda () (string-read   "#b-10000000000000000000000000000001")))
487   (assert-error  (tn) (lambda () (string-read    "#b10000000000000000000000000000000")))
488   (assert-error  (tn) (lambda () (string-read   "#b+10000000000000000000000000000000")))
489   (assert-error  (tn) (lambda () (string-read  "#b-010000000000000000000000000000001")))
490   (assert-error  (tn) (lambda () (string-read   "#b010000000000000000000000000000000")))
491   (assert-error  (tn) (lambda () (string-read  "#b+010000000000000000000000000000000")))
492   (assert-error  (tn) (lambda () (string-read  "'#b-10000000000000000000000000000001")))
493   (assert-error  (tn) (lambda () (string-read   "'#b10000000000000000000000000000000")))
494   (assert-error  (tn) (lambda () (string-read  "'#b+10000000000000000000000000000000")))
495   (assert-error  (tn) (lambda () (string-read "'#b-010000000000000000000000000000001")))
496   (assert-error  (tn) (lambda () (string-read  "'#b010000000000000000000000000000000")))
497   (assert-error  (tn) (lambda () (string-read "'#b+010000000000000000000000000000000")))
498   (assert-true   (tn) (integer?  (string-read   "#b-10000000000000000000000000000000")))
499   (assert-true   (tn) (integer?  (string-read     "#b1111111111111111111111111111111")))
500   (assert-true   (tn) (integer?  (string-read    "#b+1111111111111111111111111111111")))
501   (assert-true   (tn) (integer?  (string-read  "#b-010000000000000000000000000000000")))
502   (assert-true   (tn) (integer?  (string-read    "#b01111111111111111111111111111111")))
503   (assert-true   (tn) (integer?  (string-read   "#b+01111111111111111111111111111111")))
504   (assert-true   (tn) (integer?  (string-eval  "'#b-10000000000000000000000000000000")))
505   (assert-true   (tn) (integer?  (string-eval    "'#b1111111111111111111111111111111")))
506   (assert-true   (tn) (integer?  (string-eval   "'#b+1111111111111111111111111111111")))
507   (assert-true   (tn) (integer?  (string-eval "'#b-010000000000000000000000000000000")))
508   (assert-true   (tn) (integer?  (string-eval   "'#b01111111111111111111111111111111")))
509   (assert-true   (tn) (integer?  (string-eval  "'#b+01111111111111111111111111111111"))))
510  ((60)
511   (tn "integer limit implicit decimal")
512   (assert-error  (tn) (lambda () (string-read     "-576460752303423489")))
513   (assert-error  (tn) (lambda () (string-read      "576460752303423488")))
514   (assert-error  (tn) (lambda () (string-read     "+576460752303423488")))
515   (assert-error  (tn) (lambda () (string-read    "-0576460752303423489")))
516   (assert-error  (tn) (lambda () (string-read     "0576460752303423488")))
517   (assert-error  (tn) (lambda () (string-read    "+0576460752303423488")))
518   (assert-error  (tn) (lambda () (string-read    "'-576460752303423489")))
519   (assert-error  (tn) (lambda () (string-read     "'576460752303423488")))
520   (assert-error  (tn) (lambda () (string-read    "'+576460752303423488")))
521   (assert-error  (tn) (lambda () (string-read   "'-0576460752303423489")))
522   (assert-error  (tn) (lambda () (string-read    "'0576460752303423488")))
523   (assert-error  (tn) (lambda () (string-read   "'+0576460752303423488")))
524   (assert-true   (tn) (integer?  (string-read     "-576460752303423488")))
525   (assert-true   (tn) (integer?  (string-read      "576460752303423487")))
526   (assert-true   (tn) (integer?  (string-read     "+576460752303423487")))
527   (assert-true   (tn) (integer?  (string-read    "-0576460752303423488")))
528   (assert-true   (tn) (integer?  (string-read     "0576460752303423487")))
529   (assert-true   (tn) (integer?  (string-read    "+0576460752303423487")))
530   (assert-true   (tn) (integer?  (string-eval    "'-576460752303423488")))
531   (assert-true   (tn) (integer?  (string-eval     "'576460752303423487")))
532   (assert-true   (tn) (integer?  (string-eval    "'+576460752303423487")))
533   (assert-true   (tn) (integer?  (string-eval   "'-0576460752303423488")))
534   (assert-true   (tn) (integer?  (string-eval    "'0576460752303423487")))
535   (assert-true   (tn) (integer?  (string-eval   "'+0576460752303423487")))
536   (tn "integer limit explicit decimal")
537   (assert-error  (tn) (lambda () (string-read   "#d-576460752303423489")))
538   (assert-error  (tn) (lambda () (string-read    "#d576460752303423488")))
539   (assert-error  (tn) (lambda () (string-read   "#d+576460752303423488")))
540   (assert-error  (tn) (lambda () (string-read  "#d-0576460752303423489")))
541   (assert-error  (tn) (lambda () (string-read   "#d0576460752303423488")))
542   (assert-error  (tn) (lambda () (string-read  "#d+0576460752303423488")))
543   (assert-error  (tn) (lambda () (string-read  "'#d-576460752303423489")))
544   (assert-error  (tn) (lambda () (string-read   "'#d576460752303423488")))
545   (assert-error  (tn) (lambda () (string-read  "'#d+576460752303423488")))
546   (assert-error  (tn) (lambda () (string-read "'#d-0576460752303423489")))
547   (assert-error  (tn) (lambda () (string-read  "'#d0576460752303423488")))
548   (assert-error  (tn) (lambda () (string-read "'#d+0576460752303423488")))
549   (assert-true   (tn) (integer?  (string-read   "#d-576460752303423488")))
550   (assert-true   (tn) (integer?  (string-read    "#d576460752303423487")))
551   (assert-true   (tn) (integer?  (string-read   "#d+576460752303423487")))
552   (assert-true   (tn) (integer?  (string-read  "#d-0576460752303423488")))
553   (assert-true   (tn) (integer?  (string-read   "#d0576460752303423487")))
554   (assert-true   (tn) (integer?  (string-read  "#d+0576460752303423487")))
555   (assert-true   (tn) (integer?  (string-eval  "'#d-576460752303423488")))
556   (assert-true   (tn) (integer?  (string-eval   "'#d576460752303423487")))
557   (assert-true   (tn) (integer?  (string-eval  "'#d+576460752303423487")))
558   (assert-true   (tn) (integer?  (string-eval "'#d-0576460752303423488")))
559   (assert-true   (tn) (integer?  (string-eval  "'#d0576460752303423487")))
560   (assert-true   (tn) (integer?  (string-eval "'#d+0576460752303423487")))
561   (tn "integer limit hexadecimal")
562   (assert-error  (tn) (lambda () (string-read   "#x-800000000000001")))
563   (assert-error  (tn) (lambda () (string-read    "#x800000000000000")))
564   (assert-error  (tn) (lambda () (string-read   "#x+800000000000000")))
565   (assert-error  (tn) (lambda () (string-read  "#x-0800000000000001")))
566   (assert-error  (tn) (lambda () (string-read   "#x0800000000000000")))
567   (assert-error  (tn) (lambda () (string-read  "#x+0800000000000000")))
568   (assert-error  (tn) (lambda () (string-read  "'#x-800000000000001")))
569   (assert-error  (tn) (lambda () (string-read   "'#x800000000000000")))
570   (assert-error  (tn) (lambda () (string-read  "'#x+800000000000000")))
571   (assert-error  (tn) (lambda () (string-read "'#x-0800000000000001")))
572   (assert-error  (tn) (lambda () (string-read  "'#x0800000000000000")))
573   (assert-error  (tn) (lambda () (string-read "'#x+0800000000000000")))
574   (assert-true   (tn) (integer?  (string-read   "#x-800000000000000")))
575   (assert-true   (tn) (integer?  (string-read    "#x7ffffffffffffff")))
576   (assert-true   (tn) (integer?  (string-read   "#x+7ffffffffffffff")))
577   (assert-true   (tn) (integer?  (string-read  "#x-0800000000000000")))
578   (assert-true   (tn) (integer?  (string-read   "#x07ffffffffffffff")))
579   (assert-true   (tn) (integer?  (string-read  "#x+07ffffffffffffff")))
580   (assert-true   (tn) (integer?  (string-eval  "'#x-800000000000000")))
581   (assert-true   (tn) (integer?  (string-eval   "'#x7ffffffffffffff")))
582   (assert-true   (tn) (integer?  (string-eval  "'#x+7ffffffffffffff")))
583   (assert-true   (tn) (integer?  (string-eval "'#x-0800000000000000")))
584   (assert-true   (tn) (integer?  (string-eval  "'#x07ffffffffffffff")))
585   (assert-true   (tn) (integer?  (string-eval "'#x+07ffffffffffffff")))
586   (tn "integer limit octal")
587   (assert-error  (tn) (lambda () (string-read   "#o-40000000000000000001")))
588   (assert-error  (tn) (lambda () (string-read    "#o40000000000000000000")))
589   (assert-error  (tn) (lambda () (string-read   "#o+40000000000000000000")))
590   (assert-error  (tn) (lambda () (string-read  "#o-040000000000000000001")))
591   (assert-error  (tn) (lambda () (string-read   "#o040000000000000000000")))
592   (assert-error  (tn) (lambda () (string-read  "#o+040000000000000000000")))
593   (assert-error  (tn) (lambda () (string-read  "'#o-40000000000000000001")))
594   (assert-error  (tn) (lambda () (string-read   "'#o40000000000000000000")))
595   (assert-error  (tn) (lambda () (string-read  "'#o+40000000000000000000")))
596   (assert-error  (tn) (lambda () (string-read "'#o-040000000000000000001")))
597   (assert-error  (tn) (lambda () (string-read  "'#o040000000000000000000")))
598   (assert-error  (tn) (lambda () (string-read "'#o+040000000000000000000")))
599   (assert-true   (tn) (integer?  (string-read   "#o-40000000000000000000")))
600   (assert-true   (tn) (integer?  (string-read    "#o37777777777777777777")))
601   (assert-true   (tn) (integer?  (string-read   "#o+37777777777777777777")))
602   (assert-true   (tn) (integer?  (string-read  "#o-040000000000000000000")))
603   (assert-true   (tn) (integer?  (string-read   "#o037777777777777777777")))
604   (assert-true   (tn) (integer?  (string-read  "#o+037777777777777777777")))
605   (assert-true   (tn) (integer?  (string-eval  "'#o-40000000000000000000")))
606   (assert-true   (tn) (integer?  (string-eval   "'#o37777777777777777777")))
607   (assert-true   (tn) (integer?  (string-eval  "'#o+37777777777777777777")))
608   (assert-true   (tn) (integer?  (string-eval "'#o-040000000000000000000")))
609   (assert-true   (tn) (integer?  (string-eval  "'#o037777777777777777777")))
610   (assert-true   (tn) (integer?  (string-eval "'#o+037777777777777777777")))
611   (tn "integer limit binary")
612   (assert-error  (tn) (lambda () (string-read   "#b-100000000000000000000000000000000000000000000000000000000001")))
613   (assert-error  (tn) (lambda () (string-read    "#b100000000000000000000000000000000000000000000000000000000000")))
614   (assert-error  (tn) (lambda () (string-read   "#b+100000000000000000000000000000000000000000000000000000000000")))
615   (assert-error  (tn) (lambda () (string-read  "#b-0100000000000000000000000000000000000000000000000000000000001")))
616   (assert-error  (tn) (lambda () (string-read   "#b0100000000000000000000000000000000000000000000000000000000000")))
617   (assert-error  (tn) (lambda () (string-read  "#b+0100000000000000000000000000000000000000000000000000000000000")))
618   (assert-error  (tn) (lambda () (string-read  "'#b-100000000000000000000000000000000000000000000000000000000001")))
619   (assert-error  (tn) (lambda () (string-read   "'#b100000000000000000000000000000000000000000000000000000000000")))
620   (assert-error  (tn) (lambda () (string-read  "'#b+100000000000000000000000000000000000000000000000000000000000")))
621   (assert-error  (tn) (lambda () (string-read "'#b-0100000000000000000000000000000000000000000000000000000000001")))
622   (assert-error  (tn) (lambda () (string-read  "'#b0100000000000000000000000000000000000000000000000000000000000")))
623   (assert-error  (tn) (lambda () (string-read "'#b+0100000000000000000000000000000000000000000000000000000000000")))
624   (assert-true   (tn) (integer?  (string-read   "#b-100000000000000000000000000000000000000000000000000000000000")))
625   (assert-true   (tn) (integer?  (string-read     "#b11111111111111111111111111111111111111111111111111111111111")))
626   (assert-true   (tn) (integer?  (string-read    "#b+11111111111111111111111111111111111111111111111111111111111")))
627   (assert-true   (tn) (integer?  (string-read  "#b-0100000000000000000000000000000000000000000000000000000000000")))
628   (assert-true   (tn) (integer?  (string-read    "#b011111111111111111111111111111111111111111111111111111111111")))
629   (assert-true   (tn) (integer?  (string-read   "#b+011111111111111111111111111111111111111111111111111111111111")))
630   (assert-true   (tn) (integer?  (string-eval  "'#b-100000000000000000000000000000000000000000000000000000000000")))
631   (assert-true   (tn) (integer?  (string-eval    "'#b11111111111111111111111111111111111111111111111111111111111")))
632   (assert-true   (tn) (integer?  (string-eval   "'#b+11111111111111111111111111111111111111111111111111111111111")))
633   (assert-true   (tn) (integer?  (string-eval "'#b-0100000000000000000000000000000000000000000000000000000000000")))
634   (assert-true   (tn) (integer?  (string-eval   "'#b011111111111111111111111111111111111111111111111111111111111")))
635   (assert-true   (tn) (integer?  (string-eval  "'#b+011111111111111111111111111111111111111111111111111111111111"))))
636  ((64)
637   (tn "integer limit implicit decimal")
638   (assert-error  (tn) (lambda () (string-read     "-9223372036854775809")))
639   (assert-error  (tn) (lambda () (string-read      "9223372036854775808")))
640   (assert-error  (tn) (lambda () (string-read     "+9223372036854775808")))
641   (assert-error  (tn) (lambda () (string-read    "-09223372036854775809")))
642   (assert-error  (tn) (lambda () (string-read     "09223372036854775808")))
643   (assert-error  (tn) (lambda () (string-read    "+09223372036854775808")))
644   (assert-error  (tn) (lambda () (string-read    "'-9223372036854775809")))
645   (assert-error  (tn) (lambda () (string-read     "'9223372036854775808")))
646   (assert-error  (tn) (lambda () (string-read    "'+9223372036854775808")))
647   (assert-error  (tn) (lambda () (string-read   "'-09223372036854775809")))
648   (assert-error  (tn) (lambda () (string-read    "'09223372036854775808")))
649   (assert-error  (tn) (lambda () (string-read   "'+09223372036854775808")))
650   (assert-true   (tn) (integer?  (string-read     "-9223372036854775808")))
651   (assert-true   (tn) (integer?  (string-read      "9223372036854775807")))
652   (assert-true   (tn) (integer?  (string-read     "+9223372036854775807")))
653   (assert-true   (tn) (integer?  (string-read    "-09223372036854775808")))
654   (assert-true   (tn) (integer?  (string-read     "09223372036854775807")))
655   (assert-true   (tn) (integer?  (string-read    "+09223372036854775807")))
656   (assert-true   (tn) (integer?  (string-eval    "'-9223372036854775808")))
657   (assert-true   (tn) (integer?  (string-eval     "'9223372036854775807")))
658   (assert-true   (tn) (integer?  (string-eval    "'+9223372036854775807")))
659   (assert-true   (tn) (integer?  (string-eval   "'-09223372036854775808")))
660   (assert-true   (tn) (integer?  (string-eval    "'09223372036854775807")))
661   (assert-true   (tn) (integer?  (string-eval   "'+09223372036854775807")))
662   (tn "integer limit explicit decimal")
663   (assert-error  (tn) (lambda () (string-read   "#d-9223372036854775809")))
664   (assert-error  (tn) (lambda () (string-read    "#d9223372036854775808")))
665   (assert-error  (tn) (lambda () (string-read   "#d+9223372036854775808")))
666   (assert-error  (tn) (lambda () (string-read  "#d-09223372036854775809")))
667   (assert-error  (tn) (lambda () (string-read   "#d09223372036854775808")))
668   (assert-error  (tn) (lambda () (string-read  "#d+09223372036854775808")))
669   (assert-error  (tn) (lambda () (string-read  "'#d-9223372036854775809")))
670   (assert-error  (tn) (lambda () (string-read   "'#d9223372036854775808")))
671   (assert-error  (tn) (lambda () (string-read  "'#d+9223372036854775808")))
672   (assert-error  (tn) (lambda () (string-read "'#d-09223372036854775809")))
673   (assert-error  (tn) (lambda () (string-read  "'#d09223372036854775808")))
674   (assert-error  (tn) (lambda () (string-read "'#d+09223372036854775808")))
675   (assert-true   (tn) (integer?  (string-read   "#d-9223372036854775808")))
676   (assert-true   (tn) (integer?  (string-read    "#d9223372036854775807")))
677   (assert-true   (tn) (integer?  (string-read   "#d+9223372036854775807")))
678   (assert-true   (tn) (integer?  (string-read  "#d-09223372036854775808")))
679   (assert-true   (tn) (integer?  (string-read   "#d09223372036854775807")))
680   (assert-true   (tn) (integer?  (string-read  "#d+09223372036854775807")))
681   (assert-true   (tn) (integer?  (string-eval  "'#d-9223372036854775808")))
682   (assert-true   (tn) (integer?  (string-eval   "'#d9223372036854775807")))
683   (assert-true   (tn) (integer?  (string-eval  "'#d+9223372036854775807")))
684   (assert-true   (tn) (integer?  (string-eval "'#d-09223372036854775808")))
685   (assert-true   (tn) (integer?  (string-eval  "'#d09223372036854775807")))
686   (assert-true   (tn) (integer?  (string-eval "'#d+09223372036854775807")))
687   (tn "integer limit hexadecimal")
688   (assert-error  (tn) (lambda () (string-read   "#x-8000000000000001")))
689   (assert-error  (tn) (lambda () (string-read    "#x8000000000000000")))
690   (assert-error  (tn) (lambda () (string-read   "#x+8000000000000000")))
691   (assert-error  (tn) (lambda () (string-read  "#x-08000000000000001")))
692   (assert-error  (tn) (lambda () (string-read   "#x08000000000000000")))
693   (assert-error  (tn) (lambda () (string-read  "#x+08000000000000000")))
694   (assert-error  (tn) (lambda () (string-read  "'#x-8000000000000001")))
695   (assert-error  (tn) (lambda () (string-read   "'#x8000000000000000")))
696   (assert-error  (tn) (lambda () (string-read  "'#x+8000000000000000")))
697   (assert-error  (tn) (lambda () (string-read "'#x-08000000000000001")))
698   (assert-error  (tn) (lambda () (string-read  "'#x08000000000000000")))
699   (assert-error  (tn) (lambda () (string-read "'#x+08000000000000000")))
700   (assert-true   (tn) (integer?  (string-read   "#x-8000000000000000")))
701   (assert-true   (tn) (integer?  (string-read    "#x7fffffffffffffff")))
702   (assert-true   (tn) (integer?  (string-read   "#x+7fffffffffffffff")))
703   (assert-true   (tn) (integer?  (string-read  "#x-08000000000000000")))
704   (assert-true   (tn) (integer?  (string-read   "#x07fffffffffffffff")))
705   (assert-true   (tn) (integer?  (string-read  "#x+07fffffffffffffff")))
706   (assert-true   (tn) (integer?  (string-eval  "'#x-8000000000000000")))
707   (assert-true   (tn) (integer?  (string-eval   "'#x7fffffffffffffff")))
708   (assert-true   (tn) (integer?  (string-eval  "'#x+7fffffffffffffff")))
709   (assert-true   (tn) (integer?  (string-eval "'#x-08000000000000000")))
710   (assert-true   (tn) (integer?  (string-eval  "'#x07fffffffffffffff")))
711   (assert-true   (tn) (integer?  (string-eval "'#x+07fffffffffffffff")))
712   (tn "integer limit octal")
713   (assert-error  (tn) (lambda () (string-read   "#o-1000000000000000000001")))
714   (assert-error  (tn) (lambda () (string-read    "#o1000000000000000000000")))
715   (assert-error  (tn) (lambda () (string-read   "#o+1000000000000000000000")))
716   (assert-error  (tn) (lambda () (string-read  "#o-01000000000000000000001")))
717   (assert-error  (tn) (lambda () (string-read   "#o01000000000000000000000")))
718   (assert-error  (tn) (lambda () (string-read  "#o+01000000000000000000000")))
719   (assert-error  (tn) (lambda () (string-read  "'#o-1000000000000000000001")))
720   (assert-error  (tn) (lambda () (string-read   "'#o1000000000000000000000")))
721   (assert-error  (tn) (lambda () (string-read  "'#o+1000000000000000000000")))
722   (assert-error  (tn) (lambda () (string-read "'#o-01000000000000000000001")))
723   (assert-error  (tn) (lambda () (string-read  "'#o01000000000000000000000")))
724   (assert-error  (tn) (lambda () (string-read "'#o+01000000000000000000000")))
725   (assert-true   (tn) (integer?  (string-read   "#o-1000000000000000000000")))
726   (assert-true   (tn) (integer?  (string-read     "#o777777777777777777777")))
727   (assert-true   (tn) (integer?  (string-read    "#o+777777777777777777777")))
728   (assert-true   (tn) (integer?  (string-read  "#o-01000000000000000000000")))
729   (assert-true   (tn) (integer?  (string-read    "#o0777777777777777777777")))
730   (assert-true   (tn) (integer?  (string-read   "#o+0777777777777777777777")))
731   (assert-true   (tn) (integer?  (string-eval  "'#o-1000000000000000000000")))
732   (assert-true   (tn) (integer?  (string-eval    "'#o777777777777777777777")))
733   (assert-true   (tn) (integer?  (string-eval   "'#o+777777777777777777777")))
734   (assert-true   (tn) (integer?  (string-eval "'#o-01000000000000000000000")))
735   (assert-true   (tn) (integer?  (string-eval   "'#o0777777777777777777777")))
736   (assert-true   (tn) (integer?  (string-eval  "'#o+0777777777777777777777")))
737   (tn "integer limit binary")
738   (assert-error  (tn) (lambda () (string-read   "#b-1000000000000000000000000000000000000000000000000000000000000001")))
739   (assert-error  (tn) (lambda () (string-read    "#b1000000000000000000000000000000000000000000000000000000000000000")))
740   (assert-error  (tn) (lambda () (string-read   "#b+1000000000000000000000000000000000000000000000000000000000000000")))
741   (assert-error  (tn) (lambda () (string-read  "#b-01000000000000000000000000000000000000000000000000000000000000001")))
742   (assert-error  (tn) (lambda () (string-read   "#b01000000000000000000000000000000000000000000000000000000000000000")))
743   (assert-error  (tn) (lambda () (string-read  "#b+01000000000000000000000000000000000000000000000000000000000000000")))
744   (assert-error  (tn) (lambda () (string-read  "'#b-1000000000000000000000000000000000000000000000000000000000000001")))
745   (assert-error  (tn) (lambda () (string-read   "'#b1000000000000000000000000000000000000000000000000000000000000000")))
746   (assert-error  (tn) (lambda () (string-read  "'#b+1000000000000000000000000000000000000000000000000000000000000000")))
747   (assert-error  (tn) (lambda () (string-read "'#b-01000000000000000000000000000000000000000000000000000000000000001")))
748   (assert-error  (tn) (lambda () (string-read  "'#b01000000000000000000000000000000000000000000000000000000000000000")))
749   (assert-error  (tn) (lambda () (string-read "'#b+01000000000000000000000000000000000000000000000000000000000000000")))
750   (assert-true   (tn) (integer?  (string-read   "#b-1000000000000000000000000000000000000000000000000000000000000000")))
751   (assert-true   (tn) (integer?  (string-read     "#b111111111111111111111111111111111111111111111111111111111111111")))
752   (assert-true   (tn) (integer?  (string-read    "#b+111111111111111111111111111111111111111111111111111111111111111")))
753   (assert-true   (tn) (integer?  (string-read  "#b-01000000000000000000000000000000000000000000000000000000000000000")))
754   (assert-true   (tn) (integer?  (string-read    "#b0111111111111111111111111111111111111111111111111111111111111111")))
755   (assert-true   (tn) (integer?  (string-read   "#b+0111111111111111111111111111111111111111111111111111111111111111")))
756   (assert-true   (tn) (integer?  (string-eval  "'#b-1000000000000000000000000000000000000000000000000000000000000000")))
757   (assert-true   (tn) (integer?  (string-eval    "'#b111111111111111111111111111111111111111111111111111111111111111")))
758   (assert-true   (tn) (integer?  (string-eval   "'#b+111111111111111111111111111111111111111111111111111111111111111")))
759   (assert-true   (tn) (integer?  (string-eval "'#b-01000000000000000000000000000000000000000000000000000000000000000")))
760   (assert-true   (tn) (integer?  (string-eval   "'#b0111111111111111111111111111111111111111111111111111111111111111")))
761   (assert-true   (tn) (integer?  (string-eval  "'#b+0111111111111111111111111111111111111111111111111111111111111111")))))
762
763
764(total-report)
765