Add :application-type parameter for save-lisp-and-die on Windows.
[sbcl.git] / tests / loop.pure.lisp
1 ;;;; miscellaneous tests of LOOP-related stuff
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 (in-package "CL-USER")
15
16 (load "compiler-test-util.lisp")
17
18 ;;; The bug reported by Alexei Dejneka on sbcl-devel 2001-09-03
19 ;;; is fixed now.
20 (assert (equal (let ((hash (make-hash-table)))
21                  (setf (gethash 'key1 hash) 'val1)
22                  (setf (gethash 'key2 hash) 'val2)
23                  (sort (loop for key being each hash-key in hash
24                              collect key)
25                        #'string<))
26                '(key1 key2)))
27
28 ;;; Bug 81, reported by Wolfhard Buss on cmucl-help 2001-02-14, was
29 ;;; fixed by Alexey Dejneka's patch on sbcl-devel 2001-09-30.
30 (assert (equal '(0.0 1.0 2.0 3.0)
31                (loop with (a . b) of-type float = '(0.0 . 1.0)
32                      and (c . d) of-type float = '(2.0 . 3.0)
33                      return (list a b c d))))
34
35 ;;; a bug reported and fixed by Alexey Dejneka sbcl-devel 2001-10-05:
36 ;;; The type declarations should apply, hence under Python's
37 ;;; declarations-are-assertions rule, the code should signal a type
38 ;;; error. (Except when running interpreted code)
39 #+#.(cl:if (cl:eq sb-ext:*evaluator-mode* :compile) '(and) '(or))
40 (assert (typep (nth-value 1
41                           (ignore-errors
42                             (funcall (lambda ()
43                                        (loop with (a . b)
44                                              of-type float = '(5 . 5)
45                                              return (list a b))))))
46                'type-error))
47
48 ;;; bug 103, reported by Arthur Lemmens sbcl-devel 2001-05-05,
49 ;;; fixed by Alexey Dejneka patch sbcl-devel 2001-10-05:
50 ;;; LOOP syntax requires that forms after INITIALLY, FINALLY, and DO
51 ;;; must be compound forms.
52 (multiple-value-bind (function warnings-p failure-p)
53     (compile nil
54              '(lambda ()
55                 (loop while t do
56                       *print-level*
57                       (print t))))
58   (declare (ignore function warnings-p))
59   (assert failure-p))
60
61 ;;; a bug reported by Paul F. Dietz (in his ANSI test suite):
62 ;;; duplicate bindings in LOOP must signal errors of type
63 ;;; PROGRAM-ERROR.
64 (assert (typep (nth-value 1
65                           (ignore-errors
66                             (funcall (lambda ()
67                                        (loop for (a . a) in '((1 . 2) (3 . 4))
68                                              return a)))))
69                'program-error))
70
71 ;;; similar to gcl/ansi-test LOOP.1.27, and fixed at the same time:
72 (assert (equal (loop for x downto 7 by 2 from 13 collect x) '(13 11 9 7)))
73
74 ;;; some more from gcl/ansi-test:
75 (let ((table (make-hash-table)))
76   (setf (gethash 'foo table) '(bar baz))
77   (assert (= (loop for nil being the hash-keys of table count t) 1))
78   (assert (equal (loop for nil being the hash-keys of table
79                                using (hash-value (v1 . v2))
80                        when v1
81                          return v2)
82                  '(baz))))
83
84 (assert (= (loop for nil being the external-symbols of :cl count t) 978))
85 (assert (= (loop for x being the external-symbols of :cl count x) 977))
86
87 (let ((*package* (find-package :cl)))
88   (assert (= (loop for x being each external-symbol count t) 978)))
89
90 (assert (eq (loop for a = (return t) return nil) t))
91
92 (multiple-value-bind (result error)
93     (ignore-errors
94       (loop for nil being the external-symbols of :nonexistent-package
95             count t))
96   (assert (null result))
97   (assert (typep error 'package-error)))
98
99 (assert (equal (loop for i from 1 repeat (the (integer 7 7) 7) collect i)
100                '(1 2 3 4 5 6 7)))
101
102 (multiple-value-bind (result error)
103     (ignore-errors
104       (eval '(loop for i from 1 repeat 7 of-type fixnum collect i)))
105   (assert (null result))
106   (assert (typep error 'program-error)))
107
108 (assert (equal
109          (ignore-errors (loop for i from 1 repeat 6.5 collect i))
110          (ignore-errors (loop for i from 1 repeat (eval '6.5) collect i))))
111
112 (assert (eq (block nil
113               (loop named foo do (loop-finish) finally (return :good))
114               :bad)
115             :good))
116
117 (assert (= (loop with (a nil) = '(1 2) return a) 1))
118 (assert (= (loop with (nil a) = '(1 2) return a) 2))
119 (assert (= (loop with (a . nil) = '(1 2) return a) 1))
120 (assert (equal (loop with (nil . a) = '(1 2) return a) '(2)))
121
122 (multiple-value-bind (result error)
123     (ignore-errors
124       (loop for i in '(1 2 3) collect i always (< i 4)))
125   (assert (null result))
126   (assert (typep error 'program-error)))
127 (assert (equal
128          (loop for i in '(1 2 3) collect i into foo always (< i 4)
129                finally (return foo))
130          '(1 2 3)))
131 (assert (equal
132          (loop for i in '(1 2 3) collect i into foo always (= i 4)
133                finally (return foo))
134          nil))
135 (multiple-value-bind (result error)
136     (ignore-errors
137       (loop for i in '(1 2 3) always (< i 4) collect i))
138   (assert (null result))
139   (assert (typep error 'program-error)))
140 (assert (equal
141          (loop for i in '(1 2 3) always (< i 4) collect i into foo
142                finally (return foo))
143          '(1 2 3)))
144 (assert (equal
145          (loop for i in '(1 2 3) always (= i 4) collect i into foo
146                finally (return foo))
147          nil))
148 (multiple-value-bind (result error)
149     (ignore-errors
150       (loop for i in '(1 2 3) thereis (= i 3) collect i))
151   (assert (null result))
152   (assert (typep error 'program-error)))
153
154 (multiple-value-bind (result error)
155     (ignore-errors
156       (loop with i = 1 for x from 1 to 3 collect x into i))
157   (assert (null result))
158   (assert (typep error 'program-error)))
159 (multiple-value-bind (result error)
160     ;; this one has a plausible interpretation in terms of LET*, but
161     ;; ANSI seems specifically to disallow it
162     (ignore-errors
163       (loop with i = 1 with i = (1+ i)
164             for x from 1 to 3
165             collect (+ x i)))
166   (assert (null result))
167   (assert (typep error 'program-error)))
168
169 (let ((it 'z))
170   (assert (equal
171            ;; this one just seems weird.  Nevertheless...
172            (loop for i in '(a b c d)
173                  when i
174                    collect it
175                    and collect it)
176            '(a z b z c z d z))))
177
178 (let ((ht (make-hash-table)))
179   (setf (gethash 1 ht) 3)
180   (setf (gethash 7 ht) 15)
181   (assert (= (loop for v fixnum being each hash-key in ht sum v) 8))
182   (assert (= (loop for v fixnum being each hash-value in ht sum v) 18))
183   #+#.(cl:if (cl:eq sb-ext:*evaluator-mode* :compile) '(and) '(or))
184   (assert (raises-error? (loop for v float being each hash-value in ht sum v)
185                          type-error)))
186
187 ;; arithmetic indexes can be NIL or symbols.
188 (assert (equal (loop for nil from 0 to 2 collect nil)
189                '(nil nil nil)))
190 (assert (equal (loop for nil to 2 collect nil)
191                '(nil nil nil)))
192
193 ;; although allowed by the loop syntax definition in 6.2/LOOP,
194 ;; 6.1.2.1.1 says: "The variable var is bound to the value of form1 in
195 ;; the first iteration[...]"; since we can't bind (i j) to anything,
196 ;; we give a program error.
197 (multiple-value-bind (function warnings-p failure-p)
198     (compile nil
199              `(lambda ()
200                 (loop for (i j) from 4 to 6 collect nil)))
201   (assert failure-p))
202
203 ;; ...and another for indexes without FROM forms (these are treated
204 ;; differently by the loop code right now
205 (multiple-value-bind (function warnings-p failure-p)
206     (compile nil
207              `(lambda ()
208                 (loop for (i j) to 6 collect nil)))
209   (assert failure-p))
210
211 (assert
212  (equal
213   (let ((x 2d0))
214     (loop for d of-type double-float from 0d0 to 10d0 by x collect d))
215   '(0d0 2d0 4d0 6d0 8d0 10d0)))
216 (assert
217  (equal
218   (let ((x 2d0))
219     (loop for d of-type double-float downfrom 10d0 to 0d0 by x collect d))
220   '(10d0 8d0 6d0 4d0 2d0 0d0)))
221
222 (let ((fn (handler-case
223               (compile nil '(lambda ()
224                              (declare (special x y))
225                              (loop thereis (pop x) thereis (pop y))))
226             (warning (c) (error "Warned: ~S" c)))))
227   (let ((x (list nil nil 1))
228         (y (list nil 2 nil)))
229     (declare (special x y))
230     (assert (= (funcall fn) 2))))
231
232 ;;; Incorrect LIST type declaration, reported and patched by Teemu
233 ;;; Kalvas: end testing is done "as if by atom" so this is supposed
234 ;;; to work.
235 (assert (equal '(1 2) (loop for (a . b) on '(1 2 . 3)  collect a)))
236
237 ;;; Detection of duplicate bindings, reported by Bruno Haible for CMUCL.
238 (multiple-value-bind (_ condition)
239     (ignore-errors
240       (macroexpand '(LOOP WITH A = 0 FOR A DOWNFROM 10 TO 0 DO (PRINT A))))
241   (declare (ignore _))
242   (assert (typep condition 'program-error)))
243
244 ;;; Loop variable with a range excluding 0, reported by Andras Simon.
245 ;;; (Used to signal an error during macroexpansion.)
246 (assert (not (loop with foo of-type (single-float 1.0 2.0) = 1.5 do (return))))
247
248 ;;; 1.0.26.12 used to signal a bogus type error for this.
249 (loop with x of-type (simple-vector 1) = (make-array '(1))
250       repeat 1
251       return x)
252
253 (with-test (:name :bug-540186)
254   (let ((fun (compile nil `(lambda (x)
255                              (loop for i from 0 below (length x)
256                                    for vec of-type vector = (aref x i)
257                                    collect vec)))))
258     (assert (equal '("foo" "bar")
259              (funcall fun
260                       (vector "foo" "bar"))))))
261
262 (with-test (:name :bug-lp613871)
263   (multiple-value-bind (function warnings-p failure-p)
264       (compile nil '(lambda () (loop with nil = 1 repeat 2 collect t)))
265     (assert (null warnings-p))
266     (assert (null failure-p))
267     (assert (equal '(t t) (funcall function))))
268   (multiple-value-bind (function warnings-p failure-p)
269       (compile nil '(lambda () (loop with nil repeat 2 collect t)))
270     (assert (null warnings-p))
271     (assert (null failure-p))
272     (assert (equal '(t t) (funcall function)))))
273
274 (with-test (:name :bug-654220-regression)
275   (assert (= 32640 (loop for i to 255
276                          sum i into sum of-type fixnum
277                          finally (return sum)))))
278
279 (with-test (:name :of-type-character-init)
280   ;; The intention here is to if we initialize C to NIL before iteration start
281   ;; by looking for tell-tale types such as (OR NULL CHARACTER). ...not the
282   ;; most robust test ever, no.
283   (let* ((fun (compile nil `(lambda (x)
284                               (loop for c of-type character in x
285                                     collect (char-code c)))))
286          (consts (ctu:find-code-constants fun :type '(or symbol list))))
287     (assert (or (null consts) (equal 'character consts)))))