File: test-number-literal.scm

package info (click to toggle)
sigscheme 0.8.3-8
  • links: PTS
  • area: main
  • in suites: squeeze
  • size: 12,236 kB
  • ctags: 7,208
  • sloc: lisp: 37,498; ansic: 30,948; sh: 9,257; makefile: 744; asm: 333; ruby: 288
file content (764 lines) | stat: -rw-r--r-- 51,870 bytes parent folder | download | duplicates (14)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
;;  Filename : test-number-literal.scm
;;  About    : unit test for R5RS number literals
;;
;;  Copyright (C) 2006 YAMAMOTO Kengo <yamaken AT bp.iij4u.or.jp>
;;  Copyright (c) 2007-2008 SigScheme Project <uim-en AT googlegroups.com>
;;
;;  All rights reserved.
;;
;;  Redistribution and use in source and binary forms, with or without
;;  modification, are permitted provided that the following conditions
;;  are met:
;;
;;  1. Redistributions of source code must retain the above copyright
;;     notice, this list of conditions and the following disclaimer.
;;  2. Redistributions in binary form must reproduce the above copyright
;;     notice, this list of conditions and the following disclaimer in the
;;     documentation and/or other materials provided with the distribution.
;;  3. Neither the name of authors nor the names of its contributors
;;     may be used to endorse or promote products derived from this software
;;     without specific prior written permission.
;;
;;  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
;;  IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
;;  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
;;  PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
;;  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
;;  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
;;  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
;;  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
;;  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
;;  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
;;  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

(require-extension (unittest))

