Clean up listify-rest-args VOP on x86-64.
[sbcl.git] / tests / load.impure.lisp
1 ;;;; miscellaneous side-effectful tests of LOAD
2
3 ;;;; This software is part of the SBCL system. See the README file for
4 ;;;; more information.
5 ;;;;
6 ;;;; While most of SBCL is derived from the CMU CL system, the test
7 ;;;; files (like this one) were written from scratch after the fork
8 ;;;; from CMU CL.
9 ;;;;
10 ;;;; This software is in the public domain and is provided with
11 ;;;; absolutely no warranty. See the COPYING and CREDITS files for
12 ;;;; more information.
13
14 (defvar *tmp-filename* "load-test.tmp")
15
16 ;;; Bug reported by Sean Ross: FASL loader set fill pointer to loaded
17 ;;; simple arrays.
18
19 (defvar *array*)
20
21 (progn
22   (with-open-file (s *tmp-filename*
23                      :direction :output
24                      :if-exists :supersede
25                      :if-does-not-exist :create)
26     (print '(setq *array* #3a(((1 2) (2 1)) ((3 4) (4 3)))) s))
27   (let (tmp-fasl)
28     (unwind-protect
29          (progn
30            (setq tmp-fasl (compile-file *tmp-filename*))
31            (let ((*array* nil))
32              (load tmp-fasl)
33              (assert (arrayp *array*))
34              (assert (= (array-rank *array*) 3))
35              (assert (not (array-has-fill-pointer-p *array*)))))
36       (when tmp-fasl (delete-file tmp-fasl))
37       (delete-file *tmp-filename*))))
38
39 ;;; rudimentary external-format test
40 (dolist (ef '(:default :ascii :latin-1 :utf-8))
41   (with-open-file (s *tmp-filename*
42                      :direction :output
43                      :if-exists :supersede
44                      :if-does-not-exist :create)
45     (print '(defun foo (x) (1+ x)) s))
46   (fmakunbound 'foo)
47   (let (tmp-fasl)
48     (unwind-protect
49          (progn
50            (setq tmp-fasl (compile-file *tmp-filename* :external-format ef))
51            (load tmp-fasl)
52            (assert (= (foo 1) 2)))
53       (when tmp-fasl (delete-file tmp-fasl))
54       (delete-file *tmp-filename*))))
55
56 ;;; As reported by David Tolpin *LOAD-PATHNAME* was not merged.
57 (progn
58   (defparameter *saved-load-pathname* nil)
59   (with-open-file (s *tmp-filename*
60                      :direction :output
61                      :if-exists :supersede
62                      :if-does-not-exist :create)
63     (print '(setq *saved-load-pathname* *load-pathname*) s))
64   (unwind-protect
65        (progn
66          (load *tmp-filename*)
67          (assert (equal (merge-pathnames *tmp-filename*) *saved-load-pathname*)))
68     (delete-file *tmp-filename*)))
69 \f
70 ;;; Test many, many variations on LOAD.
71 (defparameter *counter* 0)
72 (defparameter *loaded-pathname* nil)
73 (defparameter *loaded-truename* nil)
74
75 (defparameter *test-program-string* (format nil "~
76  (incf *counter*)
77  (setf *loaded-pathname* *load-pathname*)
78  (setf *loaded-truename* *load-truename*)"))
79
80 (defmacro load-and-assert (load-argument pathname truename)
81   (let ((before (gensym)))
82     `(let ((,before *counter*)
83            *loaded-pathname* *loaded-truename*)
84        (load ,load-argument :print t :verbose t)
85        (assert (and (= (1+ ,before) *counter*)
86                     #-win32 ;kludge
87                     (equal ,(if pathname `(merge-pathnames ,pathname))
88                            *loaded-pathname*)
89                     #-win32 ;kludge
90                     (equal ,(if pathname `(merge-pathnames ,truename))
91                            *loaded-truename*))))))
92
93 (defmacro with-test-program (source fasl &body body)
94   (let ((src (gensym))
95         (fsl (gensym)))
96     `(let ((,src ,source)
97            (,fsl ,fasl))
98        (with-open-file (*standard-output* ,src :direction :output
99                                           :if-exists :supersede)
100          (princ *test-program-string*))
101        (when ,fsl
102          (compile-file ,src :output-file ,fsl))
103        (unwind-protect
104             (progn
105               ,@body)
106          (when (probe-file ,src)
107            (delete-file ,src))
108          (when (and ,fsl (probe-file ,fsl))
109            (delete-file ,fsl))))))
110
111 ;;; Loading from streams.
112
113 ;; string-stream
114 (with-input-from-string (s *test-program-string*)
115   (load-and-assert s nil nil))
116
117 ;; file-stream associated with a source file
118 (let ((source (pathname "load-impure-test.lisp")))
119   (with-test-program source nil
120     (with-open-file (stream source)
121       (load-and-assert stream source source))))
122
123 ;; file-stream associated with a fasl file
124 (let* ((source (pathname "load-impure-test.lisp"))
125        (fasl (compile-file-pathname source)))
126   (with-test-program source fasl
127     (with-open-file (stream fasl :element-type 'unsigned-byte)
128       (load-and-assert fasl fasl fasl))))
129
130 ;; Develop a simple Gray stream to test loading from.
131 (defclass load-impure-gray-stream (fundamental-character-input-stream)
132   ((pointer :initform 0 :accessor load-impure-gray-stream-pointer)))
133
134 (defmethod stream-read-char ((stream load-impure-gray-stream))
135   (with-accessors ((pointer load-impure-gray-stream-pointer)) stream
136     (prog1
137         (if (>= pointer (length *test-program-string*))
138             :eof
139             (char *test-program-string* pointer))
140       (incf pointer))))
141
142 (defmethod stream-unread-char ((stream load-impure-gray-stream) char)
143   (with-accessors ((pointer load-impure-gray-stream-pointer)) stream
144     (if (<= pointer 0)
145         (error "fibber!  you never read from this stream ~S" stream)
146         (decf pointer)))
147   nil)
148
149 (with-open-stream (stream (make-instance 'load-impure-gray-stream))
150   (load-and-assert stream nil nil))
151
152 ;;; Loading from things named by pathname designators.
153
154 ;; Test loading a source file by supplying a complete pathname.
155 (let ((source (pathname "load-impure-test.lisp")))
156   (with-test-program source nil
157     (load-and-assert source source source)))
158
159 ;; Test loading a source file when supplying a partial pathname.
160 (let ((source (pathname "load-impure-test.lisp"))
161       (partial (pathname "load-impure-test")))
162   (with-test-program source nil
163     (load-and-assert partial source source)))
164
165 ;; Test loading a source file whose name lacks a type when supplying a
166 ;; partial pathname.
167 (let ((source (make-pathname :type :unspecific
168                              :defaults (pathname "load-impure-test")))
169       (partial (pathname "load-impure-test")))
170   (with-test-program source nil
171     (load-and-assert partial partial partial)))
172
173 ;; Test loading a fasl
174 (let* ((source (pathname "load-impure-test.lisp"))
175        (fasl (compile-file-pathname source)))
176   (with-test-program source fasl
177     (load-and-assert fasl fasl fasl)))
178
179 ;; Test loading a fasl when supplying a partial pathname.
180 (let* ((source  (pathname "load-impure-test.lisp"))
181        (fasl (compile-file-pathname source))
182        (partial (pathname "load-impure-test")))
183   (with-test-program source fasl
184     (load-and-assert partial fasl fasl)))
185
186 ;; Test loading a fasl whose name lacks a type when supplying a
187 ;; partial pathname.
188 (let* ((source  (pathname "load-impure-test.lisp"))
189        (fasl (make-pathname :type :unspecific
190                             :defaults (compile-file-pathname source)))
191        (partial (pathname "load-impure-test")))
192   (with-test-program source fasl
193     (load-and-assert partial partial partial)))
194
195 ;; Test loading a fasl with a strange type
196 (let* ((source (pathname "load-impure-test.lisp"))
197        (fasl (make-pathname :defaults (compile-file-pathname source)
198                             :type "compiled-lisp")))
199   (with-test-program source fasl
200     (load-and-assert fasl fasl fasl)))
201
202 ;;; Errors
203
204 ;; Ensure that loading a fasl specified with a type checks for the
205 ;; header.
206 (let* ((source (pathname "load-impure-test.lisp"))
207        (fasl (compile-file-pathname source)))
208   (with-test-program source fasl
209     (with-open-file (f fasl :direction :io :if-exists :overwrite
210                        :element-type '(unsigned-byte 8))
211       (write-byte 0 f))
212     (handler-case (load fasl)
213       (sb-fasl::fasl-header-missing () :ok))))
214
215 ;; Ensure that loading a fasl specified without a type checks for the
216 ;; header.  Note: this wasn't the behavior in
217 ;; src/code/target-load.lisp v1.40 and earlier (SBCL version 1.0.12.35
218 ;; or so).  If target-load.lisp is reverted to that state eventually,
219 ;; this test should be removed (or that definition of LOAD altered).
220 (let* ((source (pathname "load-impure-test.lisp"))
221        (fasl (compile-file-pathname source))
222        (fasl-spec (make-pathname :type nil
223                                  :defaults (compile-file-pathname source))))
224   (with-test-program source fasl
225     (with-open-file (f fasl :direction :io :if-exists :overwrite
226                        :element-type '(unsigned-byte 8))
227       (write-byte 0 f))
228     (handler-case (load fasl-spec)
229       (sb-fasl::fasl-header-missing () :ok))))
230
231 ;; Ensure that we get an error when the source file is newer than the
232 ;; fasl and the supplied argument is an incomplete pathname.
233 (let* ((source (pathname "load-impure-test.lisp"))
234        (fasl (compile-file-pathname source))
235        (spec (make-pathname :type nil :defaults source)))
236   (with-test-program source fasl
237     (sleep 1)
238     (with-open-file (*standard-output* source :direction :output
239                                        :if-exists :append)
240       (write-line ";;comment"))
241     (handler-case (load spec)
242       ;; IWBNI the error signalled here were more specific than
243       ;; SIMPLE-ERROR.
244       (error () :|well, we got an error!|))))
245
246 ;; Ensure that we can invoke the restart SOURCE in the above case.
247 (let* ((source (pathname "load-impure-test.lisp"))
248        (fasl (compile-file-pathname source))
249        (spec (make-pathname :type nil :defaults source)))
250   (with-test-program source fasl
251     (sleep 1)
252     (with-open-file (*standard-output* source :direction :output
253                                        :if-exists :append)
254       (write-line ";;comment"))
255     (handler-bind ((error (lambda (error)
256                             (declare (ignore error))
257                             (when (find-restart 'sb-fasl::source)
258                               (invoke-restart 'sb-fasl::source)))))
259       (load-and-assert spec source source))))
260
261 ;; Ensure that we can invoke the restart OBJECT in the above case.
262 (let* ((source (pathname "load-impure-test.lisp"))
263        (fasl (compile-file-pathname source))
264        (spec (make-pathname :type nil :defaults source)))
265   (with-test-program source fasl
266     (sleep 1)
267     (with-open-file (*standard-output* source :direction :output
268                                        :if-exists :append)
269       (write-line ";;comment"))
270     (handler-bind ((error (lambda (error)
271                             (declare (ignore error))
272                             (when (find-restart 'sb-fasl::object)
273                               (invoke-restart 'sb-fasl::object)))))
274       (load-and-assert spec fasl fasl))))
275
276 (with-test (:name :bug-332)
277   (flet ((stimulate-sbcl ()
278            (let ((filename
279                   (format nil "~A/~A.lisp"
280                           (or (posix-getenv "TEST_DIRECTORY")
281                               (posix-getenv "TMPDIR")
282                               "/tmp")
283                           (gensym))))
284              (ensure-directories-exist filename)
285              ;; create a file which redefines a structure incompatibly
286              (with-open-file (f filename :direction :output :if-exists :supersede)
287                (print '(defstruct bug-332 foo) f)
288                (print '(defstruct bug-332 foo bar) f))
289              ;; compile and load the file, then invoke the continue restart on
290              ;; the structure redefinition error
291              (handler-bind ((error (lambda (c) (continue c))))
292                (load (compile-file filename))))))
293     (stimulate-sbcl)
294     (stimulate-sbcl)
295     (stimulate-sbcl)))
296
297 (defun load-empty-file (type)
298   (let ((pathname (make-pathname :name "load-impure-lisp-empty-temp"
299                                  :type type)))
300       (unwind-protect
301            (progn
302              (with-open-file (f pathname
303                                 :if-exists :supersede
304                                 :direction :output))
305              (handler-case
306                  (progn (load pathname) t)
307                (error () nil)))
308         (ignore-errors (delete-file pathname)))))
309
310 (with-test (:name (load "empty.lisp"))
311   (assert (load-empty-file "lisp")))
312
313 (with-test (:name (load "empty.fasl"))
314   (assert (not (load-empty-file "fasl"))))
315
316 (with-test (:name :parallel-fasl-load)
317   #+sb-thread
318   (let ((lisp #p"parallel-fasl-load-test.lisp")
319         (fasl nil)
320         (ready nil))
321     (unwind-protect
322          (progn
323            (multiple-value-bind (compiled warned failed)
324                (compile-file lisp)
325              (setf fasl compiled)
326              (assert (not warned))
327              (assert (not failed))
328              (labels ((load-loop ()
329                         (let* ((*standard-output* (make-broadcast-stream))
330                                (*error-output* *standard-output*))
331                           (sb-ext:wait-for ready)
332                           (handler-case
333                               (progn
334                                 (loop repeat 1000
335                                       do (load fasl)
336                                          (test-it))
337                                 t)
338                             (error (e) e))))
339                       (test-it ()
340                         (assert (= 1 (one-fun)))
341                         (assert (= 2 (two-fun)))
342                         (assert (= 42 (symbol-value '*var*)))
343                         (assert (= 13 (symbol-value '*quux*)))))
344                (let ((t1 (sb-thread:make-thread #'load-loop))
345                      (t2 (sb-thread:make-thread #'load-loop))
346                      (t3 (sb-thread:make-thread #'load-loop)))
347                  (setf ready t)
348                  (let ((r1 (sb-thread:join-thread t1))
349                        (r2 (sb-thread:join-thread t2))
350                        (r3 (sb-thread:join-thread t3)))
351                    (unless (and (eq t r1) (eq t r2) (eq t r3))
352                      (error "R1: ~A~2%R2: ~A~2%R2: ~A" r1 r2 r3))
353                    ;; These ones cannot be tested while redefinitions are running:
354                    ;; adding a method implies REMOVE-METHOD, so a call would be racy.
355                    (assert (eq :ok (a-slot (make-instance 'a-class :slot :ok))))
356                    (assert (eq 'cons (gen-fun '(foo))))
357                    (assert (eq 'a-class (gen-fun (make-instance 'a-class)))))
358                  (test-it)))))
359       (when fasl
360         (ignore-errors (delete-file fasl))))))
361
362 (defvar *pack*)
363 #+sb-simd-pack
364 (with-test (:name :load-simd-pack-int)
365   (with-open-file (s *tmp-filename*
366                      :direction :output
367                      :if-exists :supersede
368                      :if-does-not-exist :create)
369     (print '(setq *pack* (sb-kernel:%make-simd-pack-ub64 2 4)) s))
370   (let (tmp-fasl)
371     (unwind-protect
372          (progn
373            (setq tmp-fasl (compile-file *tmp-filename*))
374            (let ((*pack* nil))
375              (load tmp-fasl)
376              (assert (typep *pack* '(sb-kernel:simd-pack integer)))
377              (assert (= 2 (sb-kernel:%simd-pack-low *pack*)))
378              (assert (= 4 (sb-kernel:%simd-pack-high *pack*)))))
379       (when tmp-fasl (delete-file tmp-fasl))
380       (delete-file *tmp-filename*))))
381
382 #+sb-simd-pack
383 (with-test (:name :load-simd-pack-single)
384   (with-open-file (s *tmp-filename*
385                      :direction :output
386                      :if-exists :supersede
387                      :if-does-not-exist :create)
388     (print '(setq *pack* (sb-kernel:%make-simd-pack-single 1f0 2f0 3f0 4f0)) s))
389   (let (tmp-fasl)
390     (unwind-protect
391          (progn
392            (setq tmp-fasl (compile-file *tmp-filename*))
393            (let ((*pack* nil))
394              (load tmp-fasl)
395              (assert (typep *pack* '(sb-kernel:simd-pack single-float)))
396              (assert (equal (multiple-value-list (sb-kernel:%simd-pack-singles *pack*))
397                             '(1f0 2f0 3f0 4f0)))))
398       (when tmp-fasl (delete-file tmp-fasl))
399       (delete-file *tmp-filename*))))
400
401 #+sb-simd-pack
402 (with-test (:name :load-simd-pack-double)
403   (with-open-file (s *tmp-filename*
404                      :direction :output
405                      :if-exists :supersede
406                      :if-does-not-exist :create)
407     (print '(setq *pack* (sb-kernel:%make-simd-pack-double 1d0 2d0)) s))
408   (let (tmp-fasl)
409     (unwind-protect
410          (progn
411            (setq tmp-fasl (compile-file *tmp-filename*))
412            (let ((*pack* nil))
413              (load tmp-fasl)
414              (assert (typep *pack* '(sb-kernel:simd-pack double-float)))
415              (assert (equal (multiple-value-list (sb-kernel:%simd-pack-doubles *pack*))
416                             '(1d0 2d0)))))
417       (when tmp-fasl (delete-file tmp-fasl))
418       (delete-file *tmp-filename*))))