0.8.12.15:
[sbcl.git] / tests / run-tests.sh
1 #!/bin/sh
2
3 # Run the regression tests in this directory.
4
5 # This software is part of the SBCL system. See the README file for
6 # more information.
7 #
8 # While most of SBCL is derived from the CMU CL system, the test
9 # files (like this one) were written from scratch after the fork
10 # from CMU CL.
11
12 # This software is in the public domain and is provided with
13 # absolutely no warranty. See the COPYING and CREDITS files for
14 # more information.
15
16 # how we invoke SBCL in the tests
17 #
18 # Until sbcl-0.6.12.8, the shell variable SBCL was bound to a relative
19 # pathname, but now we take care to bind it to an absolute pathname (still
20 # generated relative to `pwd` in the tests/ directory) so that tests
21 # can chdir before invoking SBCL and still work.
22 sbclstem=`pwd`/../src/runtime/sbcl
23 SBCL="${1:-$sbclstem --core `pwd`/../output/sbcl.core --noinform --sysinit /dev/null --userinit /dev/null --noprint --disable-debugger}"
24 export SBCL
25 echo /running tests on SBCL=\'$SBCL\'
26 # more or less like SBCL, but without enough grot removed that appending
27 # a --core command line argument works
28 #
29 # (KLUDGE: and also without any magic to suppress --userinit and
30 # --sysinit, so if you use it in a test, you need to add those
31 # yourself if you want things to be clean. If many tests start using
32 # this, we can redo it as a shell function or something so that the
33 # magic can be done once and only once.)
34 SBCL_ALLOWING_CORE=${1:-$sbclstem}
35 export SBCL_ALLOWING_CORE
36 echo /with SBCL_ALLOWING_CORE=\'$SBCL_ALLOWING_CORE\'
37
38 # "Ten four" is the closest numerical slang I can find to "OK", so
39 # it's the Unix status value that we expect from a successful test.
40 # (Of course, zero is the usual success value, but we don't want to
41 # use that because SBCL returns that by default, so we might think
42 # we passed a test when in fact some error caused us to exit SBCL
43 # in a weird unexpected way. In contrast, 104 is unlikely to be
44 # returned unless we exit through the intended explicit "test
45 # successful" path.
46 tenfour () {
47     if [ $1 = 104 ]; then
48         echo ok
49     else
50         echo test $2 failed, expected 104 return code, got $1
51         exit 1
52     fi
53 }
54
55 # *.pure.lisp files are ordinary Lisp code with no side effects,
56 # and we can run them all in a single Lisp process.
57 echo //running '*.pure.lisp' tests
58 echo //i.e. *.pure.lisp
59 (
60 echo "(progn"
61 echo "  (progn (format t \"//loading assertoid.lisp~%\") (load \"assertoid.lisp\"))"
62 echo "  (use-package \"ASSERTOID\")"
63 for f in *.pure.lisp; do
64     if [ -f $f ]; then
65         echo "  (progn (format t \"//running $f test~%\") (load \"$f\"))"
66     fi
67 done
68 echo "  (sb-ext:quit :unix-status 104)) ; Return status=success."
69 ) | $SBCL ; tenfour $? "(pure.lisp files)"
70
71 # *.impure.lisp files are Lisp code with side effects (e.g. doing
72 # DEFSTRUCT or DEFTYPE or DEFVAR, or messing with the read table).
73 # Each one should be LOADed in a separate invocation of Lisp, so 
74 # that we don't need to worry about them interfering with each
75 # other.
76 echo //running '*.impure.lisp' tests
77 for f in *.impure.lisp; do
78     if [ -f $f ]; then
79         echo //running $f test
80         echo "(load \"$f\")" | $SBCL ; tenfour $? $f
81     fi
82 done
83
84 # *.test.sh files are scripts to test stuff, typically stuff which 
85 # can't so easily be tested within Lisp itself. A file foo.test.sh
86 # may be associated with other files foo*, e.g. foo.lisp, foo-1.lisp,
87 # or foo.pl.
88 echo //running '*.test.sh' tests
89 for f in *.test.sh; do
90     if [ -f $f ]; then
91         echo //running $f test
92         sh $f "$SBCL"; tenfour $? $f
93     fi
94 done
95
96 # *.assertoids files contain ASSERTOID statements to test things
97 # interpreted and at various compilation levels.
98 echo //running '*.assertoids' tests
99 for f in *.assertoids; do
100     if [ -f $f ]; then
101         echo //running $f test
102         echo "(load \"$f\")" | $SBCL --eval '(load "assertoid.lisp")' ; tenfour $? $f
103     fi
104 done
105
106 # *.pure-cload.lisp files want to be compiled, then loaded. They 
107 # can all be done in the same invocation of Lisp.
108 echo //running '*.pure-cload.lisp' tests
109 for f in *.pure-cload.lisp; do
110     # (Actually here we LOAD each one into a separate invocation
111     # of Lisp just because I haven't figured out a concise way
112     # to LOAD them all into the same Lisp.)
113     if [ -f $f ]; then
114         echo //running $f test
115         $SBCL <<EOF ; tenfour $? $f
116                 (compile-file "$f")
117                 (progn
118                   (unwind-protect
119                   (load *)
120                    (ignore-errors (delete-file (compile-file-pathname "$f"))))
121                   (sb-ext:quit :unix-status 104))
122 EOF
123     fi
124 done
125
126 # *.impure-cload.lisp files want to be compiled, then loaded. They
127 # can have side effects, so each one should be done in a separate
128 # invocation of Lisp so that they don't interfere.
129 echo //running '*.impure-cload.lisp' tests
130 for f in *.impure-cload.lisp; do
131     if [ -f $f ]; then
132         echo //running $f test
133         $SBCL <<EOF ; tenfour $? $f
134                 (compile-file "$f")
135                 (progn
136                   (unwind-protect
137                   (load *)
138                    (ignore-errors (delete-file (compile-file-pathname "$f"))))
139                   (sb-ext:quit :unix-status 104))
140 EOF
141     fi
142 done
143
144 # (*.before-xc.lisp and *.after-xc.lisp files aren't handled in this
145 # script at all. They're tests intended to run in the cross-compiler,
146 # so that some functionality can be tested even when cold init doesn't
147 # work.)
148
149 echo '//apparent success (reached end of run-tests.sh normally)'
150 date