0.8.0.6:

[sbcl.git] / tests / compiler.pure.lisp

diff --git a/tests/compiler.pure.lisp b/tests/compiler.pure.lisp
index b58bbea..841bf9a 100644 (file)
--- a/tests/compiler.pure.lisp
+++ b/tests/compiler.pure.lisp
@@ -75,16 +75,16 @@
 
 ;;; another LET-related bug fixed by Alexey Dejneka at the same
 ;;; time as bug 112
-(multiple-value-bind (value error)
-    (ignore-errors
-      ;; should complain about duplicate variable names in LET binding
-      (compile nil
-              '(lambda ()
-                 (let (x
-                       (x 1))
-                   (list x)))))
-  (assert (null value))
-  (assert (typep error 'error)))
+(multiple-value-bind (fun warnings-p failure-p)
+    ;; should complain about duplicate variable names in LET binding
+    (compile nil
+            '(lambda ()
+              (let (x
+                    (x 1))
+                (list x))))
+  (declare (ignore warnings-p))
+  (assert (functionp fun))
+  (assert failure-p))
 
 ;;; bug 169 (reported by Alexey Dejneka 2002-05-12, fixed by David
 ;;; Lichteblau 2002-05-21)
@@ -232,7 +232,7 @@
     (ignore-errors (ecase 1 (t 0) (1 2)))
   (assert (eql result 2))
   (assert (null error)))
-         
+
 ;;; FTYPE should accept any functional type specifier
 (compile nil '(lambda (x) (declare (ftype function f)) (f x)))
 
@@ -332,3 +332,73 @@
        ((lambda (&optional *x* &rest y) (declare (special *x*)) (values *x* y)) nil))
    for real-warns-p = (nth-value 1 (compile nil fun))
    do (assert (eq warns-p real-warns-p)))
+
+;;; Bug reported by Gilbert Baumann on #lisp IRC 2003-03-26
+(assert (equal (funcall (eval '(lambda (x &optional (y (pop x))) (list x y)))
+                        '(1 2))
+               '((2) 1)))
+
+;;; Bug reported by Paul Dietz on cmucl-imp and fixed by Gerd
+;;; Moellmann: CONVERT-MORE-CALL failed on the following call
+(assert (eq (eval '((lambda (&key) 'u) :allow-other-keys nil)) 'u))
+
+(raises-error? (multiple-value-bind (a b c)
+                   (eval '(truncate 3 4))
+                 (declare (integer c))
+                 (list a b c))
+               type-error)
+
+(assert (equal (multiple-value-list (the (values &rest integer)
+                                      (eval '(values 3))))
+               '(3)))
+
+;;; Bug relating to confused representation for the wild function
+;;; type:
+(assert (null (funcall (eval '(lambda () (multiple-value-list (values)))))))
+
+;;; &ENVIRONMENT parameter should be bound first (from Paul Dietz'
+;;; test suite)
+(assert (eql (macrolet ((foo () 1))
+               (macrolet ((%f (&optional (x (macroexpand '(foo) env)) &environment env)
+                            x))
+                 (%f)))
+             1))
+
+;;; MACROLET should check for duplicated names
+(dolist (ll '((x (z x))
+              (x y &optional z x w)
+              (x y &optional z z)
+              (x &rest x)
+              (x &rest (y x))
+              (x &optional (y nil x))
+              (x &optional (y nil y))
+              (x &key x)
+              (x &key (y nil x))
+              (&key (y nil z) (z nil w))
+              (&whole x &optional x)
+              (&environment x &whole x)))
+  (assert (nth-value 2
+                     (handler-case
+                         (compile nil
+                                  `(lambda ()
+                                     (macrolet ((foo ,ll nil)
+                                                (bar (&environment env)
+                                                  `',(macro-function 'foo env)))
+                                       (bar))))
+                       (error (c)
+                         (values nil t t))))))
+
+(assert (typep (eval `(the arithmetic-error
+                          ',(make-condition 'arithmetic-error)))
+              'arithmetic-error))
+
+(assert (not (nth-value
+              2 (compile nil '(lambda ()
+                               (make-array nil :initial-element 11))))))
+
+(assert (raises-error? (funcall (eval #'open) "assertoid.lisp"
+                                :external-format '#:nonsense)))
+(assert (raises-error? (funcall (eval #'load) "assertoid.lisp"
+                                :external-format '#:nonsense)))
+
+(assert (= (the (values integer symbol) (values 1 'foo 13)) 1))