X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=tests%2Fcompiler.pure.lisp;h=841bf9a757877cacaded84c39ea2c0094c161310;hb=9489abab7f981b8eea2aec8a883f2eb48d4cb138;hp=5abc69e2d84c0f38e779612d2a7c6df510755324;hpb=3520a51b0035094f8da72639fa72ad8a844e0982;p=sbcl.git diff --git a/tests/compiler.pure.lisp b/tests/compiler.pure.lisp index 5abc69e..841bf9a 100644 --- 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) @@ -222,5 +222,183 @@ (assert (null result)) (assert (typep error 'program-error))) +;;; ECASE should treat a bare T as a literal key +(multiple-value-bind (result error) + (ignore-errors (ecase 1 (t 0))) + (assert (null result)) + (assert (typep error 'type-error))) + +(multiple-value-bind (result error) + (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))) + +;;; FUNCALL of special operators and macros should signal an +;;; UNDEFINED-FUNCTION error +(multiple-value-bind (result error) + (ignore-errors (funcall 'quote 1)) + (assert (null result)) + (assert (typep error 'undefined-function)) + (assert (eq (cell-error-name error) 'quote))) +(multiple-value-bind (result error) + (ignore-errors (funcall 'and 1)) + (assert (null result)) + (assert (typep error 'undefined-function)) + (assert (eq (cell-error-name error) 'and))) + +;;; PSETQ should behave when given complex symbol-macro arguments +(multiple-value-bind (sequence index) + (symbol-macrolet ((x (aref a (incf i))) + (y (aref a (incf i)))) + (let ((a (copy-seq #(0 1 2 3 4 5 6 7 8 9))) + (i 0)) + (psetq x (aref a (incf i)) + y (aref a (incf i))) + (values a i))) + (assert (equalp sequence #(0 2 2 4 4 5 6 7 8 9))) + (assert (= index 4))) + +(multiple-value-bind (result error) + (ignore-errors + (let ((x (list 1 2))) + (psetq (car x) 3) + x)) + (assert (null result)) + (assert (typep error 'program-error))) + +;;; COPY-SEQ should work on known-complex vectors: +(assert (equalp #(1) + (let ((v (make-array 0 :fill-pointer 0))) + (vector-push-extend 1 v) + (copy-seq v)))) + +;;; to support INLINE functions inside MACROLET, it is necessary for +;;; FUNCTION-LAMBDA-EXPRESSION to return a proper lambda expression in +;;; certain circumstances, one of which is when compile is called from +;;; top-level. +(assert (equal + (function-lambda-expression + (compile nil '(lambda (x) (block nil (print x))))) + '(lambda (x) (block nil (print x))))) + +;;; bug 62: too cautious type inference in a loop +(assert (nth-value + 2 + (compile nil + '(lambda (a) + (declare (optimize speed (safety 0))) + (typecase a + (array (loop (print (car a))))))))) + +;;; Bug reported by Robert E. Brown sbcl-devel 2003-02-02: compiler +;;; failure +(compile nil + '(lambda (key tree collect-path-p) + (let ((lessp (key-lessp tree)) + (equalp (key-equalp tree))) + (declare (type (function (t t) boolean) lessp equalp)) + (let ((path '(nil))) + (loop for node = (root-node tree) + then (if (funcall lessp key (node-key node)) + (left-child node) + (right-child node)) + when (null node) + do (return (values nil nil nil)) + do (when collect-path-p + (push node path)) + (when (funcall equalp key (node-key node)) + (return (values node path t)))))))) + +;;; CONSTANTLY should return a side-effect-free function (bug caught +;;; by Paul Dietz' test suite) +(let ((i 0)) + (let ((fn (constantly (progn (incf i) 1)))) + (assert (= i 1)) + (assert (= (funcall fn) 1)) + (assert (= i 1)) + (assert (= (funcall fn) 1)) + (assert (= i 1)))) + +;;; Bug 240 reported by tonyms on #lisp IRC 2003-02-25 (modified version) +(loop for (fun warns-p) in + '(((lambda (&optional *x*) *x*) t) + ((lambda (&optional *x* &rest y) (values *x* y)) t) + ((lambda (&optional *print-base*) (values *print-base*)) nil) + ((lambda (&optional *print-base* &rest y) (values *print-base* y)) nil) + ((lambda (&optional *x*) (declare (special *x*)) (values *x*)) nil) + ((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))