← Back to branch summary

~ubuntu-branches/ubuntu/maverick/uim/maverick

« back to all changes in this revision

Viewing changes to sigscheme/test/test-number-literal.scm

  • Committer: Bazaar Package Importer
  • Author(s): Masahito Omote
  • Date: 2008-06-25 19:56:33 UTC
  • mfrom: (3.1.18 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080625195633-8jljph4rfq00l8o7
Tags: 1:1.5.1-2
http://bugs.debian.org/482659
http://bugs.debian.org/483078
* uim-tcode: provide tutcode-custom.scm, tutcode-bushudic.scm
  and tutcode-rule.scm (Closes: #482659)
* Fix FTBFS: segv during compile (Closes: #483078).
  I personally think this bug is not specific for uim but is a optimization
  problem on gcc-4.3.1. (https://bugs.freedesktop.org/show_bug.cgi?id=16477)

Show diffs side-by-side

added added

removed removed

Lines of Context:
sigscheme/test/test-number-literal.scm
 
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)