Debian Codegraph @

lib/compat/chibi-test.scm

raw
1 ;;
2 ;; A quick hack to run test suite written for Chibi
3 ;;
4
5 (define-module compat.chibi-test
6 (use gauche.test)
7 (use util.match)
8 (export chibi-test current-test-comparator))
9 (select-module compat.chibi-test)
10
11 (define current-test-comparator (make-parameter equal?))
12 (define-syntax gauche:parameterize parameterize)
13 (define gauche:test-error test-error)
14
15 ;; chibi allows internal defines to interleave expressions. Gauche can't
16 ;; do that, so we translate the whole body of chibi-test into
17 ;; nested lets.
18
19 ;; we also cheat the scope - we want to replace macros such as
20 ;; test, include and parameterize, but we want them to be effective
21 ;; only inside chibi-test.
22
23 (define-syntax chibi-test
24 (er-macro-transformer
25 (^[f r c]
26 `(let-syntax
27 ([parameterize
28 (syntax-rules ()
29 [(_ bindings . fs)
30 (,(r'gauche:parameterize) bindings
31 (,(r'chibi-test:expand) fs))])]
32 [use
33 ;; NB: We ignore 'use' in the chibi test file; necessary modules
34 ;; are supposed to be already used in the includer.
35 (syntax-rules ()
36 [(_ . args) (begin)])]
37 [import
38 ;; So as import
39 (syntax-rules ()
40 [(_ . args) (begin)])]
41 [include
42 (syntax-rules ()
43 [(_ file) (,(r'chibi-test:include) file)])]
44 [test
45 (syntax-rules ()
46 [(_ name expected expr)
47 (,(r'test*) name expected expr (current-test-comparator))]
48 [(_ expected expr)
49 (,(r'test*) 'expr expected expr (current-test-comparator))])]
50 [test-group
51 (syntax-rules ()
52 [(_ name . fs)
53 (begin
54 (,(r'test-section) name)
55 (,(r'chibi-test:expand) fs))])]
56 [test-assert
57 (syntax-rules ()
58 [(_ expr)
59 (,(r'test*) 'expr #t (,(r'boolean) expr))]
60 [(_ name expr)
61 (,(r'test*) name #t (,(r'boolean) expr))])]
62 [test-equal
63 (syntax-rules ()
64 [(_ equal name expect expr)
65 (,(r'parameterize) ((current-test-comparator equal))
66 (,(r'test*) name expect expr))]
67 [(_ equal expect expr)
68 (,(r'parameterize) ((current-test-comparator equal))
69 (,(r'test*) 'expr expect expr))])]
70 [test-not
71 (syntax-rules ()
72 [(_ expr)
73 (,(r'test*) 'expr #f (,(r'boolean) expr))]
74 [(_ name expr)
75 (,(r'test*) name #f (,(r'boolean) expr))])]
76 [test-error
77 (syntax-rules ()
78 [(_ expr)
79 (,(r'test*) 'expr (,(r'gauche:test-error)) expr)])]
80 [test-exit
81 ;; ignore test-exit, for it is inside chibi-test and we don't
82 ;; want to exit.
83 (syntax-rules ()
84 [(_ . args) (begin)])]
85 )
86 (,(r'chibi-test:expand) ,(cdr f))))))
87
88 ;; We gather definitions at the same level, so that mutually recursive
89 ;; definitions work
90 (define-syntax chibi-test:expand
91 (er-macro-transformer
92 (^[f r c]
93 (let loop ([forms (cadr f)]
94 [defs '()])
95 (match forms
96 [()
97 (if (null? defs)
98 (quasirename r `(begin))
99 (quasirename r `(let () ,@(reverse defs) (begin))))]
100 [(form)
101 (if (null? defs)
102 (car forms)
103 (quasirename r `(let () ,@(reverse defs) ,(car forms))))]
104 [((and ((? (cut c <> (r'define))) . _) def) . forms)
105 (loop forms (cons def defs))]
106 [(form . forms)
107 (if (null? defs)
108 (quasirename r `(let () ,form (chibi-test:expand ,forms)))
109 (quasirename r `(let () ,@(reverse defs)
110 ,form (chibi-test:expand ,forms))))])))))
111
112 (define-syntax chibi-test:include
113 (er-macro-transformer
114 (^[f r c]
115 (let ([file (cadr f)])
116 (let1 iport ((with-module gauche.internal pass1/open-include-file)
117 file (current-load-path))
118 (unwind-protect
119 `(,(r 'chibi-test:expand) ,(port->sexp-list iport))
120 (close-port iport)))))))
121
122 ;; A hack to make Gauche think it has loaded chibi.test so that it won't
123 ;; tripped by (import (chibi test)) in the test code.
124 (define-module chibi.test (extend compat.chibi-test))
125 (provide "chibi/test")
126 (provide "compat/chibi-test")