(if (not (symbol-bound? 'number?))
    (test-skip "R5RS numbers is not enabled"))

(define tn test-name)


(tn "integer implicit decimal")
(assert-equal? (tn) 0  (string-read   "-0"))
(assert-equal? (tn) 0  (string-read    "0"))
(assert-equal? (tn) 0  (string-read   "+0"))
(assert-equal? (tn) 0  (string-read  "-00"))
(assert-equal? (tn) 0  (string-read   "00"))
(assert-equal? (tn) 0  (string-read  "+00"))
(assert-equal? (tn) -9 (string-read   "-9"))
(assert-equal? (tn) 9  (string-read    "9"))
(assert-equal? (tn) 9  (string-read   "+9"))
(assert-equal? (tn) -9 (string-read  "-09"))
(assert-equal? (tn) 9  (string-read   "09"))
(assert-equal? (tn) 9  (string-read  "+09"))
(assert-equal? (tn) 0  (string-eval  "'-0"))
(assert-equal? (tn) 0  (string-eval   "'0"))
(assert-equal? (tn) 0  (string-eval  "'+0"))
(assert-equal? (tn) 0  (string-eval "'-00"))
(assert-equal? (tn) 0  (string-eval  "'00"))
(assert-equal? (tn) 0  (string-eval "'+00"))
(assert-equal? (tn) -9 (string-eval  "'-9"))
(assert-equal? (tn) 9  (string-eval   "'9"))
(assert-equal? (tn) 9  (string-eval  "'+9"))
(assert-equal? (tn) -9 (string-eval "'-09"))
(assert-equal? (tn) 9  (string-eval  "'09"))
(assert-equal? (tn) 9  (string-eval "'+09"))
(assert-equal? (tn)  238975 (string-read  "0238975"))
(assert-equal? (tn)  238975 (string-read   "238975"))
(assert-equal? (tn)  238975 (string-read  "+238975"))
(assert-equal? (tn)  238975 (string-read "+0238975"))
(assert-equal? (tn) -238975 (string-read  "-238975"))
(assert-equal? (tn) -238975 (string-read "-0238975"))
(if (>= fixnum-bits 60)
    (begin
      (tn "integer implicit decimal 64-bit")
      (string-eval "(assert-equal? (tn)  956397711204 (string-read  \"0956397711204\"))")
      (string-eval "(assert-equal? (tn)  956397711204 (string-read   \"956397711204\"))")
      (string-eval "(assert-equal? (tn)  956397711204 (string-read  \"+956397711204\"))")
      (string-eval "(assert-equal? (tn)  956397711204 (string-read \"+0956397711204\"))")
      (string-eval "(assert-equal? (tn) -956397711204 (string-read  \"-956397711204\"))")
      (string-eval "(assert-equal? (tn) -956397711204 (string-read \"-0956397711204\"))")))
(tn "integer explicit decimal")
(assert-equal? (tn) 0  (string-read   "#d-0"))
(assert-equal? (tn) 0  (string-read    "#d0"))
(assert-equal? (tn) 0  (string-read   "#d+0"))
(assert-equal? (tn) 0  (string-read  "#d-00"))
(assert-equal? (tn) 0  (string-read   "#d00"))
(assert-equal? (tn) 0  (string-read  "#d+00"))
(assert-equal? (tn) -9 (string-read   "#d-9"))
(assert-equal? (tn) 9  (string-read    "#d9"))
(assert-equal? (tn) 9  (string-read   "#d+9"))
(assert-equal? (tn) -9 (string-read  "#d-09"))
(assert-equal? (tn) 9  (string-read   "#d09"))
(assert-equal? (tn) 9  (string-read  "#d+09"))
(assert-equal? (tn) 0  (string-eval  "'#d-0"))
(assert-equal? (tn) 0  (string-eval   "'#d0"))
(assert-equal? (tn) 0  (string-eval  "'#d+0"))
(assert-equal? (tn) 0  (string-eval "'#d-00"))
(assert-equal? (tn) 0  (string-eval  "'#d00"))
(assert-equal? (tn) 0  (string-eval "'#d+00"))
(assert-equal? (tn) -9 (string-eval  "'#d-9"))
(assert-equal? (tn) 9  (string-eval   "'#d9"))
(assert-equal? (tn) 9  (string-eval  "'#d+9"))
(assert-equal? (tn) -9 (string-eval "'#d-09"))
(assert-equal? (tn) 9  (string-eval  "'#d09"))
(assert-equal? (tn) 9  (string-eval "'#d+09"))
(assert-equal? (tn)  238975 (string-read  "#d0238975"))
(assert-equal? (tn)  238975 (string-read   "#d238975"))
(assert-equal? (tn)  238975 (string-read  "#d+238975"))
(assert-equal? (tn)  238975 (string-read "#d+0238975"))
(assert-equal? (tn) -238975 (string-read  "#d-238975"))
(assert-equal? (tn) -238975 (string-read "#d-0238975"))
(if (>= fixnum-bits 60)
    (begin
      (tn "integer explicit decimal 64-bit")
      (string-eval "(assert-equal? (tn)  956397711204 (string-read  \"#d0956397711204\"))")
      (string-eval "(assert-equal? (tn)  956397711204 (string-read   \"#d956397711204\"))")
      (string-eval "(assert-equal? (tn)  956397711204 (string-read  \"#d+956397711204\"))")
      (string-eval "(assert-equal? (tn)  956397711204 (string-read \"#d+0956397711204\"))")
      (string-eval "(assert-equal? (tn) -956397711204 (string-read  \"#d-956397711204\"))")
      (string-eval "(assert-equal? (tn) -956397711204 (string-read \"#d-0956397711204\"))")))
(tn "integer hexadecimal")
(assert-equal? (tn) 0   (string-read   "#x-0"))
(assert-equal? (tn) 0   (string-read    "#x0"))
(assert-equal? (tn) 0   (string-read   "#x+0"))
(assert-equal? (tn) 0   (string-read  "#x-00"))
(assert-equal? (tn) 0   (string-read   "#x00"))
(assert-equal? (tn) 0   (string-read  "#x+00"))
(assert-equal? (tn) -15 (string-read   "#x-f"))
(assert-equal? (tn) 15  (string-read    "#xf"))
(assert-equal? (tn) 15  (string-read   "#x+f"))
(assert-equal? (tn) -15 (string-read  "#x-0f"))
(assert-equal? (tn) 15  (string-read   "#x0f"))
(assert-equal? (tn) 15  (string-read  "#x+0f"))
(assert-equal? (tn) -15 (string-read   "#x-F"))
(assert-equal? (tn) 15  (string-read    "#xF"))
(assert-equal? (tn) 15  (string-read   "#x+F"))
(assert-equal? (tn) -15 (string-read  "#x-0F"))
(assert-equal? (tn) 15  (string-read   "#x0F"))
(assert-equal? (tn) 15  (string-read  "#x+0F"))
(assert-equal? (tn) 0   (string-eval  "'#x-0"))
(assert-equal? (tn) 0   (string-eval   "'#x0"))
(assert-equal? (tn) 0   (string-eval  "'#x+0"))
(assert-equal? (tn) 0   (string-eval "'#x-00"))
(assert-equal? (tn) 0   (string-eval  "'#x00"))
(assert-equal? (tn) 0   (string-eval "'#x+00"))
(assert-equal? (tn) -15 (string-eval  "'#x-f"))
(assert-equal? (tn) 15  (string-eval   "'#xf"))
(assert-equal? (tn) 15  (string-eval  "'#x+f"))
(assert-equal? (tn) -15 (string-eval "'#x-0f"))
(assert-equal? (tn) 15  (string-eval  "'#x0f"))
(assert-equal? (tn) 15  (string-eval "'#x+0f"))
(assert-equal? (tn) -15 (string-eval  "'#x-F"))
(assert-equal? (tn) 15  (string-eval   "'#xF"))
(assert-equal? (tn) 15  (string-eval  "'#x+F"))
(assert-equal? (tn) -15 (string-eval "'#x-0F"))
(assert-equal? (tn) 15  (string-eval  "'#x0F"))
(assert-equal? (tn) 15  (string-eval "'#x+0F"))
(assert-equal? (tn)  14593330 (string-read  "#x0deAd32"))
(assert-equal? (tn)  14593330 (string-read   "#xdeAd32"))
(assert-equal? (tn)  14593330 (string-read  "#x+dEad32"))
(assert-equal? (tn)  14593330 (string-read "#x+0dEad32"))
(assert-equal? (tn) -14593330 (string-read  "#x-deaD32"))
(assert-equal? (tn) -14593330 (string-read "#x-0deaD32"))
(assert-equal? (tn)   3333805 (string-read   "#x32deAd"))
(assert-equal? (tn)   3333805 (string-read  "#x+32dEad"))
(assert-equal? (tn)  -3333805 (string-read  "#x-32deaD"))
(if (>= fixnum-bits 60)
    (begin
      (tn "integer hexadecimal 64-bit")
      (string-eval "(assert-equal? (tn)  956397711204 (string-read  \"#x0deadbeef64\"))")
      (string-eval "(assert-equal? (tn)  956397711204 (string-read   \"#xdeadbeef64\"))")
      (string-eval "(assert-equal? (tn)  956397711204 (string-read  \"#x+deadbeef64\"))")
      (string-eval "(assert-equal? (tn)  956397711204 (string-read \"#x+0deadbeef64\"))")
      (string-eval "(assert-equal? (tn) -956397711204 (string-read  \"#x-deadbeef64\"))")
      (string-eval "(assert-equal? (tn) -956397711204 (string-read \"#x-0deadbeef64\"))")))
(tn "integer octal")
(assert-equal? (tn) 0  (string-read   "#o-0"))
(assert-equal? (tn) 0  (string-read    "#o0"))
(assert-equal? (tn) 0  (string-read   "#o+0"))
(assert-equal? (tn) 0  (string-read  "#o-00"))
(assert-equal? (tn) 0  (string-read   "#o00"))
(assert-equal? (tn) 0  (string-read  "#o+00"))
(assert-equal? (tn) -7 (string-read   "#o-7"))
(assert-equal? (tn) 7  (string-read    "#o7"))
(assert-equal? (tn) 7  (string-read   "#o+7"))
(assert-equal? (tn) -7 (string-read  "#o-07"))
(assert-equal? (tn) 7  (string-read   "#o07"))
(assert-equal? (tn) 7  (string-read  "#o+07"))
(assert-equal? (tn) 0  (string-eval  "'#o-0"))
(assert-equal? (tn) 0  (string-eval   "'#o0"))
(assert-equal? (tn) 0  (string-eval  "'#o+0"))
(assert-equal? (tn) 0  (string-eval "'#o-00"))
(assert-equal? (tn) 0  (string-eval  "'#o00"))
(assert-equal? (tn) 0  (string-eval "'#o+00"))
(assert-equal? (tn) -7 (string-eval  "'#o-7"))
(assert-equal? (tn) 7  (string-eval   "'#o7"))
(assert-equal? (tn) 7  (string-eval  "'#o+7"))
(assert-equal? (tn) -7 (string-eval "'#o-07"))
(assert-equal? (tn) 7  (string-eval  "'#o07"))
(assert-equal? (tn) 7  (string-eval "'#o+07"))
(assert-equal? (tn)  1556392 (string-read  "#o05737650"))
(assert-equal? (tn)  1556392 (string-read   "#o5737650"))
(assert-equal? (tn)  1556392 (string-read  "#o+5737650"))
(assert-equal? (tn)  1556392 (string-read "#o+05737650"))
(assert-equal? (tn) -1556392 (string-read  "#o-5737650"))
(assert-equal? (tn) -1556392 (string-read "#o-05737650"))
(if (>= fixnum-bits 60)
    (begin
      (tn "integer octal 64-bit")
      (string-eval "(assert-equal? (tn)  956397711204 (string-read  \"#o015725557567544\"))")
      (string-eval "(assert-equal? (tn)  956397711204 (string-read   \"#o15725557567544\"))")
      (string-eval "(assert-equal? (tn)  956397711204 (string-read  \"#o+15725557567544\"))")
      (string-eval "(assert-equal? (tn)  956397711204 (string-read \"#o+015725557567544\"))")
      (string-eval "(assert-equal? (tn) -956397711204 (string-read  \"#o-15725557567544\"))")
      (string-eval "(assert-equal? (tn) -956397711204 (string-read \"#o-015725557567544\"))")))
(tn "integer binary")
(assert-equal? (tn) 0  (string-read   "#b-0"))
(assert-equal? (tn) 0  (string-read    "#b0"))
(assert-equal? (tn) 0  (string-read   "#b+0"))
(assert-equal? (tn) 0  (string-read  "#b-00"))
(assert-equal? (tn) 0  (string-read   "#b00"))
(assert-equal? (tn) 0  (string-read  "#b+00"))
(assert-equal? (tn) -1 (string-read   "#b-1"))
(assert-equal? (tn) 1  (string-read    "#b1"))
(assert-equal? (tn) 1  (string-read   "#b+1"))
(assert-equal? (tn) -1 (string-read  "#b-01"))
(assert-equal? (tn) 1  (string-read   "#b01"))
(assert-equal? (tn) 1  (string-read  "#b+01"))
(assert-equal? (tn) 0  (string-eval  "'#b-0"))
(assert-equal? (tn) 0  (string-eval   "'#b0"))
(assert-equal? (tn) 0  (string-eval  "'#b+0"))
(assert-equal? (tn) 0  (string-eval "'#b-00"))
(assert-equal? (tn) 0  (string-eval  "'#b00"))
(assert-equal? (tn) 0  (string-eval "'#b+00"))
(assert-equal? (tn) -1 (string-eval  "'#b-1"))
(assert-equal? (tn) 1  (string-eval   "'#b1"))
(assert-equal? (tn) 1  (string-eval  "'#b+1"))
(assert-equal? (tn) -1 (string-eval "'#b-01"))
(assert-equal? (tn) 1  (string-eval  "'#b01"))
(assert-equal? (tn) 1  (string-eval "'#b+01"))
(assert-equal? (tn)  2990842 (string-read  "#b01011011010001011111010"))
(assert-equal? (tn)  2990842 (string-read   "#b1011011010001011111010"))
(assert-equal? (tn)  2990842 (string-read  "#b+1011011010001011111010"))
(assert-equal? (tn)  2990842 (string-read "#b+01011011010001011111010"))
(assert-equal? (tn) -2990842 (string-read  "#b-1011011010001011111010"))
(assert-equal? (tn) -2990842 (string-read "#b-01011011010001011111010"))
(if (>= fixnum-bits 60)
    (begin
      (tn "integer binary 64-bit")
      (string-eval "(assert-equal? (tn)  956397711204 (string-read  \"#b01101111010101101101111101110111101100100\"))")
      (string-eval "(assert-equal? (tn)  956397711204 (string-read   \"#b1101111010101101101111101110111101100100\"))")
      (string-eval "(assert-equal? (tn)  956397711204 (string-read  \"#b+1101111010101101101111101110111101100100\"))")
      (string-eval "(assert-equal? (tn)  956397711204 (string-read \"#b+01101111010101101101111101110111101100100\"))")
      (string-eval "(assert-equal? (tn) -956397711204 (string-read  \"#b-1101111010101101101111101110111101100100\"))")
      (string-eval "(assert-equal? (tn) -956397711204 (string-read \"#b-01101111010101101101111101110111101100100\"))")))
(case fixnum-bits
  ((28)
   (tn "integer limit implicit decimal")
   (assert-error  (tn) (lambda () (string-read     "-134217729")))
   (assert-error  (tn) (lambda () (string-read      "134217728")))
   (assert-error  (tn) (lambda () (string-read     "+134217728")))
   (assert-error  (tn) (lambda () (string-read    "-0134217729")))
   (assert-error  (tn) (lambda () (string-read     "0134217728")))
   (assert-error  (tn) (lambda () (string-read    "+0134217728")))
   (assert-error  (tn) (lambda () (string-read    "'-134217729")))
   (assert-error  (tn) (lambda () (string-read     "'134217728")))
   (assert-error  (tn) (lambda () (string-read    "'+134217728")))
   (assert-error  (tn) (lambda () (string-read   "'-0134217729")))
   (assert-error  (tn) (lambda () (string-read    "'0134217728")))
   (assert-error  (tn) (lambda () (string-read   "'+0134217728")))
   (assert-true   (tn) (integer?  (string-read     "-134217728")))
   (assert-true   (tn) (integer?  (string-read      "134217727")))
   (assert-true   (tn) (integer?  (string-read     "+134217727")))
   (assert-true   (tn) (integer?  (string-read    "-0134217728")))
   (assert-true   (tn) (integer?  (string-read     "0134217727")))
   (assert-true   (tn) (integer?  (string-read    "+0134217727")))
   (assert-true   (tn) (integer?  (string-eval    "'-134217728")))
   (assert-true   (tn) (integer?  (string-eval     "'134217727")))
   (assert-true   (tn) (integer?  (string-eval    "'+134217727")))
   (assert-true   (tn) (integer?  (string-eval   "'-0134217728")))
   (assert-true   (tn) (integer?  (string-eval    "'0134217727")))
   (assert-true   (tn) (integer?  (string-eval   "'+0134217727")))
   (tn "integer limit explicit decimal")
   (assert-error  (tn) (lambda () (string-read   "#d-134217729")))
   (assert-error  (tn) (lambda () (string-read    "#d134217728")))
   (assert-error  (tn) (lambda () (string-read   "#d+134217728")))
   (assert-error  (tn) (lambda () (string-read  "#d-0134217729")))
   (assert-error  (tn) (lambda () (string-read   "#d0134217728")))
   (assert-error  (tn) (lambda () (string-read  "#d+0134217728")))
   (assert-error  (tn) (lambda () (string-read  "'#d-134217729")))
   (assert-error  (tn) (lambda () (string-read   "'#d134217728")))
   (assert-error  (tn) (lambda () (string-read  "'#d+134217728")))
   (assert-error  (tn) (lambda () (string-read "'#d-0134217729")))
   (assert-error  (tn) (lambda () (string-read  "'#d0134217728")))
   (assert-error  (tn) (lambda () (string-read "'#d+0134217728")))
   (assert-true   (tn) (integer?  (string-read   "#d-134217728")))
   (assert-true   (tn) (integer?  (string-read    "#d134217727")))
   (assert-true   (tn) (integer?  (string-read   "#d+134217727")))
   (assert-true   (tn) (integer?  (string-read  "#d-0134217728")))
   (assert-true   (tn) (integer?  (string-read   "#d0134217727")))
   (assert-true   (tn) (integer?  (string-read  "#d+0134217727")))
   (assert-true   (tn) (integer?  (string-eval  "'#d-134217728")))
   (assert-true   (tn) (integer?  (string-eval   "'#d134217727")))
   (assert-true   (tn) (integer?  (string-eval  "'#d+134217727")))
   (assert-true   (tn) (integer?  (string-eval "'#d-0134217728")))
   (assert-true   (tn) (integer?  (string-eval  "'#d0134217727")))
   (assert-true   (tn) (integer?  (string-eval "'#d+0134217727")))
   (tn "integer limit hexadecimal")
   (assert-error  (tn) (lambda () (string-read   "#x-8000001")))
   (assert-error  (tn) (lambda () (string-read    "#x8000000")))
   (assert-error  (tn) (lambda () (string-read   "#x+8000000")))
   (assert-error  (tn) (lambda () (string-read  "#x-08000001")))
   (assert-error  (tn) (lambda () (string-read   "#x08000000")))
   (assert-error  (tn) (lambda () (string-read  "#x+08000000")))
   (assert-error  (tn) (lambda () (string-read  "'#x-8000001")))
   (assert-error  (tn) (lambda () (string-read   "'#x8000000")))
   (assert-error  (tn) (lambda () (string-read  "'#x+8000000")))
   (assert-error  (tn) (lambda () (string-read "'#x-08000001")))
   (assert-error  (tn) (lambda () (string-read  "'#x08000000")))
   (assert-error  (tn) (lambda () (string-read "'#x+08000000")))
   (assert-true   (tn) (integer?  (string-read   "#x-8000000")))
   (assert-true   (tn) (integer?  (string-read    "#x7ffffff")))
   (assert-true   (tn) (integer?  (string-read   "#x+7ffffff")))
   (assert-true   (tn) (integer?  (string-read  "#x-08000000")))
   (assert-true   (tn) (integer?  (string-read   "#x07ffffff")))
   (assert-true   (tn) (integer?  (string-read  "#x+07ffffff")))
   (assert-true   (tn) (integer?  (string-eval  "'#x-8000000")))
   (assert-true   (tn) (integer?  (string-eval   "'#x7ffffff")))
   (assert-true   (tn) (integer?  (string-eval  "'#x+7ffffff")))
   (assert-true   (tn) (integer?  (string-eval "'#x-08000000")))
   (assert-true   (tn) (integer?  (string-eval  "'#x07ffffff")))
   (assert-true   (tn) (integer?  (string-eval "'#x+07ffffff")))
   (tn "integer limit octal")
   (assert-error  (tn) (lambda () (string-read   "#o-1000000001")))
   (assert-error  (tn) (lambda () (string-read    "#o1000000000")))
   (assert-error  (tn) (lambda () (string-read   "#o+1000000000")))
   (assert-error  (tn) (lambda () (string-read  "#o-01000000001")))
   (assert-error  (tn) (lambda () (string-read   "#o01000000000")))
   (assert-error  (tn) (lambda () (string-read  "#o+01000000000")))
   (assert-error  (tn) (lambda () (string-read  "'#o-1000000001")))
   (assert-error  (tn) (lambda () (string-read   "'#o1000000000")))
   (assert-error  (tn) (lambda () (string-read  "'#o+1000000000")))
   (assert-error  (tn) (lambda () (string-read "'#o-01000000001")))
   (assert-error  (tn) (lambda () (string-read  "'#o01000000000")))
   (assert-error  (tn) (lambda () (string-read "'#o+01000000000")))
   (assert-true   (tn) (integer?  (string-read   "#o-1000000000")))
   (assert-true   (tn) (integer?  (string-read     "#o777777777")))
   (assert-true   (tn) (integer?  (string-read    "#o+777777777")))
   (assert-true   (tn) (integer?  (string-read  "#o-01000000000")))
   (assert-true   (tn) (integer?  (string-read    "#o0777777777")))
   (assert-true   (tn) (integer?  (string-read   "#o+0777777777")))
   (assert-true   (tn) (integer?  (string-eval  "'#o-1000000000")))
   (assert-true   (tn) (integer?  (string-eval    "'#o777777777")))
   (assert-true   (tn) (integer?  (string-eval   "'#o+777777777")))
   (assert-true   (tn) (integer?  (string-eval "'#o-01000000000")))
   (assert-true   (tn) (integer?  (string-eval   "'#o0777777777")))
   (assert-true   (tn) (integer?  (string-eval  "'#o+0777777777")))
   (tn "integer limit binary")
   (assert-error  (tn) (lambda () (string-read   "#b-1000000000000000000000000001")))
   (assert-error  (tn) (lambda () (string-read    "#b1000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read   "#b+1000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "#b-01000000000000000000000000001")))
   (assert-error  (tn) (lambda () (string-read   "#b01000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "#b+01000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "'#b-1000000000000000000000000001")))
   (assert-error  (tn) (lambda () (string-read   "'#b1000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "'#b+1000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read "'#b-01000000000000000000000000001")))
   (assert-error  (tn) (lambda () (string-read  "'#b01000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read "'#b+01000000000000000000000000000")))
   (assert-true   (tn) (integer?  (string-read   "#b-1000000000000000000000000000")))
   (assert-true   (tn) (integer?  (string-read     "#b111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-read    "#b+111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-read  "#b-01000000000000000000000000000")))
   (assert-true   (tn) (integer?  (string-read    "#b0111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-read   "#b+0111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-eval  "'#b-1000000000000000000000000000")))
   (assert-true   (tn) (integer?  (string-eval    "'#b111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-eval   "'#b+111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-eval "'#b-01000000000000000000000000000")))
   (assert-true   (tn) (integer?  (string-eval   "'#b0111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-eval  "'#b+0111111111111111111111111111"))))
  ((32)
   (tn "integer limit implicit decimal")
   (assert-error  (tn) (lambda () (string-read     "-2147483649")))
   (assert-error  (tn) (lambda () (string-read      "2147483648")))
   (assert-error  (tn) (lambda () (string-read     "+2147483648")))
   (assert-error  (tn) (lambda () (string-read    "-02147483649")))
   (assert-error  (tn) (lambda () (string-read     "02147483648")))
   (assert-error  (tn) (lambda () (string-read    "+02147483648")))
   (assert-error  (tn) (lambda () (string-read    "'-2147483649")))
   (assert-error  (tn) (lambda () (string-read     "'2147483648")))
   (assert-error  (tn) (lambda () (string-read    "'+2147483648")))
   (assert-error  (tn) (lambda () (string-read   "'-02147483649")))
   (assert-error  (tn) (lambda () (string-read    "'02147483648")))
   (assert-error  (tn) (lambda () (string-read   "'+02147483648")))
   (assert-true   (tn) (integer?  (string-read     "-2147483648")))
   (assert-true   (tn) (integer?  (string-read      "2147483647")))
   (assert-true   (tn) (integer?  (string-read     "+2147483647")))
   (assert-true   (tn) (integer?  (string-read    "-02147483648")))
   (assert-true   (tn) (integer?  (string-read     "02147483647")))
   (assert-true   (tn) (integer?  (string-read    "+02147483647")))
   (assert-true   (tn) (integer?  (string-eval    "'-2147483648")))
   (assert-true   (tn) (integer?  (string-eval     "'2147483647")))
   (assert-true   (tn) (integer?  (string-eval    "'+2147483647")))
   (assert-true   (tn) (integer?  (string-eval   "'-02147483648")))
   (assert-true   (tn) (integer?  (string-eval    "'02147483647")))
   (assert-true   (tn) (integer?  (string-eval   "'+02147483647")))
   (tn "integer limit explicit decimal")
   (assert-error  (tn) (lambda () (string-read   "#d-2147483649")))
   (assert-error  (tn) (lambda () (string-read    "#d2147483648")))
   (assert-error  (tn) (lambda () (string-read   "#d+2147483648")))
   (assert-error  (tn) (lambda () (string-read  "#d-02147483649")))
   (assert-error  (tn) (lambda () (string-read   "#d02147483648")))
   (assert-error  (tn) (lambda () (string-read  "#d+02147483648")))
   (assert-error  (tn) (lambda () (string-read  "'#d-2147483649")))
   (assert-error  (tn) (lambda () (string-read   "'#d2147483648")))
   (assert-error  (tn) (lambda () (string-read  "'#d+2147483648")))
   (assert-error  (tn) (lambda () (string-read "'#d-02147483649")))
   (assert-error  (tn) (lambda () (string-read  "'#d02147483648")))
   (assert-error  (tn) (lambda () (string-read "'#d+02147483648")))
   (assert-true   (tn) (integer?  (string-read   "#d-2147483648")))
   (assert-true   (tn) (integer?  (string-read    "#d2147483647")))
   (assert-true   (tn) (integer?  (string-read   "#d+2147483647")))
   (assert-true   (tn) (integer?  (string-read  "#d-02147483648")))
   (assert-true   (tn) (integer?  (string-read   "#d02147483647")))
   (assert-true   (tn) (integer?  (string-read  "#d+02147483647")))
   (assert-true   (tn) (integer?  (string-eval  "'#d-2147483648")))
   (assert-true   (tn) (integer?  (string-eval   "'#d2147483647")))
   (assert-true   (tn) (integer?  (string-eval  "'#d+2147483647")))
   (assert-true   (tn) (integer?  (string-eval "'#d-02147483648")))
   (assert-true   (tn) (integer?  (string-eval  "'#d02147483647")))
   (assert-true   (tn) (integer?  (string-eval "'#d+02147483647")))
   (tn "integer limit hexadecimal")
   (assert-error  (tn) (lambda () (string-read   "#x-80000001")))
   (assert-error  (tn) (lambda () (string-read    "#x80000000")))
   (assert-error  (tn) (lambda () (string-read   "#x+80000000")))
   (assert-error  (tn) (lambda () (string-read  "#x-080000001")))
   (assert-error  (tn) (lambda () (string-read   "#x080000000")))
   (assert-error  (tn) (lambda () (string-read  "#x+080000000")))
   (assert-error  (tn) (lambda () (string-read  "'#x-80000001")))
   (assert-error  (tn) (lambda () (string-read   "'#x80000000")))
   (assert-error  (tn) (lambda () (string-read  "'#x+80000000")))
   (assert-error  (tn) (lambda () (string-read "'#x-080000001")))
   (assert-error  (tn) (lambda () (string-read  "'#x080000000")))
   (assert-error  (tn) (lambda () (string-read "'#x+080000000")))
   (assert-true   (tn) (integer?  (string-read   "#x-80000000")))
   (assert-true   (tn) (integer?  (string-read    "#x7fffffff")))
   (assert-true   (tn) (integer?  (string-read   "#x+7fffffff")))
   (assert-true   (tn) (integer?  (string-read  "#x-080000000")))
   (assert-true   (tn) (integer?  (string-read   "#x07fffffff")))
   (assert-true   (tn) (integer?  (string-read  "#x+07fffffff")))
   (assert-true   (tn) (integer?  (string-eval  "'#x-80000000")))
   (assert-true   (tn) (integer?  (string-eval   "'#x7fffffff")))
   (assert-true   (tn) (integer?  (string-eval  "'#x+7fffffff")))
   (assert-true   (tn) (integer?  (string-eval "'#x-080000000")))
   (assert-true   (tn) (integer?  (string-eval  "'#x07fffffff")))
   (assert-true   (tn) (integer?  (string-eval "'#x+07fffffff")))
   (tn "integer limit octal")
   (assert-error  (tn) (lambda () (string-read   "#o-20000000001")))
   (assert-error  (tn) (lambda () (string-read    "#o20000000000")))
   (assert-error  (tn) (lambda () (string-read   "#o+20000000000")))
   (assert-error  (tn) (lambda () (string-read  "#o-020000000001")))
   (assert-error  (tn) (lambda () (string-read   "#o020000000000")))
   (assert-error  (tn) (lambda () (string-read  "#o+020000000000")))
   (assert-error  (tn) (lambda () (string-read  "'#o-20000000001")))
   (assert-error  (tn) (lambda () (string-read   "'#o20000000000")))
   (assert-error  (tn) (lambda () (string-read  "'#o+20000000000")))
   (assert-error  (tn) (lambda () (string-read "'#o-020000000001")))
   (assert-error  (tn) (lambda () (string-read  "'#o020000000000")))
   (assert-error  (tn) (lambda () (string-read "'#o+020000000000")))
   (assert-true   (tn) (integer?  (string-read   "#o-20000000000")))
   (assert-true   (tn) (integer?  (string-read    "#o17777777777")))
   (assert-true   (tn) (integer?  (string-read   "#o+17777777777")))
   (assert-true   (tn) (integer?  (string-read  "#o-020000000000")))
   (assert-true   (tn) (integer?  (string-read   "#o017777777777")))
   (assert-true   (tn) (integer?  (string-read  "#o+017777777777")))
   (assert-true   (tn) (integer?  (string-eval  "'#o-20000000000")))
   (assert-true   (tn) (integer?  (string-eval   "'#o17777777777")))
   (assert-true   (tn) (integer?  (string-eval  "'#o+17777777777")))
   (assert-true   (tn) (integer?  (string-eval "'#o-020000000000")))
   (assert-true   (tn) (integer?  (string-eval  "'#o017777777777")))
   (assert-true   (tn) (integer?  (string-eval "'#o+017777777777")))
   (tn "integer limit binary")
   (assert-error  (tn) (lambda () (string-read   "#b-10000000000000000000000000000001")))
   (assert-error  (tn) (lambda () (string-read    "#b10000000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read   "#b+10000000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "#b-010000000000000000000000000000001")))
   (assert-error  (tn) (lambda () (string-read   "#b010000000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "#b+010000000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "'#b-10000000000000000000000000000001")))
   (assert-error  (tn) (lambda () (string-read   "'#b10000000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "'#b+10000000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read "'#b-010000000000000000000000000000001")))
   (assert-error  (tn) (lambda () (string-read  "'#b010000000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read "'#b+010000000000000000000000000000000")))
   (assert-true   (tn) (integer?  (string-read   "#b-10000000000000000000000000000000")))
   (assert-true   (tn) (integer?  (string-read     "#b1111111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-read    "#b+1111111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-read  "#b-010000000000000000000000000000000")))
   (assert-true   (tn) (integer?  (string-read    "#b01111111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-read   "#b+01111111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-eval  "'#b-10000000000000000000000000000000")))
   (assert-true   (tn) (integer?  (string-eval    "'#b1111111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-eval   "'#b+1111111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-eval "'#b-010000000000000000000000000000000")))
   (assert-true   (tn) (integer?  (string-eval   "'#b01111111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-eval  "'#b+01111111111111111111111111111111"))))
  ((60)
   (tn "integer limit implicit decimal")
   (assert-error  (tn) (lambda () (string-read     "-576460752303423489")))
   (assert-error  (tn) (lambda () (string-read      "576460752303423488")))
   (assert-error  (tn) (lambda () (string-read     "+576460752303423488")))
   (assert-error  (tn) (lambda () (string-read    "-0576460752303423489")))
   (assert-error  (tn) (lambda () (string-read     "0576460752303423488")))
   (assert-error  (tn) (lambda () (string-read    "+0576460752303423488")))
   (assert-error  (tn) (lambda () (string-read    "'-576460752303423489")))
   (assert-error  (tn) (lambda () (string-read     "'576460752303423488")))
   (assert-error  (tn) (lambda () (string-read    "'+576460752303423488")))
   (assert-error  (tn) (lambda () (string-read   "'-0576460752303423489")))
   (assert-error  (tn) (lambda () (string-read    "'0576460752303423488")))
   (assert-error  (tn) (lambda () (string-read   "'+0576460752303423488")))
   (assert-true   (tn) (integer?  (string-read     "-576460752303423488")))
   (assert-true   (tn) (integer?  (string-read      "576460752303423487")))
   (assert-true   (tn) (integer?  (string-read     "+576460752303423487")))
   (assert-true   (tn) (integer?  (string-read    "-0576460752303423488")))
   (assert-true   (tn) (integer?  (string-read     "0576460752303423487")))
   (assert-true   (tn) (integer?  (string-read    "+0576460752303423487")))
   (assert-true   (tn) (integer?  (string-eval    "'-576460752303423488")))
   (assert-true   (tn) (integer?  (string-eval     "'576460752303423487")))
   (assert-true   (tn) (integer?  (string-eval    "'+576460752303423487")))
   (assert-true   (tn) (integer?  (string-eval   "'-0576460752303423488")))
   (assert-true   (tn) (integer?  (string-eval    "'0576460752303423487")))
   (assert-true   (tn) (integer?  (string-eval   "'+0576460752303423487")))
   (tn "integer limit explicit decimal")
   (assert-error  (tn) (lambda () (string-read   "#d-576460752303423489")))
   (assert-error  (tn) (lambda () (string-read    "#d576460752303423488")))
   (assert-error  (tn) (lambda () (string-read   "#d+576460752303423488")))
   (assert-error  (tn) (lambda () (string-read  "#d-0576460752303423489")))
   (assert-error  (tn) (lambda () (string-read   "#d0576460752303423488")))
   (assert-error  (tn) (lambda () (string-read  "#d+0576460752303423488")))
   (assert-error  (tn) (lambda () (string-read  "'#d-576460752303423489")))
   (assert-error  (tn) (lambda () (string-read   "'#d576460752303423488")))
   (assert-error  (tn) (lambda () (string-read  "'#d+576460752303423488")))
   (assert-error  (tn) (lambda () (string-read "'#d-0576460752303423489")))
   (assert-error  (tn) (lambda () (string-read  "'#d0576460752303423488")))
   (assert-error  (tn) (lambda () (string-read "'#d+0576460752303423488")))
   (assert-true   (tn) (integer?  (string-read   "#d-576460752303423488")))
   (assert-true   (tn) (integer?  (string-read    "#d576460752303423487")))
   (assert-true   (tn) (integer?  (string-read   "#d+576460752303423487")))
   (assert-true   (tn) (integer?  (string-read  "#d-0576460752303423488")))
   (assert-true   (tn) (integer?  (string-read   "#d0576460752303423487")))
   (assert-true   (tn) (integer?  (string-read  "#d+0576460752303423487")))
   (assert-true   (tn) (integer?  (string-eval  "'#d-576460752303423488")))
   (assert-true   (tn) (integer?  (string-eval   "'#d576460752303423487")))
   (assert-true   (tn) (integer?  (string-eval  "'#d+576460752303423487")))
   (assert-true   (tn) (integer?  (string-eval "'#d-0576460752303423488")))
   (assert-true   (tn) (integer?  (string-eval  "'#d0576460752303423487")))
   (assert-true   (tn) (integer?  (string-eval "'#d+0576460752303423487")))
   (tn "integer limit hexadecimal")
   (assert-error  (tn) (lambda () (string-read   "#x-800000000000001")))
   (assert-error  (tn) (lambda () (string-read    "#x800000000000000")))
   (assert-error  (tn) (lambda () (string-read   "#x+800000000000000")))
   (assert-error  (tn) (lambda () (string-read  "#x-0800000000000001")))
   (assert-error  (tn) (lambda () (string-read   "#x0800000000000000")))
   (assert-error  (tn) (lambda () (string-read  "#x+0800000000000000")))
   (assert-error  (tn) (lambda () (string-read  "'#x-800000000000001")))
   (assert-error  (tn) (lambda () (string-read   "'#x800000000000000")))
   (assert-error  (tn) (lambda () (string-read  "'#x+800000000000000")))
   (assert-error  (tn) (lambda () (string-read "'#x-0800000000000001")))
   (assert-error  (tn) (lambda () (string-read  "'#x0800000000000000")))
   (assert-error  (tn) (lambda () (string-read "'#x+0800000000000000")))
   (assert-true   (tn) (integer?  (string-read   "#x-800000000000000")))
   (assert-true   (tn) (integer?  (string-read    "#x7ffffffffffffff")))
   (assert-true   (tn) (integer?  (string-read   "#x+7ffffffffffffff")))
   (assert-true   (tn) (integer?  (string-read  "#x-0800000000000000")))
   (assert-true   (tn) (integer?  (string-read   "#x07ffffffffffffff")))
   (assert-true   (tn) (integer?  (string-read  "#x+07ffffffffffffff")))
   (assert-true   (tn) (integer?  (string-eval  "'#x-800000000000000")))
   (assert-true   (tn) (integer?  (string-eval   "'#x7ffffffffffffff")))
   (assert-true   (tn) (integer?  (string-eval  "'#x+7ffffffffffffff")))
   (assert-true   (tn) (integer?  (string-eval "'#x-0800000000000000")))
   (assert-true   (tn) (integer?  (string-eval  "'#x07ffffffffffffff")))
   (assert-true   (tn) (integer?  (string-eval "'#x+07ffffffffffffff")))
   (tn "integer limit octal")
   (assert-error  (tn) (lambda () (string-read   "#o-40000000000000000001")))
   (assert-error  (tn) (lambda () (string-read    "#o40000000000000000000")))
   (assert-error  (tn) (lambda () (string-read   "#o+40000000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "#o-040000000000000000001")))
   (assert-error  (tn) (lambda () (string-read   "#o040000000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "#o+040000000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "'#o-40000000000000000001")))
   (assert-error  (tn) (lambda () (string-read   "'#o40000000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "'#o+40000000000000000000")))
   (assert-error  (tn) (lambda () (string-read "'#o-040000000000000000001")))
   (assert-error  (tn) (lambda () (string-read  "'#o040000000000000000000")))
   (assert-error  (tn) (lambda () (string-read "'#o+040000000000000000000")))
   (assert-true   (tn) (integer?  (string-read   "#o-40000000000000000000")))
   (assert-true   (tn) (integer?  (string-read    "#o37777777777777777777")))
   (assert-true   (tn) (integer?  (string-read   "#o+37777777777777777777")))
   (assert-true   (tn) (integer?  (string-read  "#o-040000000000000000000")))
   (assert-true   (tn) (integer?  (string-read   "#o037777777777777777777")))
   (assert-true   (tn) (integer?  (string-read  "#o+037777777777777777777")))
   (assert-true   (tn) (integer?  (string-eval  "'#o-40000000000000000000")))
   (assert-true   (tn) (integer?  (string-eval   "'#o37777777777777777777")))
   (assert-true   (tn) (integer?  (string-eval  "'#o+37777777777777777777")))
   (assert-true   (tn) (integer?  (string-eval "'#o-040000000000000000000")))
   (assert-true   (tn) (integer?  (string-eval  "'#o037777777777777777777")))
   (assert-true   (tn) (integer?  (string-eval "'#o+037777777777777777777")))
   (tn "integer limit binary")
   (assert-error  (tn) (lambda () (string-read   "#b-100000000000000000000000000000000000000000000000000000000001")))
   (assert-error  (tn) (lambda () (string-read    "#b100000000000000000000000000000000000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read   "#b+100000000000000000000000000000000000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "#b-0100000000000000000000000000000000000000000000000000000000001")))
   (assert-error  (tn) (lambda () (string-read   "#b0100000000000000000000000000000000000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "#b+0100000000000000000000000000000000000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "'#b-100000000000000000000000000000000000000000000000000000000001")))
   (assert-error  (tn) (lambda () (string-read   "'#b100000000000000000000000000000000000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "'#b+100000000000000000000000000000000000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read "'#b-0100000000000000000000000000000000000000000000000000000000001")))
   (assert-error  (tn) (lambda () (string-read  "'#b0100000000000000000000000000000000000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read "'#b+0100000000000000000000000000000000000000000000000000000000000")))
   (assert-true   (tn) (integer?  (string-read   "#b-100000000000000000000000000000000000000000000000000000000000")))
   (assert-true   (tn) (integer?  (string-read     "#b11111111111111111111111111111111111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-read    "#b+11111111111111111111111111111111111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-read  "#b-0100000000000000000000000000000000000000000000000000000000000")))
   (assert-true   (tn) (integer?  (string-read    "#b011111111111111111111111111111111111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-read   "#b+011111111111111111111111111111111111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-eval  "'#b-100000000000000000000000000000000000000000000000000000000000")))
   (assert-true   (tn) (integer?  (string-eval    "'#b11111111111111111111111111111111111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-eval   "'#b+11111111111111111111111111111111111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-eval "'#b-0100000000000000000000000000000000000000000000000000000000000")))
   (assert-true   (tn) (integer?  (string-eval   "'#b011111111111111111111111111111111111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-eval  "'#b+011111111111111111111111111111111111111111111111111111111111"))))
  ((64)
   (tn "integer limit implicit decimal")
   (assert-error  (tn) (lambda () (string-read     "-9223372036854775809")))
   (assert-error  (tn) (lambda () (string-read      "9223372036854775808")))
   (assert-error  (tn) (lambda () (string-read     "+9223372036854775808")))
   (assert-error  (tn) (lambda () (string-read    "-09223372036854775809")))
   (assert-error  (tn) (lambda () (string-read     "09223372036854775808")))
   (assert-error  (tn) (lambda () (string-read    "+09223372036854775808")))
   (assert-error  (tn) (lambda () (string-read    "'-9223372036854775809")))
   (assert-error  (tn) (lambda () (string-read     "'9223372036854775808")))
   (assert-error  (tn) (lambda () (string-read    "'+9223372036854775808")))
   (assert-error  (tn) (lambda () (string-read   "'-09223372036854775809")))
   (assert-error  (tn) (lambda () (string-read    "'09223372036854775808")))
   (assert-error  (tn) (lambda () (string-read   "'+09223372036854775808")))
   (assert-true   (tn) (integer?  (string-read     "-9223372036854775808")))
   (assert-true   (tn) (integer?  (string-read      "9223372036854775807")))
   (assert-true   (tn) (integer?  (string-read     "+9223372036854775807")))
   (assert-true   (tn) (integer?  (string-read    "-09223372036854775808")))
   (assert-true   (tn) (integer?  (string-read     "09223372036854775807")))
   (assert-true   (tn) (integer?  (string-read    "+09223372036854775807")))
   (assert-true   (tn) (integer?  (string-eval    "'-9223372036854775808")))
   (assert-true   (tn) (integer?  (string-eval     "'9223372036854775807")))
   (assert-true   (tn) (integer?  (string-eval    "'+9223372036854775807")))
   (assert-true   (tn) (integer?  (string-eval   "'-09223372036854775808")))
   (assert-true   (tn) (integer?  (string-eval    "'09223372036854775807")))
   (assert-true   (tn) (integer?  (string-eval   "'+09223372036854775807")))
   (tn "integer limit explicit decimal")
   (assert-error  (tn) (lambda () (string-read   "#d-9223372036854775809")))
   (assert-error  (tn) (lambda () (string-read    "#d9223372036854775808")))
   (assert-error  (tn) (lambda () (string-read   "#d+9223372036854775808")))
   (assert-error  (tn) (lambda () (string-read  "#d-09223372036854775809")))
   (assert-error  (tn) (lambda () (string-read   "#d09223372036854775808")))
   (assert-error  (tn) (lambda () (string-read  "#d+09223372036854775808")))
   (assert-error  (tn) (lambda () (string-read  "'#d-9223372036854775809")))
   (assert-error  (tn) (lambda () (string-read   "'#d9223372036854775808")))
   (assert-error  (tn) (lambda () (string-read  "'#d+9223372036854775808")))
   (assert-error  (tn) (lambda () (string-read "'#d-09223372036854775809")))
   (assert-error  (tn) (lambda () (string-read  "'#d09223372036854775808")))
   (assert-error  (tn) (lambda () (string-read "'#d+09223372036854775808")))
   (assert-true   (tn) (integer?  (string-read   "#d-9223372036854775808")))
   (assert-true   (tn) (integer?  (string-read    "#d9223372036854775807")))
   (assert-true   (tn) (integer?  (string-read   "#d+9223372036854775807")))
   (assert-true   (tn) (integer?  (string-read  "#d-09223372036854775808")))
   (assert-true   (tn) (integer?  (string-read   "#d09223372036854775807")))
   (assert-true   (tn) (integer?  (string-read  "#d+09223372036854775807")))
   (assert-true   (tn) (integer?  (string-eval  "'#d-9223372036854775808")))
   (assert-true   (tn) (integer?  (string-eval   "'#d9223372036854775807")))
   (assert-true   (tn) (integer?  (string-eval  "'#d+9223372036854775807")))
   (assert-true   (tn) (integer?  (string-eval "'#d-09223372036854775808")))
   (assert-true   (tn) (integer?  (string-eval  "'#d09223372036854775807")))
   (assert-true   (tn) (integer?  (string-eval "'#d+09223372036854775807")))
   (tn "integer limit hexadecimal")
   (assert-error  (tn) (lambda () (string-read   "#x-8000000000000001")))
   (assert-error  (tn) (lambda () (string-read    "#x8000000000000000")))
   (assert-error  (tn) (lambda () (string-read   "#x+8000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "#x-08000000000000001")))
   (assert-error  (tn) (lambda () (string-read   "#x08000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "#x+08000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "'#x-8000000000000001")))
   (assert-error  (tn) (lambda () (string-read   "'#x8000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "'#x+8000000000000000")))
   (assert-error  (tn) (lambda () (string-read "'#x-08000000000000001")))
   (assert-error  (tn) (lambda () (string-read  "'#x08000000000000000")))
   (assert-error  (tn) (lambda () (string-read "'#x+08000000000000000")))
   (assert-true   (tn) (integer?  (string-read   "#x-8000000000000000")))
   (assert-true   (tn) (integer?  (string-read    "#x7fffffffffffffff")))
   (assert-true   (tn) (integer?  (string-read   "#x+7fffffffffffffff")))
   (assert-true   (tn) (integer?  (string-read  "#x-08000000000000000")))
   (assert-true   (tn) (integer?  (string-read   "#x07fffffffffffffff")))
   (assert-true   (tn) (integer?  (string-read  "#x+07fffffffffffffff")))
   (assert-true   (tn) (integer?  (string-eval  "'#x-8000000000000000")))
   (assert-true   (tn) (integer?  (string-eval   "'#x7fffffffffffffff")))
   (assert-true   (tn) (integer?  (string-eval  "'#x+7fffffffffffffff")))
   (assert-true   (tn) (integer?  (string-eval "'#x-08000000000000000")))
   (assert-true   (tn) (integer?  (string-eval  "'#x07fffffffffffffff")))
   (assert-true   (tn) (integer?  (string-eval "'#x+07fffffffffffffff")))
   (tn "integer limit octal")
   (assert-error  (tn) (lambda () (string-read   "#o-1000000000000000000001")))
   (assert-error  (tn) (lambda () (string-read    "#o1000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read   "#o+1000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "#o-01000000000000000000001")))
   (assert-error  (tn) (lambda () (string-read   "#o01000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "#o+01000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "'#o-1000000000000000000001")))
   (assert-error  (tn) (lambda () (string-read   "'#o1000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "'#o+1000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read "'#o-01000000000000000000001")))
   (assert-error  (tn) (lambda () (string-read  "'#o01000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read "'#o+01000000000000000000000")))
   (assert-true   (tn) (integer?  (string-read   "#o-1000000000000000000000")))
   (assert-true   (tn) (integer?  (string-read     "#o777777777777777777777")))
   (assert-true   (tn) (integer?  (string-read    "#o+777777777777777777777")))
   (assert-true   (tn) (integer?  (string-read  "#o-01000000000000000000000")))
   (assert-true   (tn) (integer?  (string-read    "#o0777777777777777777777")))
   (assert-true   (tn) (integer?  (string-read   "#o+0777777777777777777777")))
   (assert-true   (tn) (integer?  (string-eval  "'#o-1000000000000000000000")))
   (assert-true   (tn) (integer?  (string-eval    "'#o777777777777777777777")))
   (assert-true   (tn) (integer?  (string-eval   "'#o+777777777777777777777")))
   (assert-true   (tn) (integer?  (string-eval "'#o-01000000000000000000000")))
   (assert-true   (tn) (integer?  (string-eval   "'#o0777777777777777777777")))
   (assert-true   (tn) (integer?  (string-eval  "'#o+0777777777777777777777")))
   (tn "integer limit binary")
   (assert-error  (tn) (lambda () (string-read   "#b-1000000000000000000000000000000000000000000000000000000000000001")))
   (assert-error  (tn) (lambda () (string-read    "#b1000000000000000000000000000000000000000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read   "#b+1000000000000000000000000000000000000000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "#b-01000000000000000000000000000000000000000000000000000000000000001")))
   (assert-error  (tn) (lambda () (string-read   "#b01000000000000000000000000000000000000000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "#b+01000000000000000000000000000000000000000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "'#b-1000000000000000000000000000000000000000000000000000000000000001")))
   (assert-error  (tn) (lambda () (string-read   "'#b1000000000000000000000000000000000000000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read  "'#b+1000000000000000000000000000000000000000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read "'#b-01000000000000000000000000000000000000000000000000000000000000001")))
   (assert-error  (tn) (lambda () (string-read  "'#b01000000000000000000000000000000000000000000000000000000000000000")))
   (assert-error  (tn) (lambda () (string-read "'#b+01000000000000000000000000000000000000000000000000000000000000000")))
   (assert-true   (tn) (integer?  (string-read   "#b-1000000000000000000000000000000000000000000000000000000000000000")))
   (assert-true   (tn) (integer?  (string-read     "#b111111111111111111111111111111111111111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-read    "#b+111111111111111111111111111111111111111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-read  "#b-01000000000000000000000000000000000000000000000000000000000000000")))
   (assert-true   (tn) (integer?  (string-read    "#b0111111111111111111111111111111111111111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-read   "#b+0111111111111111111111111111111111111111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-eval  "'#b-1000000000000000000000000000000000000000000000000000000000000000")))
   (assert-true   (tn) (integer?  (string-eval    "'#b111111111111111111111111111111111111111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-eval   "'#b+111111111111111111111111111111111111111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-eval "'#b-01000000000000000000000000000000000000000000000000000000000000000")))
   (assert-true   (tn) (integer?  (string-eval   "'#b0111111111111111111111111111111111111111111111111111111111111111")))
   (assert-true   (tn) (integer?  (string-eval  "'#b+0111111111111111111111111111111111111111111111111111111111111111")))))


(total-report)