~ubuntu-branches/ubuntu/hardy/uim/hardy

« back to all changes in this revision

Viewing changes to sigscheme/test/test-letstar.scm

  • Committer: Bazaar Package Importer
  • Author(s): Masahito Omote
  • Date: 2007-04-21 03:46:09 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20070421034609-gpcurkutp8vaysqj
Tags: 1:1.4.1-3
* Switch to dh_gtkmodules for the gtk 2.10 transition (Closes:
  #419318)
  - debian/control: Add ${misc:Depends} and remove libgtk2.0-bin on
    uim-gtk2.0.
  - debian/uim-gtk2.0.post{inst,rm}: Removed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
;;  Filename : test-letstar.scm
 
2
;;  About    : unit test for R5RS let*
 
3
;;
 
4
;;  Copyright (C) 2005-2006 YAMAMOTO Kengo <yamaken AT bp.iij4u.or.jp>
 
5
;;  Copyright (c) 2007 SigScheme Project <uim AT freedesktop.org>
 
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
(load "./test/unittest.scm")
 
35
 
 
36
(define *test-track-progress* #f)
 
37
(define tn test-name)
 
38
 
 
39
 
 
40
;;
 
41
;; let*
 
42
;;
 
43
(tn "let* invalid form")
 
44
;; bindings and body required
 
45
(assert-error  (tn) (lambda ()
 
46
                      (let*)))
 
47
(assert-error  (tn) (lambda ()
 
48
                      (let* ())))
 
49
(assert-error  (tn) (lambda ()
 
50
                      (let* ((a)))))
 
51
(assert-error  (tn) (lambda ()
 
52
                      (let* ((a 1)))))
 
53
(assert-error  (tn) (lambda ()
 
54
                      (let* (a 1))))
 
55
(assert-error  (tn) (lambda ()
 
56
                      (let* a)))
 
57
(assert-error  (tn) (lambda ()
 
58
                      (let* #())))
 
59
(assert-error  (tn) (lambda ()
 
60
                      (let* #f)))
 
61
(assert-error  (tn) (lambda ()
 
62
                      (let* #t)))
 
63
;; bindings must be a list
 
64
(assert-error  (tn) (lambda ()
 
65
                      (let* a 'val)))
 
66
(if (provided? "siod-bugs")
 
67
    (assert-equal? (tn)
 
68
                   'val
 
69
                   (let* #f 'val))
 
70
    (assert-error  (tn) (lambda ()
 
71
                          (let* #f 'val))))
 
72
(assert-error  (tn) (lambda ()
 
73
                      (let* #() 'val)))
 
74
(assert-error  (tn) (lambda ()
 
75
                      (let* #t 'val)))
 
76
;; each binding must be a 2-elem list
 
77
(assert-error  (tn) (lambda ()
 
78
                      (let* (a 1))))
 
79
(if (provided? "siod-bugs")
 
80
    (assert-equal? (tn)
 
81
                   'val
 
82
                   (let* ((a)) 'val))
 
83
    (assert-error  (tn)
 
84
                   (lambda ()
 
85
                     (let* ((a)) 'val))))
 
86
(assert-error  (tn)
 
87
               (lambda ()
 
88
                 (let* ((a 1 'excessive)) 'val)))
 
89
(assert-error  (tn)
 
90
               (lambda ()
 
91
                 (let* ((a 1) . (b 2)) 'val)))
 
92
(assert-error  (tn)
 
93
               (lambda ()
 
94
                 (let* ((a . 1)) 'val)))
 
95
(assert-error  (tn)
 
96
               (lambda ()
 
97
                 (let* ((a  1)) . a)))
 
98
(assert-error  (tn)
 
99
               (lambda ()
 
100
                 (let* ((a  1)) 'val . a)))
 
101
(assert-error  (tn)
 
102
               (lambda ()
 
103
                 (let* (1) #t)))
 
104
 
 
105
(tn "let* binding syntactic keyword")
 
106
(assert-equal? (tn) 4 (let* ((else 4)) else))
 
107
(assert-equal? (tn) 5 (let* ((=> 5)) =>))
 
108
(assert-equal? (tn) 6 (let* ((unquote 6)) unquote))
 
109
(assert-error  (tn) (lambda () else))
 
110
(assert-error  (tn) (lambda () =>))
 
111
(assert-error  (tn) (lambda () unquote))
 
112
 
 
113
(tn "let* env isolation")
 
114
(assert-equal? (tn)
 
115
               1
 
116
               (let* ((var1 1)
 
117
                      (var2 var1))
 
118
                 var2))
 
119
(assert-error  (tn)
 
120
               (lambda ()
 
121
                 (let* ((var1 var2)
 
122
                        (var2 2))
 
123
                   'result)))
 
124
;; The environment is extended even if empty bindings on
 
125
;; !SCM_STRICT_DEFINE_PLACEMENT
 
126
(assert-equal? (tn)
 
127
               1
 
128
               (let ((var1 1))
 
129
                 (let* ()
 
130
                   (define var1 2)
 
131
                   'dummy)
 
132
                 var1))
 
133
(if (provided? "sigscheme")
 
134
    (begin
 
135
      (assert-equal? (tn)
 
136
                     '(#f #t #t)
 
137
                     (let* ((var1 (symbol-bound? 'var1 (%%current-environment)))
 
138
                            (var2 (symbol-bound? 'var1 (%%current-environment)))
 
139
                            (var3 (symbol-bound? 'var1 (%%current-environment))))
 
140
                       (list var1 var2 var3)))
 
141
      (assert-equal? (tn)
 
142
                     '(#f #f #t)
 
143
                     (let* ((var1 (symbol-bound? 'var2 (%%current-environment)))
 
144
                            (var2 (symbol-bound? 'var2 (%%current-environment)))
 
145
                            (var3 (symbol-bound? 'var2 (%%current-environment))))
 
146
                       (list var1 var2 var3)))
 
147
      (assert-equal? (tn)
 
148
                     '(#f #f #f)
 
149
                     (let* ((var1 (symbol-bound? 'var3 (%%current-environment)))
 
150
                            (var2 (symbol-bound? 'var3 (%%current-environment)))
 
151
                            (var3 (symbol-bound? 'var3 (%%current-environment))))
 
152
                       (list var1 var2 var3)))))
 
153
 
 
154
(tn "let* internal definitions lacking sequence part")
 
155
;; at least one <expression> is required
 
156
(assert-error  (tn)
 
157
               (lambda ()
 
158
                 (let* ()
 
159
                   (define var1 1))))
 
160
(assert-error  (tn)
 
161
               (lambda ()
 
162
                 (let* ()
 
163
                   (define (proc1) 1))))
 
164
(assert-error  (tn)
 
165
               (lambda ()
 
166
                 (let* ()
 
167
                   (define var1 1)
 
168
                   (define var2 2))))
 
169
(assert-error  (tn)
 
170
               (lambda ()
 
171
                 (let* ()
 
172
                   (define (proc1) 1)
 
173
                   (define (proc2) 2))))
 
174
(assert-error  (tn)
 
175
               (lambda ()
 
176
                 (let* ()
 
177
                   (define var1 1)
 
178
                   (define (proc2) 2))))
 
179
(assert-error  (tn)
 
180
               (lambda ()
 
181
                 (let* ()
 
182
                   (define (proc1) 1)
 
183
                   (define var2 2))))
 
184
(assert-error  (tn)
 
185
               (lambda ()
 
186
                 (let* ()
 
187
                   (begin))))
 
188
(assert-error  (tn)
 
189
               (lambda ()
 
190
                 (let* ()
 
191
                   (begin
 
192
                     (define var1 1)))))
 
193
(assert-error  (tn)
 
194
               (lambda ()
 
195
                 (let* ()
 
196
                   (begin
 
197
                     (define (proc1) 1)))))
 
198
(assert-error  (tn)
 
199
               (lambda ()
 
200
                 (let* ()
 
201
                   (begin
 
202
                     (define var1 1)
 
203
                     (define var2 2)))))
 
204
(assert-error  (tn)
 
205
               (lambda ()
 
206
                 (let* ()
 
207
                   (begin
 
208
                     (define (proc1) 1)
 
209
                     (define (proc2) 2)))))
 
210
(assert-error  (tn)
 
211
               (lambda ()
 
212
                 (let* ()
 
213
                   (begin
 
214
                     (define var1 1)
 
215
                     (define (proc2) 2)))))
 
216
(assert-error  (tn)
 
217
               (lambda ()
 
218
                 (let* ()
 
219
                   (begin
 
220
                     (define (proc1) 1)
 
221
                     (define var2 2)))))
 
222
;; appending a non-definition expression into a begin block is invalid
 
223
(assert-error  (tn)
 
224
               (lambda ()
 
225
                 (let* ()
 
226
                   (begin
 
227
                     (define var1 1)
 
228
                     'val))))
 
229
(assert-error  (tn)
 
230
               (lambda ()
 
231
                 (let* ()
 
232
                   (begin
 
233
                     (define (proc1) 1)
 
234
                     'val))))
 
235
(assert-error  (tn)
 
236
               (lambda ()
 
237
                 (let* ()
 
238
                   (begin
 
239
                     (define var1 1)
 
240
                     (define var2 2)
 
241
                     'val))))
 
242
(assert-error  (tn)
 
243
               (lambda ()
 
244
                 (let* ()
 
245
                   (begin
 
246
                     (define (proc1) 1)
 
247
                     (define (proc2) 2)
 
248
                     'val))))
 
249
(assert-error  (tn)
 
250
               (lambda ()
 
251
                 (let* ()
 
252
                   (begin
 
253
                     (define var1 1)
 
254
                     (define (proc2) 2)
 
255
                     'val))))
 
256
(assert-error  (tn)
 
257
               (lambda ()
 
258
                 (let* ()
 
259
                   (begin
 
260
                     (define (proc1) 1)
 
261
                     (define var2 2)
 
262
                     'val))))
 
263
 
 
264
(tn "let* internal definitions cross reference")
 
265
;; R5RS: 5.2.2 Internal definitions
 
266
;; Just as for the equivalent `letrec' expression, it must be possible to
 
267
;; evaluate each <expression> of every internal definition in a <body> without
 
268
;; assigning or referring to the value of any <variable> being defined.
 
269
(assert-error  (tn)
 
270
               (lambda ()
 
271
                 (let* ()
 
272
                   (define var1 1)
 
273
                   (define var2 var1)
 
274
                   'val)))
 
275
(assert-error  (tn)
 
276
               (lambda ()
 
277
                 (let* ()
 
278
                   (define var1 var2)
 
279
                   (define var2 2)
 
280
                   'val)))
 
281
(assert-error  (tn)
 
282
               (lambda ()
 
283
                 (let* ()
 
284
                   (define var1 var1)
 
285
                   'val)))
 
286
(assert-equal? (tn)
 
287
               '(0 0 0 0 0)
 
288
               (let* ((var0 0))
 
289
                 (define var1 var0)
 
290
                 (define var2 var0)
 
291
                 (begin
 
292
                   (define var3 var0)
 
293
                   (begin
 
294
                     (define var4 var0)))
 
295
                 (define var5 var0)
 
296
                 (list var1 var2 var3 var4 var5)))
 
297
(assert-equal? (tn)
 
298
               '(#f #f #f #f #f #f)
 
299
               (let* ((var0 (symbol-bound? 'var1)))
 
300
                 (define var1 (symbol-bound? 'var1))
 
301
                 (define var2 (symbol-bound? 'var1))
 
302
                 (begin
 
303
                   (define var3 (symbol-bound? 'var1))
 
304
                   (begin
 
305
                     (define var4 (symbol-bound? 'var1))))
 
306
                 (define var5 (symbol-bound? 'var1))
 
307
                 (list var0 var1 var2 var3 var4 var5)))
 
308
(assert-equal? (tn)
 
309
               '(#f #f #f #f #f #f)
 
310
               (let* ((var0 (symbol-bound? 'var2)))
 
311
                 (define var1 (symbol-bound? 'var2))
 
312
                 (define var2 (symbol-bound? 'var2))
 
313
                 (begin
 
314
                   (define var3 (symbol-bound? 'var2))
 
315
                   (begin
 
316
                     (define var4 (symbol-bound? 'var2))))
 
317
                 (define var5 (symbol-bound? 'var2))
 
318
                 (list var0 var1 var2 var3 var4 var5)))
 
319
(assert-equal? (tn)
 
320
               '(#f #f #f #f #f #f)
 
321
               (let* ((var0 (symbol-bound? 'var3)))
 
322
                 (define var1 (symbol-bound? 'var3))
 
323
                 (define var2 (symbol-bound? 'var3))
 
324
                 (begin
 
325
                   (define var3 (symbol-bound? 'var3))
 
326
                   (begin
 
327
                     (define var4 (symbol-bound? 'var3))))
 
328
                 (define var5 (symbol-bound? 'var3))
 
329
                 (list var0 var1 var2 var3 var4 var5)))
 
330
(assert-equal? (tn)
 
331
               '(#f #f #f #f #f #f)
 
332
               (let* ((var0 (symbol-bound? 'var4)))
 
333
                 (define var1 (symbol-bound? 'var4))
 
334
                 (define var2 (symbol-bound? 'var4))
 
335
                 (begin
 
336
                   (define var3 (symbol-bound? 'var4))
 
337
                   (begin
 
338
                     (define var4 (symbol-bound? 'var4))))
 
339
                 (define var5 (symbol-bound? 'var4))
 
340
                 (list var0 var1 var2 var3 var4 var5)))
 
341
(assert-equal? (tn)
 
342
               '(#f #f #f #f #f #f)
 
343
               (let* ((var0 (symbol-bound? 'var5)))
 
344
                 (define var1 (symbol-bound? 'var5))
 
345
                 (define var2 (symbol-bound? 'var5))
 
346
                 (begin
 
347
                   (define var3 (symbol-bound? 'var5))
 
348
                   (begin
 
349
                     (define var4 (symbol-bound? 'var5))))
 
350
                 (define var5 (symbol-bound? 'var5))
 
351
                 (list var0 var1 var2 var3 var4 var5)))
 
352
;; outer let cannot refer internal variable
 
353
(assert-error  (tn)
 
354
               (lambda ()
 
355
                 (let* ((var0 (lambda () var1)))
 
356
                   (define var1 (lambda () 1))
 
357
                   (eq? (var0) var0))))
 
358
;; defining procedure can refer other (and self) variables as if letrec
 
359
(assert-equal? (tn)
 
360
               '(#t #t #t #t #t)
 
361
               (let* ((var0 (lambda () 0)))
 
362
                 (define var1 (lambda () var0))
 
363
                 (define var2 (lambda () var0))
 
364
                 (begin
 
365
                   (define var3 (lambda () var0))
 
366
                   (begin
 
367
                     (define var4 (lambda () var0))))
 
368
                 (define var5 (lambda () var0))
 
369
                 (list (eq? (var1) var0)
 
370
                       (eq? (var2) var0)
 
371
                       (eq? (var3) var0)
 
372
                       (eq? (var4) var0)
 
373
                       (eq? (var5) var0))))
 
374
(assert-equal? (tn)
 
375
               '(#t #t #t #t #t)
 
376
               (let* ()
 
377
                 (define var1 (lambda () var1))
 
378
                 (define var2 (lambda () var1))
 
379
                 (begin
 
380
                   (define var3 (lambda () var1))
 
381
                   (begin
 
382
                     (define var4 (lambda () var1))))
 
383
                 (define var5 (lambda () var1))
 
384
                 (list (eq? (var1) var1)
 
385
                       (eq? (var2) var1)
 
386
                       (eq? (var3) var1)
 
387
                       (eq? (var4) var1)
 
388
                       (eq? (var5) var1))))
 
389
(assert-equal? (tn)
 
390
               '(#t #t #t #t #t)
 
391
               (let* ()
 
392
                 (define var1 (lambda () var2))
 
393
                 (define var2 (lambda () var2))
 
394
                 (begin
 
395
                   (define var3 (lambda () var2))
 
396
                   (begin
 
397
                     (define var4 (lambda () var2))))
 
398
                 (define var5 (lambda () var2))
 
399
                 (list (eq? (var1) var2)
 
400
                       (eq? (var2) var2)
 
401
                       (eq? (var3) var2)
 
402
                       (eq? (var4) var2)
 
403
                       (eq? (var5) var2))))
 
404
(assert-equal? (tn)
 
405
               '(#t #t #t #t #t)
 
406
               (let* ()
 
407
                 (define var1 (lambda () var3))
 
408
                 (define var2 (lambda () var3))
 
409
                 (begin
 
410
                   (define var3 (lambda () var3))
 
411
                   (begin
 
412
                     (define var4 (lambda () var3))))
 
413
                 (define var5 (lambda () var3))
 
414
                 (list (eq? (var1) var3)
 
415
                       (eq? (var2) var3)
 
416
                       (eq? (var3) var3)
 
417
                       (eq? (var4) var3)
 
418
                       (eq? (var5) var3))))
 
419
(assert-equal? (tn)
 
420
               '(#t #t #t #t #t)
 
421
               (let* ()
 
422
                 (define var1 (lambda () var4))
 
423
                 (define var2 (lambda () var4))
 
424
                 (begin
 
425
                   (define var3 (lambda () var4))
 
426
                   (begin
 
427
                     (define var4 (lambda () var4))))
 
428
                 (define var5 (lambda () var4))
 
429
                 (list (eq? (var1) var4)
 
430
                       (eq? (var2) var4)
 
431
                       (eq? (var3) var4)
 
432
                       (eq? (var4) var4)
 
433
                       (eq? (var5) var4))))
 
434
(assert-equal? (tn)
 
435
               '(#t #t #t #t #t)
 
436
               (let* ()
 
437
                 (define var1 (lambda () var5))
 
438
                 (define var2 (lambda () var5))
 
439
                 (begin
 
440
                   (define var3 (lambda () var5))
 
441
                   (begin
 
442
                     (define var4 (lambda () var5))))
 
443
                 (define var5 (lambda () var5))
 
444
                 (list (eq? (var1) var5)
 
445
                       (eq? (var2) var5)
 
446
                       (eq? (var3) var5)
 
447
                       (eq? (var4) var5)
 
448
                       (eq? (var5) var5))))
 
449
 
 
450
(tn "let* internal definitions valid forms")
 
451
;; valid internal definitions
 
452
(assert-equal? (tn)
 
453
               '(1)
 
454
               (let* ()
 
455
                 (define var1 1)
 
456
                 (list var1)))
 
457
(assert-equal? (tn)
 
458
               '(1)
 
459
               (let* ()
 
460
                 (define (proc1) 1)
 
461
                 (list (proc1))))
 
462
(assert-equal? (tn)
 
463
               '(1 2)
 
464
               (let* ()
 
465
                 (define var1 1)
 
466
                 (define var2 2)
 
467
                 (list var1 var2)))
 
468
(assert-equal? (tn)
 
469
               '(1 2)
 
470
               (let* ()
 
471
                 (define (proc1) 1)
 
472
                 (define (proc2) 2)
 
473
                 (list (proc1) (proc2))))
 
474
(assert-equal? (tn)
 
475
               '(1 2)
 
476
               (let* ()
 
477
                 (define var1 1)
 
478
                 (define (proc2) 2)
 
479
                 (list var1 (proc2))))
 
480
(assert-equal? (tn)
 
481
               '(1 2)
 
482
               (let* ()
 
483
                 (define (proc1) 1)
 
484
                 (define var2 2)
 
485
                 (list (proc1) var2)))
 
486
;; SigScheme accepts '(begin)' as valid internal definition '(begin
 
487
;; <definition>*)' as defined in "7.1.6 Programs and definitions" of R5RS
 
488
;; although it is rejected as expression '(begin <sequence>)' as defined in
 
489
;; "7.1.3 Expressions".
 
490
(assert-equal? (tn)
 
491
               1
 
492
               (let* ()
 
493
                 (begin)
 
494
                 1))
 
495
(assert-equal? (tn)
 
496
               1
 
497
               (let* ()
 
498
                 (begin)
 
499
                 (define var1 1)
 
500
                 (begin)
 
501
                 1))
 
502
(assert-equal? (tn)
 
503
               '(1)
 
504
               (let* ()
 
505
                 (begin
 
506
                   (define var1 1))
 
507
                 (list var1)))
 
508
(assert-equal? (tn)
 
509
               '(1)
 
510
               (let* ()
 
511
                 (begin
 
512
                   (define (proc1) 1))
 
513
                 (list (proc1))))
 
514
(assert-equal? (tn)
 
515
               '(1 2)
 
516
               (let* ()
 
517
                 (begin
 
518
                   (define var1 1)
 
519
                   (define var2 2))
 
520
                 (list var1 var2)))
 
521
(assert-equal? (tn)
 
522
               '(1 2)
 
523
               (let* ()
 
524
                 (begin
 
525
                   (define (proc1) 1)
 
526
                   (define (proc2) 2))
 
527
                 (list (proc1) (proc2))))
 
528
(assert-equal? (tn)
 
529
               '(1 2)
 
530
               (let* ()
 
531
                 (begin
 
532
                   (define var1 1)
 
533
                   (define (proc2) 2))
 
534
                 (list var1 (proc2))))
 
535
(assert-equal? (tn)
 
536
               '(1 2)
 
537
               (let* ()
 
538
                 (begin
 
539
                   (define (proc1) 1)
 
540
                   (define var2 2))
 
541
                 (list (proc1) var2)))
 
542
(assert-equal? (tn)
 
543
               '(1 2 3 4 5 6)
 
544
               (let* ()
 
545
                 (begin
 
546
                   (define (proc1) 1)
 
547
                   (define var2 2)
 
548
                   (begin
 
549
                     (define (proc3) 3)
 
550
                     (define var4 4)
 
551
                     (begin
 
552
                       (define (proc5) 5)
 
553
                       (define var6 6))))
 
554
                 (list (proc1) var2
 
555
                       (proc3) var4
 
556
                       (proc5) var6)))
 
557
;; begin block and single definition mixed
 
558
(assert-equal? (tn)
 
559
               '(1 2 3 4 5 6)
 
560
               (let* ()
 
561
                 (begin)
 
562
                 (define (proc1) 1)
 
563
                 (begin
 
564
                   (define var2 2)
 
565
                   (begin
 
566
                     (define (proc3) 3)
 
567
                     (begin)
 
568
                     (define var4 4)))
 
569
                 (begin)
 
570
                 (define (proc5) 5)
 
571
                 (begin
 
572
                   (begin
 
573
                     (begin
 
574
                       (begin)))
 
575
                   (define var6 6)
 
576
                   (begin))
 
577
                 (begin)
 
578
                 (list (proc1) var2
 
579
                       (proc3) var4
 
580
                       (proc5) var6)))
 
581
 
 
582
(tn "let* internal definitions invalid begin blocks")
 
583
;; appending a non-definition expression into a begin block is invalid
 
584
(assert-error  (tn)
 
585
               (lambda ()
 
586
                 (let* ()
 
587
                   (begin
 
588
                     (define var1 1)
 
589
                     'val)
 
590
                   (list var1))))
 
591
(assert-error  (tn)
 
592
               (lambda ()
 
593
                 (let* ()
 
594
                   (begin
 
595
                     (define (proc1) 1)
 
596
                     'val)
 
597
                   (list (proc1)))))
 
598
(assert-error  (tn)
 
599
               (lambda ()
 
600
                 (let* ()
 
601
                   (begin
 
602
                     (define var1 1)
 
603
                     (define var2 2)
 
604
                     'val)
 
605
                   (list var1 var2))))
 
606
(assert-error  (tn)
 
607
               (lambda ()
 
608
                 (let* ()
 
609
                   (begin
 
610
                     (define (proc1) 1)
 
611
                     (define (proc2) 2)
 
612
                     'val)
 
613
                   (list (proc1) (proc2)))))
 
614
(assert-error  (tn)
 
615
               (lambda ()
 
616
                 (let* ()
 
617
                   (begin
 
618
                     (define var1 1)
 
619
                     (define (proc2) 2)
 
620
                     'val)
 
621
                   (list var1 (proc2)))))
 
622
(assert-error  (tn)
 
623
               (lambda ()
 
624
                 (let* ()
 
625
                   (begin
 
626
                     (define (proc1) 1)
 
627
                     (define var2 2)
 
628
                     'val)
 
629
                   (list (proc1) var2))))
 
630
(assert-error  (tn)
 
631
               (lambda ()
 
632
                 (let* ()
 
633
                   (begin
 
634
                     (define (proc1) 1)
 
635
                     (define var2 2)
 
636
                     (begin
 
637
                       (define (proc3) 3)
 
638
                       (define var4 4)
 
639
                       (begin
 
640
                         (define (proc5) 5)
 
641
                         (define var6 6)
 
642
                         'val)))
 
643
                   (list (proc1) var2
 
644
                         (proc3) var4
 
645
                         (proc5) var6))))
 
646
 
 
647
(tn "let* internal definitions invalid placement")
 
648
;; a non-definition expression prior to internal definition is invalid
 
649
(assert-error  (tn)
 
650
               (lambda ()
 
651
                 (let* ()
 
652
                   'val
 
653
                   (define var1 1))))
 
654
(assert-error  (tn)
 
655
               (lambda ()
 
656
                 (let* ()
 
657
                   'val
 
658
                   (define (proc1) 1))))
 
659
(assert-error  (tn)
 
660
               (lambda ()
 
661
                 (let* ()
 
662
                   'val
 
663
                   (define var1 1)
 
664
                   (define var2 2))))
 
665
(assert-error  (tn)
 
666
               (lambda ()
 
667
                 (let* ()
 
668
                   'val
 
669
                   (define (proc1) 1)
 
670
                   (define (proc2) 2))))
 
671
(assert-error  (tn)
 
672
               (lambda ()
 
673
                 (let* ()
 
674
                   'val
 
675
                   (define var1 1)
 
676
                   (define (proc2) 2))))
 
677
(assert-error  (tn)
 
678
               (lambda ()
 
679
                 (let* ()
 
680
                   'val
 
681
                   (define (proc1) 1)
 
682
                   (define var2 2))))
 
683
(assert-error  (tn)
 
684
               (lambda ()
 
685
                 (let* ()
 
686
                   'val
 
687
                   (begin))))
 
688
(assert-error  (tn)
 
689
               (lambda ()
 
690
                 (let* ()
 
691
                   'val
 
692
                   (begin
 
693
                     (define var1 1)))))
 
694
(assert-error  (tn)
 
695
               (lambda ()
 
696
                 (let* ()
 
697
                   'val
 
698
                   (begin
 
699
                     (define (proc1) 1)))))
 
700
(assert-error  (tn)
 
701
               (lambda ()
 
702
                 (let* ()
 
703
                   'val
 
704
                   (begin
 
705
                     (define var1 1)
 
706
                     (define var2 2)))))
 
707
(assert-error  (tn)
 
708
               (lambda ()
 
709
                 (let* ()
 
710
                   'val
 
711
                   (begin
 
712
                     (define (proc1) 1)
 
713
                     (define (proc2) 2)))))
 
714
(assert-error  (tn)
 
715
               (lambda ()
 
716
                 (let* ()
 
717
                   'val
 
718
                   (begin
 
719
                     (define var1 1)
 
720
                     (define (proc2) 2)))))
 
721
(assert-error  (tn)
 
722
               (lambda ()
 
723
                 (let* ()
 
724
                   'val
 
725
                   (begin
 
726
                     (define (proc1) 1)
 
727
                     (define var2 2)))))
 
728
(assert-error  (tn)
 
729
               (lambda ()
 
730
                 (let* ()
 
731
                   'val
 
732
                   (begin
 
733
                     (define (proc1) 1)
 
734
                     (define var2 2)
 
735
                     (begin
 
736
                       (define (proc3) 3)
 
737
                       (define var4 4)
 
738
                       (begin
 
739
                         (define (proc5) 5)
 
740
                         (define var6 6)))))))
 
741
(assert-error  (tn)
 
742
               (lambda ()
 
743
                 (let* ()
 
744
                   (begin
 
745
                     (define (proc1) 1)
 
746
                     (define var2 2)
 
747
                     'val
 
748
                     (begin
 
749
                       (define (proc3) 3)
 
750
                       (define var4 4)
 
751
                       (begin
 
752
                         (define (proc5) 5)
 
753
                         (define var6 6)))))))
 
754
;; a non-definition expression prior to internal definition is invalid even if
 
755
;; expression(s) is following the internal definition
 
756
(assert-error  (tn)
 
757
               (lambda ()
 
758
                 (let* ()
 
759
                   'val
 
760
                   (define var1 1)
 
761
                   'val)))
 
762
(assert-error  (tn)
 
763
               (lambda ()
 
764
                 (let* ()
 
765
                   'val
 
766
                   (define (proc1) 1)
 
767
                   'val)))
 
768
(assert-error  (tn)
 
769
               (lambda ()
 
770
                 (let* ()
 
771
                   'val
 
772
                   (define var1 1)
 
773
                   (define var2 2)
 
774
                   'val)))
 
775
(assert-error  (tn)
 
776
               (lambda ()
 
777
                 (let* ()
 
778
                   'val
 
779
                   (define (proc1) 1)
 
780
                   (define (proc2) 2)
 
781
                   'val)))
 
782
(assert-error  (tn)
 
783
               (lambda ()
 
784
                 (let* ()
 
785
                   'val
 
786
                   (define var1 1)
 
787
                   (define (proc2) 2)
 
788
                   'val)))
 
789
(assert-error  (tn)
 
790
               (lambda ()
 
791
                 (let* ()
 
792
                   'val
 
793
                   (define (proc1) 1)
 
794
                   (define var2 2)
 
795
                   'val)))
 
796
(assert-error  (tn)
 
797
               (lambda ()
 
798
                 (let* ()
 
799
                   'val
 
800
                   (begin)
 
801
                   'val)))
 
802
(assert-error  (tn)
 
803
               (lambda ()
 
804
                 (let* ()
 
805
                   'val
 
806
                   (begin
 
807
                     (define var1 1))
 
808
                   'val)))
 
809
(assert-error  (tn)
 
810
               (lambda ()
 
811
                 (let* ()
 
812
                   'val
 
813
                   (begin
 
814
                     (define (proc1) 1))
 
815
                   'val)))
 
816
(assert-error  (tn)
 
817
               (lambda ()
 
818
                 (let* ()
 
819
                   'val
 
820
                   (begin
 
821
                     (define var1 1)
 
822
                     (define var2 2))
 
823
                   'val)))
 
824
(assert-error  (tn)
 
825
               (lambda ()
 
826
                 (let* ()
 
827
                   'val
 
828
                   (begin
 
829
                     (define (proc1) 1)
 
830
                     (define (proc2) 2))
 
831
                   'val)))
 
832
(assert-error  (tn)
 
833
               (lambda ()
 
834
                 (let* ()
 
835
                   'val
 
836
                   (begin
 
837
                     (define var1 1)
 
838
                     (define (proc2) 2))
 
839
                   'val)))
 
840
(assert-error  (tn)
 
841
               (lambda ()
 
842
                 (let* ()
 
843
                   'val
 
844
                   (begin
 
845
                     (define (proc1) 1)
 
846
                     (define var2 2))
 
847
                   'val)))
 
848
(assert-error  (tn)
 
849
               (lambda ()
 
850
                 (let* ()
 
851
                   'val
 
852
                   (begin
 
853
                     (define (proc1) 1)
 
854
                     (define var2 2)
 
855
                     (begin
 
856
                       (define (proc3) 3)
 
857
                       (define var4 4)
 
858
                       (begin
 
859
                         (define (proc5) 5)
 
860
                         (define var6 6))))
 
861
                   (list (proc1) var2
 
862
                         (proc3) var4
 
863
                         (proc5) var6))))
 
864
 
 
865
(tn "let* binding syntactic keywords")
 
866
(assert-error  (tn)
 
867
               (lambda ()
 
868
                 (let* ((syn define))
 
869
                   #t)))
 
870
(assert-error  (tn)
 
871
               (lambda ()
 
872
                 (let* ((syn if))
 
873
                   #t)))
 
874
(assert-error  (tn)
 
875
               (lambda ()
 
876
                 (let* ((syn and))
 
877
                   #t)))
 
878
(assert-error  (tn)
 
879
               (lambda ()
 
880
                 (let* ((syn cond))
 
881
                   #t)))
 
882
(assert-error  (tn)
 
883
               (lambda ()
 
884
                 (let* ((syn begin))
 
885
                   #t)))
 
886
(assert-error  (tn)
 
887
               (lambda ()
 
888
                 (let* ((syn do))
 
889
                   #t)))
 
890
(assert-error  (tn)
 
891
               (lambda ()
 
892
                 (let* ((syn delay))
 
893
                   #t)))
 
894
(assert-error  (tn)
 
895
               (lambda ()
 
896
                 (let* ((syn let*))
 
897
                   #t)))
 
898
(assert-error  (tn)
 
899
               (lambda ()
 
900
                 (let* ((syn else))
 
901
                   #t)))
 
902
(assert-error  (tn)
 
903
               (lambda ()
 
904
                 (let* ((syn =>))
 
905
                   #t)))
 
906
(assert-error  (tn)
 
907
               (lambda ()
 
908
                 (let* ((syn quote))
 
909
                   #t)))
 
910
(assert-error  (tn)
 
911
               (lambda ()
 
912
                 (let* ((syn quasiquote))
 
913
                   #t)))
 
914
(assert-error  (tn)
 
915
               (lambda ()
 
916
                 (let* ((syn unquote))
 
917
                   #t)))
 
918
(assert-error  (tn)
 
919
               (lambda ()
 
920
                 (let* ((syn unquote-splicing))
 
921
                   #t)))
 
922
 
 
923
 
 
924
(tn "let*")
 
925
;; empty bindings is allowed by the formal syntax spec
 
926
(assert-equal? (tn)
 
927
               'result
 
928
               (let* () 'result))
 
929
;; duplicate variable name is allowd on let*
 
930
(assert-equal? (tn)
 
931
               2
 
932
               (let* ((var1 1)
 
933
                      (var1 2))
 
934
                 var1))
 
935
;; masked variable name
 
936
(assert-equal? (tn)
 
937
               '(4 5 3)
 
938
               (let* ((var1 1)
 
939
                      (var2 2)
 
940
                      (var3 3))
 
941
                 (let* ((var1 4)
 
942
                        (var2 5))
 
943
                   (list var1 var2 var3))))
 
944
(assert-equal? (tn)
 
945
               '(1 2 3)
 
946
               (let* ((var1 1)
 
947
                      (var2 2)
 
948
                      (var3 3))
 
949
                 (let* ((var1 4)
 
950
                        (var2 5))
 
951
                   'dummy)
 
952
                 (list var1 var2 var3)))
 
953
(assert-equal? (tn)
 
954
               '(1 2 9)
 
955
               (let* ((var1 1)
 
956
                      (var2 2)
 
957
                      (var3 3))
 
958
                 (let* ((var1 4)
 
959
                        (var2 5))
 
960
                   (set! var3 (+ var1 var2)))
 
961
                 (list var1 var2 var3)))
 
962
(assert-equal? (tn)
 
963
               '(1 2 30)
 
964
               (let* ((var1 1)
 
965
                      (var2 2)
 
966
                      (var3 3))
 
967
                 (let* ((var1 4)
 
968
                        (var2 5))
 
969
                   (set! var1 10)
 
970
                   (set! var2 20)
 
971
                   (set! var3 (+ var1 var2)))
 
972
                 (list var1 var2 var3)))
 
973
(assert-equal? (tn)
 
974
               '(1 2 30 (10 20 30))
 
975
               (let* ((var1 1)
 
976
                      (var2 2)
 
977
                      (var3 3)
 
978
                      (var4 (let* ((var1 4)
 
979
                                       (var2 5))
 
980
                                  (set! var1 10)
 
981
                                  (set! var2 20)
 
982
                                  (set! var3 30)
 
983
                                  (list var1 var2 var3))))
 
984
                 (list var1 var2 var3 var4)))
 
985
;; normal case(s)
 
986
(assert-equal? (tn)
 
987
               '(1 2 3)
 
988
               (let* ((var1 1)
 
989
                      (var2 (+ var1 1))
 
990
                      (var3 (+ var2 1)))
 
991
                 (list var1 var2 var3)))
 
992
 
 
993
(tn "let* lexical scope")
 
994
(define count-let*
 
995
  (let* ((count-let* 0))  ;; intentionally same name
 
996
    (lambda ()
 
997
      (set! count-let* (+ count-let* 1))
 
998
      count-let*)))
 
999
(assert-true   (tn) (procedure? count-let*))
 
1000
(assert-equal? (tn) 1 (count-let*))
 
1001
(assert-equal? (tn) 2 (count-let*))
 
1002
(assert-equal? (tn) 3 (count-let*))
 
1003
 
 
1004
 
 
1005
(total-report)