diff --git a/ansi-tests/defclass-errors.lsp b/ansi-tests/defclass-errors.lsp index 61ebb9182f5729c9ab2d425450881252dbc0abfe..39d1f87f78e1daf77c5f1dc0d5fa0c9a589ea270 100644 --- a/ansi-tests/defclass-errors.lsp +++ b/ansi-tests/defclass-errors.lsp @@ -9,140 +9,162 @@ ;;; tests could be reduced in size. (deftest defclass.error.1 - (classify-error + (signals-error (defclass erroneous-class.1 () - (a b c d b e))) - program-error) + (a b c d b e)) + program-error) + t) (deftest defclass.error.2 - (classify-error + (signals-error (defclass erroneous-class.2 () ((s1 :initarg :foo)) - (:default-initargs :foo 1 :foo 2))) - program-error) + (:default-initargs :foo 1 :foo 2)) + program-error) + t) (deftest defclass.error.3 - (classify-error + (signals-error (defclass erroneous-class.3 () - ((s1 :initform 0 :initform 2)))) - program-error) + ((s1 :initform 0 :initform 2))) + program-error) + t) (deftest defclass.error.4 - (classify-error + (signals-error (defclass erroneous-class.4 () - ((s1 :initform 0 :initform 0)))) - program-error) + ((s1 :initform 0 :initform 0))) + program-error) + t) (deftest defclass.error.5 - (classify-error + (signals-error (defclass erroneous-class.5 () - ((s1 :type fixnum :type character)))) - program-error) + ((s1 :type fixnum :type character))) + program-error) + t) (deftest defclass.error.6 - (classify-error + (signals-error (defclass erroneous-class.6 () - ((s1 :type t :type t)))) - program-error) + ((s1 :type t :type t))) + program-error) + t) (deftest defclass.error.7 - (classify-error + (signals-error (defclass erroneous-class.7 () - ((s1 :documentation "foo" :documentation "bar")))) - program-error) + ((s1 :documentation "foo" :documentation "bar"))) + program-error) + t) (deftest defclass.error.8 - (classify-error + (signals-error (defclass erroneous-class.8 () - ((s1 :documentation #1="foo" :documentation #1#)))) - program-error) + ((s1 :documentation #1="foo" :documentation #1#))) + program-error) + t) (deftest defclass.error.9 - (classify-error + (signals-error (defclass erroneous-class.9 () - ((s1 :allocation :class :allocation :instance)))) - program-error) + ((s1 :allocation :class :allocation :instance))) + program-error) + t) (deftest defclass.error.10 - (classify-error + (signals-error (defclass erroneous-class.10 () - ((s1 :allocation :class :allocation :class)))) - program-error) + ((s1 :allocation :class :allocation :class))) + program-error) + t) (deftest defclass.error.11 - (classify-error + (signals-error (defclass erroneous-class.11 () - ((s1 :allocation :instance :allocation :instance)))) - program-error) + ((s1 :allocation :instance :allocation :instance))) + program-error) + t) (deftest defclass.error.12 - (classify-error + (signals-error (defclass erroneous-class.12 () - ((s1 #.(gensym) nil)))) - program-error) + ((s1 #.(gensym) nil))) + program-error) + t) (deftest defclass.error.13 - (classify-error + (signals-error (defclass erroneous-class.13 () (a b c) - (#.(gensym)))) - program-error) + (#.(gensym))) + program-error) + t) (deftest defclass.error.14 - (classify-error + (signals-error (defclass defclass-error-14 nil - (foo foo))) - program-error) + (foo foo)) + program-error) + t) (deftest defclass.error.15 - (classify-error + (signals-error (defclass defclass-error-15 nil - (foo (foo)))) - program-error) + (foo (foo))) + program-error) + t) (deftest defclass.error.16 - (classify-error + (signals-error (defclass defclass-error-16 nil ((foo :initarg f1)) - (:default-initargs :f1 10 :f1 20))) - program-error) + (:default-initargs :f1 10 :f1 20)) + program-error) + t) (deftest defclass.error.17 - (classify-error + (signals-error (defclass defclass-error-17 nil - ((foo :initform 10 :initform 20 :reader defclass-error-4/foo)))) - program-error) + ((foo :initform 10 :initform 20 :reader defclass-error-4/foo))) + program-error) + t) (deftest defclass.error.18 - (classify-error + (signals-error (defclass defclass-error-18 nil - ((foo :initform 10 :initform 10 :reader defclass-error-5/foo)))) - program-error) + ((foo :initform 10 :initform 10 :reader defclass-error-5/foo))) + program-error) + t) (deftest defclass.error.19 - (classify-error + (signals-error (defclass defclass-error-19 nil - ((foo :initarg f1 :type t :type t :reader defclass-error-6/foo)))) - program-error) + ((foo :initarg f1 :type t :type t :reader defclass-error-6/foo))) + program-error) + t) (deftest defclass.error.20 - (classify-error + (signals-error (defclass defclass-error-20 nil ((foo :initarg f1 :documentation "x" :reader defclass-error-7/foo - :documentation "x")))) - program-error) + :documentation "x"))) + program-error) + t) (deftest defclass.error.21 - (classify-error + (signals-error (defclass defclass-error-21 () - ((foo #:unknown-slot-option nil)))) - program-error) + ((foo #:unknown-slot-option nil))) + program-error) + t) (deftest defclass.error.22 (let ((option (gentemp "UNKNOWN-OPTION" (symbol-package :foo)))) (eval - `(classify-error + `(signals-error (defclass defclass-error-22 () (foo bar) - (,option nil))))) - program-error) + (,option nil)) + program-error))) + t) diff --git a/ansi-tests/defclass-forward-reference.lsp b/ansi-tests/defclass-forward-reference.lsp index 029fab666740def6827879c7f015ce2a37d04100..026a6728aaa31aad5b2d8d8ade79f2cc817318cd 100644 --- a/ansi-tests/defclass-forward-reference.lsp +++ b/ansi-tests/defclass-forward-reference.lsp @@ -119,18 +119,9 @@ (return 3)) (unless (typep (eval `(defclass ,c2 (,c4 ,c5) nil)) 'class) (return 4)) - (let ((error-symbol - (classify-error** - `(progn - (defclass ,c3 (,c5 ,c4) nil) - (make-instance ',c1))))) - (and (symbolp error-symbol) - (subtypep error-symbol 'error) - 'good)))) - good) - - - - - - + (handler-case + (eval `(progn + (defclass ,c3 (,c5 ,c4) nil) + (make-instance ',c1))) + (error () :good)))) + :good) diff --git a/ansi-tests/defconstant.lsp b/ansi-tests/defconstant.lsp index af229580b8e0826889c6985206c2b70a133a9e0c..a5aad4d7750214a540f5ca8f64e61f0c23210e7b 100644 --- a/ansi-tests/defconstant.lsp +++ b/ansi-tests/defconstant.lsp @@ -31,31 +31,34 @@ test-constant-3) ;;; (deftest defconstant.error.1 -;;; (classify-error (defconstant)) -;;; program-error) +;;; (signals-error (defconstant) program-error) +;;; t) ;;; ;;; (deftest defconstant.error.2 -;;; (classify-error (defconstant +ignorable-constant-name+)) -;;; program-error) +;;; (signals-error (defconstant +ignorable-constant-name+) program-error) +;;; t) ;;; ;;; (deftest defconstant.error.3 -;;; (classify-error (defconstant +ignorable-constant-name2+ nil +;;; (signals-error (defconstant +ignorable-constant-name2+ nil ;;; "This is a docstring" -;;; "This is an unnecessary extra argument.")) -;;; program-error) +;;; "This is an unnecessary extra argument.") +;;; program-error) +;;; t) (deftest defconstant.error.1 - (classify-error (funcall (macro-function 'defconstant))) - program-error) + (signals-error (funcall (macro-function 'defconstant)) + program-error) + t) (deftest defconstant.error.2 - (classify-error (funcall (macro-function 'defconstant) - '(defconstant +nonexistent-constant+ 0))) - program-error) + (signals-error (funcall (macro-function 'defconstant) + '(defconstant +nonexistent-constant+ 0)) + program-error) + t) (deftest defconstant.error.3 - (classify-error (funcall (macro-function 'defconstant) + (signals-error (funcall (macro-function 'defconstant) '(defconstant +nonexistent-constant+ 0) - nil nil)) - program-error) - \ No newline at end of file + nil nil) + program-error) + t) diff --git a/ansi-tests/defgeneric.lsp b/ansi-tests/defgeneric.lsp index 5d03fb3f16c1c910eab6ba103cdcf74e57580827..a210d51e0abd000a3acf18c16478f757a7f2af44 100644 --- a/ansi-tests/defgeneric.lsp +++ b/ansi-tests/defgeneric.lsp @@ -41,20 +41,23 @@ nil) (deftest defgeneric.error.4 - (classify-error (defgeneric defgeneric-error-fn.4 (x y) - (:argument-precedence-order x y x))) - program-error) + (signals-error (defgeneric defgeneric-error-fn.4 (x y) + (:argument-precedence-order x y x)) + program-error) + t) (deftest defgeneric.error.5 - (classify-error (defgeneric defgeneric-error-fn.5 (x) + (signals-error (defgeneric defgeneric-error-fn.5 (x) (:documentation "some documentation") - (:documentation "illegally repeated documentation"))) - program-error) + (:documentation "illegally repeated documentation")) + program-error) + t) (deftest defgeneric.error.6 - (classify-error (defgeneric defgeneric-error-fn.6 (x) - (unknown-option nil))) - program-error) + (signals-error (defgeneric defgeneric-error-fn.6 (x) + (unknown-option nil)) + program-error) + t) (deftest defgeneric.error.7 (handler-case @@ -66,9 +69,10 @@ :good) (deftest defgeneric.error.8 - (classify-error (defgeneric defgeneric-error-fn.8 (x y) - (:argument-precedence-order x))) - program-error) + (signals-error (defgeneric defgeneric-error-fn.8 (x y) + (:argument-precedence-order x)) + program-error) + t) ;;; Non-congruent methods cause defgeneric to signal an error @@ -178,20 +182,22 @@ ;;; error tests are necessary. See sections 7.6.5 of the CLHS. (deftest defgeneric.error.20 - (classify-error + (signals-error (let ((fn (defgeneric defgeneric-error-fn.20 (x &key) (:method ((x number) &key foo) (list x foo)) (:method ((x symbol) &key bar) (list x bar))))) - (funcall fn 1 :bar 'a))) - program-error) + (funcall fn 1 :bar 'a)) + program-error) + t) (deftest defgeneric.error.21 - (classify-error + (signals-error (let ((fn (defgeneric defgeneric-error-fn.21 (x &key) (:method ((x number) &key foo &allow-other-keys) (list x foo)) (:method ((x symbol) &key bar) (list x bar))))) - (funcall fn 'x :foo 'a))) - program-error) + (funcall fn 'x :foo 'a)) + program-error) + t) ;;; @@ -205,8 +211,6 @@ :good) - - ;;; Non error cases (deftest defgeneric.1 diff --git a/ansi-tests/define-compiler-macro.lsp b/ansi-tests/define-compiler-macro.lsp index 4fbd03d07ec2315bbd4f63a96e59a544f5c8fb5d..5e3dcb03a38e0047b2bbf28e57b89ffb99b91e8b 100644 --- a/ansi-tests/define-compiler-macro.lsp +++ b/ansi-tests/define-compiler-macro.lsp @@ -8,16 +8,19 @@ ;;; Need to add non-error tests (deftest define-compiler-macro.error.1 - (classify-error (funcall (macro-function 'define-compiler-macro))) - program-error) + (signals-error (funcall (macro-function 'define-compiler-macro)) + program-error) + t) (deftest define-compiler-macro.error.2 - (classify-error (funcall (macro-function 'define-compiler-macro) - '(definee-compiler-macro nonexistent-function ()))) - program-error) + (signals-error (funcall (macro-function 'define-compiler-macro) + '(definee-compiler-macro nonexistent-function ())) + program-error) + t) (deftest define-compiler-macro.error.3 - (classify-error (funcall (macro-function 'define-compiler-macro) + (signals-error (funcall (macro-function 'define-compiler-macro) '(definee-compiler-macro nonexistent-function ()) - nil nil)) - program-error) + nil nil) + program-error) + t) diff --git a/ansi-tests/define-modify-macro.lsp b/ansi-tests/define-modify-macro.lsp index b3a5fb4baf1db5d8e56b370833c9199bfa41183b..89e39273af9961f31283492a10ffdf2435387b6d 100644 --- a/ansi-tests/define-modify-macro.lsp +++ b/ansi-tests/define-modify-macro.lsp @@ -65,21 +65,22 @@ (3 #(0 0 3 0 0) 3)) ;;; (deftest define-modify-macro.error.1 -;;; (classify-error (define-modify-macro)) -;;; program-error) +;;; (signals-error (define-modify-macro) program-error) +;;; t) ;;; ;;; (deftest define-modify-macro.error.2 -;;; (classify-error (define-modify-macro dfm-error-1)) -;;; program-error) +;;; (signals-error (define-modify-macro dfm-error-1) program-error) +;;; t) ;;; ;;; (deftest define-modify-macro.error.3 -;;; (classify-error (define-modify-macro dfm-error-2 ())) -;;; program-error) +;;; (signals-error (define-modify-macro dfm-error-2 ()) program-error) +;;; t) ;;; ;;; (deftest define-modify-macro.error.4 -;;; (classify-error (define-modify-macro dfm-error-2 () nil "Documentation" -;;; "extra illegal argument")) -;;; program-error) +;;; (signals-error (define-modify-macro dfm-error-2 () nil "Documentation" +;;; "extra illegal argument") +;;; program-error) +;;; t) (def-macro-test define-modify-macro.error.1 (define-modify-macro nonexistent-modify-macro () foo)) diff --git a/ansi-tests/define-symbol-macro.lsp b/ansi-tests/define-symbol-macro.lsp index 9a02631c460b0a7e0370eba73f220ddb389de566..623477fde988ca0a1304197ce447fbec2108cc4f 100644 --- a/ansi-tests/define-symbol-macro.lsp +++ b/ansi-tests/define-symbol-macro.lsp @@ -6,18 +6,21 @@ (in-package :cl-test) (deftest define-symbol-macro.error.1 - (classify-error (funcall (macro-function 'define-symbol-macro))) - program-error) + (signals-error (funcall (macro-function 'define-symbol-macro)) + program-error) + t) (deftest define-symbol-macro.error.2 - (classify-error (funcall (macro-function 'define-symbol-macro) + (signals-error (funcall (macro-function 'define-symbol-macro) '(define-symbol-macro - nonexistent-symbol-macro nil))) - program-error) + nonexistent-symbol-macro nil)) + program-error) + t) (deftest define-symbol-macro.error.3 - (classify-error (funcall (macro-function 'define-symbol-macro) + (signals-error (funcall (macro-function 'define-symbol-macro) '(define-symbol-macro nonexistent-symbol-macro nil) - nil nil)) - program-error) + nil nil) + program-error) + t) diff --git a/ansi-tests/defmacro.lsp b/ansi-tests/defmacro.lsp index 91f799a65e1133a6708d90e6121b54655c309b05..dc1ae8e0dfdd32e5ce9dd4f8499a241e4cbe6d99 100644 --- a/ansi-tests/defmacro.lsp +++ b/ansi-tests/defmacro.lsp @@ -5,19 +5,23 @@ (in-package :cl-test) +;;; FIXME ;;; Need to add non-error tests (deftest defmacro.error.1 - (classify-error (funcall (macro-function 'defmacro))) - program-error) + (signals-error (funcall (macro-function 'defmacro)) + program-error) + t) (deftest defmacro.error.2 - (classify-error (funcall (macro-function 'defmacro) - '(defmacro nonexistent-macro ()))) - program-error) + (signals-error (funcall (macro-function 'defmacro) + '(defmacro nonexistent-macro ())) + program-error) + t) (deftest defmacro.error.3 - (classify-error (funcall (macro-function 'defmacro) + (signals-error (funcall (macro-function 'defmacro) '(defmacro nonexistent-macro ()) - nil nil)) - program-error) + nil nil) + program-error) + t) diff --git a/ansi-tests/defparameter.lsp b/ansi-tests/defparameter.lsp index a285c3a621f033a5f7b8b9385316e0edfd79fd65..9caafa3210038ed5abf4c0c421452be04ccfb143 100644 --- a/ansi-tests/defparameter.lsp +++ b/ansi-tests/defparameter.lsp @@ -52,31 +52,35 @@ 300) ;;; (deftest defparameter.error.1 -;;; (classify-error (defparameter)) -;;; program-error) +;;; (signals-error (defparameter) program-error) +;;; t) ;;; ;;; (deftest defparameter.error.2 -;;; (classify-error (defparameter *ignored-defparameter-name*)) -;;; program-error) +;;; (signals-error (defparameter *ignored-defparameter-name*) +;;; program-error) +;;; t) ;;; ;;; (deftest defparameter.error.3 -;;; (classify-error (defparameter *ignored-defparameter-name* nil +;;; (signals-error (defparameter *ignored-defparameter-name* nil ;;; "documentation" -;;; "illegal extra argument")) -;;; program-error) +;;; "illegal extra argument") +;;; program-error) +;;; t) (deftest defparameter.error.1 - (classify-error (funcall (macro-function 'defparameter))) - program-error) + (signals-error (funcall (macro-function 'defparameter)) + program-error) + t) (deftest defparameter.error.2 - (classify-error (funcall (macro-function 'defparameter) - '(defparameter *nonexistent-variable* nil))) - program-error) + (signals-error (funcall (macro-function 'defparameter) + '(defparameter *nonexistent-variable* nil)) + program-error) + t) (deftest defparameter.error.3 - (classify-error (funcall (macro-function 'defparameter) + (signals-error (funcall (macro-function 'defparameter) '(defparameter *nonexistent-variable* nil) - nil nil)) - program-error) - + nil nil) + program-error) + t) diff --git a/ansi-tests/deftype.lsp b/ansi-tests/deftype.lsp index 003d3bebdd4615e47051f4d0ffa755387a32eb84..047139d3f35e52aa444a2c676d8057560c0167fc 100644 --- a/ansi-tests/deftype.lsp +++ b/ansi-tests/deftype.lsp @@ -5,17 +5,24 @@ (in-package :cl-test) +;;; FIXME +;;; Need to add non-error tests + (deftest deftype.error.1 - (classify-error (funcall (macro-function 'deftype))) - program-error) + (signals-error (funcall (macro-function 'deftype)) + program-error) + t) (deftest deftype.error.2 - (classify-error (funcall (macro-function 'deftype) - '(deftype nonexistent-type () nil))) - program-error) + (signals-error (funcall (macro-function 'deftype) + '(deftype nonexistent-type () nil)) + program-error) + t) (deftest deftype.error.3 - (classify-error (funcall (macro-function 'deftype) + (signals-error (funcall (macro-function 'deftype) '(deftype nonexistent-type () nil) - nil nil)) - program-error) + nil nil) + program-error) + t) + diff --git a/ansi-tests/defun.lsp b/ansi-tests/defun.lsp index 7d9357a553937e2023054663eaedcf3f5ddc6744..5ac3508d7651b318adda77dc11ebc3e985f18fa4 100644 --- a/ansi-tests/defun.lsp +++ b/ansi-tests/defun.lsp @@ -6,19 +6,22 @@ (in-package :cl-test) (deftest defun.error.1 - (classify-error (funcall (macro-function 'defun))) - program-error) + (signals-error (funcall (macro-function 'defun)) + program-error) + t) (deftest defun.error.2 - (classify-error (funcall (macro-function 'defun) - '(defun nonexistent-function ()))) - program-error) + (signals-error (funcall (macro-function 'defun) + '(defun nonexistent-function ())) + program-error) + t) (deftest defun.error.3 - (classify-error (funcall (macro-function 'defun) + (signals-error (funcall (macro-function 'defun) '(defun nonexistent-function ()) - nil nil)) - program-error) + nil nil) + program-error) + t) ;;; Tests for implicit blocks diff --git a/ansi-tests/defvar.lsp b/ansi-tests/defvar.lsp index 1e1d3c9c7a0d205fc0951c2c3ac9dd87d52f4d27..5bffe6d3531a608eb738170560b0e48824bd5d9f 100644 --- a/ansi-tests/defvar.lsp +++ b/ansi-tests/defvar.lsp @@ -55,26 +55,29 @@ 0) ;;; (deftest defvar.error.1 -;;; (classify-error (defvar)) -;;; program-error) +;;; (signals-error (defvar) program-error) +;;; t) ;;; ;;; (deftest defvar.error.2 -;;; (classify-error (defvar *ignored-defvar-name* nil "documentation" -;;; "illegal extra argument")) -;;; program-error) +;;; (signals-error (defvar *ignored-defvar-name* nil "documentation" +;;; "illegal extra argument") +;;; program-error) +;;; t) (deftest defvar.error.1 - (classify-error (funcall (macro-function 'defvar))) - program-error) + (signals-error (funcall (macro-function 'defvar)) + program-error) + t) (deftest defvar.error.2 - (classify-error (funcall (macro-function 'defvar) - '(defvar *nonexistent-variable* nil))) - program-error) + (signals-error (funcall (macro-function 'defvar) + '(defvar *nonexistent-variable* nil)) + program-error) + t) (deftest defvar.error.3 - (classify-error (funcall (macro-function 'defvar) + (signals-error (funcall (macro-function 'defvar) '(defvar *nonexistent-variable* nil) - nil nil)) - program-error) - + nil nil) + program-error) + t) diff --git a/ansi-tests/delete-file.lsp b/ansi-tests/delete-file.lsp index 6692c02859fad109b3cc787d7d6e3f0b5a5c02be..bdcde337e304260c5bbece5af19d86b662510af0 100644 --- a/ansi-tests/delete-file.lsp +++ b/ansi-tests/delete-file.lsp @@ -54,8 +54,8 @@ ;;; (deftest delete-file.error.1 - (classify-error (delete-file)) - program-error) + (signals-error (delete-file) program-error) + t) (deftest delete-file.error.2 (let ((pn "scratch.txt")) @@ -64,18 +64,15 @@ (format s "Contents~%"))) (values (notnot (probe-file pn)) - (classify-error (delete-file "scratch.txt" nil)) + (signals-error (delete-file "scratch.txt" nil) program-error) (notnot (probe-file pn)) (delete-file pn) (probe-file pn))) - t program-error t t nil) + t t t t nil) (deftest delete-file.error.3 (let ((pn "nonexistent.txt")) (when (probe-file pn) (delete-file pn)) - (let ((result (classify-error (delete-file "nonexistent.txt")))) - (if (member result '(file-error t)) - t - result))) + (signals-error (delete-file "nonexistent.txt") file-error)) t) diff --git a/ansi-tests/deposit-field.lsp b/ansi-tests/deposit-field.lsp index 3a9dee1d4c2e8e97f55e1119bc1d229fde3e945d..188e17a788158ca9be51cf4d60c8c0655df29e7e 100644 --- a/ansi-tests/deposit-field.lsp +++ b/ansi-tests/deposit-field.lsp @@ -5,21 +5,25 @@ (in-package :cl-test) +;;; Error tests + (deftest deposit-field.error.1 - (classify-error (deposit-field)) - program-error) + (signals-error (deposit-field) program-error) + t) (deftest deposit-field.error.2 - (classify-error (deposit-field 1)) - program-error) + (signals-error (deposit-field 1) program-error) + t) (deftest deposit-field.error.3 - (classify-error (deposit-field 1 (byte 1 0))) - program-error) + (signals-error (deposit-field 1 (byte 1 0)) program-error) + t) (deftest deposit-field.error.4 - (classify-error (deposit-field 1 (byte 1 0) 0 nil)) - program-error) + (signals-error (deposit-field 1 (byte 1 0) 0 nil) program-error) + t) + +;;; Non-error tests (deftest deposit-field.1 (loop for pos = (random 32) diff --git a/ansi-tests/destructuring-bind.lsp b/ansi-tests/destructuring-bind.lsp index 61c67a4816c24f62adefc606b4ffd2e5186d60c8..57622dc17a2ed3b5ea4cfdf58d8f189374a30997 100644 --- a/ansi-tests/destructuring-bind.lsp +++ b/ansi-tests/destructuring-bind.lsp @@ -116,42 +116,48 @@ #| (deftest destructuring-bind.error.1 - (classify-error (destructuring-bind (a b c) nil (list a b c))) - program-error) + (signals-error (destructuring-bind (a b c) nil (list a b c)) + program-error) + t) (deftest destructuring-bind.error.2 - (classify-error (destructuring-bind ((a b c)) nil (list a b c))) - program-error) + (signals-error (destructuring-bind ((a b c)) nil (list a b c)) + program-error) + t) (deftest destructuring-bind.error.3 - (classify-error (destructuring-bind (a b) 'x (list a b))) - program-error) + (signals-error (destructuring-bind (a b) 'x (list a b)) + program-error) + t) (deftest destructuring-bind.error.4 - (classify-error (destructuring-bind (a . b) 'x (list a b))) - program-error) + (signals-error (destructuring-bind (a . b) 'x (list a b)) + program-error) + t) |# ;;; (deftest destructuring-bind.error.5 -;;; (classify-error (destructuring-bind)) -;;; program-error) +;;; (signals-error (destructuring-bind) program-error) +;;; t) ;;; ;;; (deftest destructuring-bind.error.6 -;;; (classify-error (destructuring-bind x)) -;;; program-error) +;;; (signals-error (destructuring-bind x) program-error) +;;; t) (deftest destructuring-bind.error.7 - (classify-error (funcall (macro-function 'destructuring-bind))) - program-error) + (signals-error (funcall (macro-function 'destructuring-bind)) + program-error) + t) (deftest destructuring-bind.error.8 - (classify-error (funcall (macro-function 'destructuring-bind) - '(destructuring-bind (a . b) '(1 2) nil))) - program-error) + (signals-error (funcall (macro-function 'destructuring-bind) + '(destructuring-bind (a . b) '(1 2) nil)) + program-error) + t) (deftest destructuring-bind.error.9 - (classify-error (funcall (macro-function 'destructuring-bind) + (signals-error (funcall (macro-function 'destructuring-bind) '(destructuring-bind (a . b) '(1 2) nil) - nil nil)) - program-error) - + nil nil) + program-error) + t) diff --git a/ansi-tests/directory.lsp b/ansi-tests/directory.lsp index 68867be28b1a67ea587efc8f05df8f691d3595bd..2c8ecfe0ff8269e4d194fc5096a7f196ca161f1f 100644 --- a/ansi-tests/directory.lsp +++ b/ansi-tests/directory.lsp @@ -57,5 +57,5 @@ nil) (deftest directory.error.1 - (classify-error (directory)) - program-error) + (signals-error (directory) program-error) + t) diff --git a/ansi-tests/divide.lsp b/ansi-tests/divide.lsp index 8c753b6d7c655a4f802b777766e1513e77177ae1..a0d0b47b74bbbcb0f501b5797e8d0e15969650a7 100644 --- a/ansi-tests/divide.lsp +++ b/ansi-tests/divide.lsp @@ -9,8 +9,8 @@ (compile-and-load "division-aux.lsp") (deftest /.error.1 - (classify-error (/)) - program-error) + (signals-error (/) program-error) + t) (deftest /.error.2 (divide-by-zero-test 0)) diff --git a/ansi-tests/dpb.lsp b/ansi-tests/dpb.lsp index d4fb2315f15d6ffdf0682cfad6fb898d81c781f0..b0b31f5ebaabad885730321165c09752698297b9 100644 --- a/ansi-tests/dpb.lsp +++ b/ansi-tests/dpb.lsp @@ -5,21 +5,25 @@ (in-package :cl-test) +;;; Error tests + (deftest dpb.error.1 - (classify-error (dpb)) - program-error) + (signals-error (dpb) program-error) + t) (deftest dpb.error.2 - (classify-error (dpb 1)) - program-error) + (signals-error (dpb 1) program-error) + t) (deftest dpb.error.3 - (classify-error (dpb 1 (byte 1 0))) - program-error) + (signals-error (dpb 1 (byte 1 0)) program-error) + t) (deftest dpb.error.4 - (classify-error (dpb 1 (byte 1 0) 0 nil)) - program-error) + (signals-error (dpb 1 (byte 1 0) 0 nil) program-error) + t) + +;;; Non-error tests (deftest dpb.1 (loop for pos = (random 32) diff --git a/ansi-tests/ecase.lsp b/ansi-tests/ecase.lsp index bc41a5ba1a6c22dc635742d04589f105b0d3a290..6a42ec1473469faf1a2ee506c06fbb372c0d5acd 100644 --- a/ansi-tests/ecase.lsp +++ b/ansi-tests/ecase.lsp @@ -10,23 +10,23 @@ 2) (deftest ecase.2 - (classify-error (ecase 1)) - type-error) + (signals-error (ecase 1) type-error) + t) (deftest ecase.3 - (classify-error (ecase 1 (a 1) (b 2) (c 3))) - type-error) + (signals-error (ecase 1 (a 1) (b 2) (c 3)) type-error) + t) ;;; It is legal to use T or OTHERWISE as key designators ;;; in ECASE forms. They have no special meaning here. (deftest ecase.4 - (classify-error (ecase 1 (t nil))) - type-error) + (signals-error (ecase 1 (t nil)) type-error) + t) (deftest ecase.5 - (classify-error (ecase 1 (otherwise nil))) - type-error) + (signals-error (ecase 1 (otherwise nil)) type-error) + t) (deftest ecase.6 (ecase 'b ((a z) 1) ((y b w) 2) ((b c) 3)) @@ -45,8 +45,8 @@ a) (deftest ecase.9 - (classify-error (ecase nil (nil 'a))) - type-error) + (signals-error (ecase nil (nil 'a)) type-error) + t) (deftest ecase.10 (ecase nil ((nil) 'a)) @@ -57,8 +57,8 @@ 1 2 3) (deftest ecase.12 - (classify-error (ecase t (a 10))) - type-error) + (signals-error (ecase t (a 10)) type-error) + t) (deftest ecase.13 (ecase t ((t) 10) (t 20)) @@ -70,24 +70,26 @@ 1) (deftest ecase.15 - (classify-error (ecase 'otherwise ((t) 10))) - type-error) + (signals-error (ecase 'otherwise ((t) 10)) type-error) + t) (deftest ecase.16 - (classify-error (ecase t ((otherwise) 10))) - type-error) + (signals-error (ecase t ((otherwise) 10)) type-error) + t) (deftest ecase.17 - (classify-error (ecase 'a (b 0) (c 1) (otherwise 2))) - type-error) + (signals-error (ecase 'a (b 0) (c 1) (otherwise 2)) + type-error) + t) (deftest ecase.18 - (classify-error (ecase 'a (b 0) (c 1) ((otherwise) 2))) - type-error) + (signals-error (ecase 'a (b 0) (c 1) ((otherwise) 2)) + type-error) + t) (deftest ecase.19 - (classify-error (ecase 'a (b 0) (c 1) ((t) 2))) - type-error) + (signals-error (ecase 'a (b 0) (c 1) ((t) 2)) type-error) + t) (deftest ecase.20 (ecase #\a @@ -160,16 +162,15 @@ good) (deftest ecase.error.1 - (classify-error (funcall (macro-function 'ecase))) - program-error) + (signals-error (funcall (macro-function 'ecase)) program-error) + t) (deftest ecase.error.2 - (classify-error (funcall (macro-function 'ecase) - '(ecase t))) - program-error) + (signals-error (funcall (macro-function 'ecase) '(ecase t)) + program-error) + t) (deftest ecase.error.3 - (classify-error (funcall (macro-function 'ecase) - '(ecase t) - nil nil)) - program-error) + (signals-error (funcall (macro-function 'ecase) '(ecase t) nil nil) + program-error) + t) diff --git a/ansi-tests/elt.lsp b/ansi-tests/elt.lsp index 16698ccf4bd63be4933b2048c12d0749c24f4c82..ef3b7f8ce5338f3b2c98c95e832e78b6f962de5e 100644 --- a/ansi-tests/elt.lsp +++ b/ansi-tests/elt.lsp @@ -10,27 +10,27 @@ ;; elt on lists (deftest elt.1 - (classify-error (elt nil 0)) - type-error) + (signals-error (elt nil 0) type-error) + t) (deftest elt.1a - (classify-error (elt nil -10)) - type-error) + (signals-error (elt nil -10) type-error) + t) (deftest elt.1b - (classify-error (locally (elt nil 0) t)) - type-error) + (signals-error (locally (elt nil 0) t) type-error) + t) (deftest elt.2 - (classify-error (elt nil 1000000)) - type-error) + (signals-error (elt nil 1000000) type-error) + t) (deftest elt.3 (elt '(a b c d e) 0) a) (deftest elt.4 (elt '(a b c d e) 2) c) (deftest elt.5 (elt '(a b c d e) 4) e) (deftest elt.5a - (classify-error (elt '(a b c d e) -4)) - type-error) + (signals-error (elt '(a b c d e) -4) type-error) + t) (deftest elt.6 (let ((x (make-int-list 1000))) @@ -59,10 +59,11 @@ ((a b c e) e)) (deftest elt.10 - (classify-error + (signals-error (let ((x (list 'a 'b 'c))) - (setf (elt x 4) 'd))) - type-error) + (setf (elt x 4) 'd)) + type-error) + t) (deftest elt.11 (let ((x (list 'a 'b 'c 'd 'e))) @@ -88,40 +89,46 @@ (79999 foo 80001)) (deftest elt.14 - (classify-error + (signals-error (let ((x (list 'a 'b 'c))) - (elt x 10))) - type-error) + (elt x 10)) + type-error) + t) (deftest elt.15 - (classify-error + (signals-error (let ((x (list 'a 'b 'c))) - (elt x 'a))) - type-error) + (elt x 'a)) + type-error) + t) (deftest elt.16 - (classify-error + (signals-error (let ((x (list 'a 'b 'c))) - (elt x 10.0))) - type-error) + (elt x 10.0)) + type-error) + t) (deftest elt.17 - (classify-error + (signals-error (let ((x (list 'a 'b 'c))) - (elt x -1))) - type-error) + (elt x -1)) + type-error) + t) (deftest elt.18 - (classify-error + (signals-error (let ((x (list 'a 'b 'c))) - (elt x -100000000000000000))) - type-error) + (elt x -100000000000000000)) + type-error) + t) (deftest elt.19 - (classify-error + (signals-error (let ((x (list 'a 'b 'c))) - (elt x #\w))) - type-error) + (elt x #\w)) + type-error) + t) (deftest elt.order.1 (let ((i 0) x y) @@ -143,9 +150,8 @@ k (a b c k e) 3 1 2 3) (deftest elt-v.1 - (classify-error - (elt (make-array '(0)) 0)) - type-error) + (signals-error (elt (make-array '(0)) 0) type-error) + t) ;; (deftest elt-v.2 (elt (make-array '(1)) 0) nil) ;; actually undefined (deftest elt-v.3 @@ -183,16 +189,18 @@ (a b c e e)) (deftest elt-v.10 - (classify-error + (signals-error (let ((x (make-array '(3) :initial-contents (list 'a 'b 'c)))) - (setf (elt x 4) 'd))) - type-error) + (setf (elt x 4) 'd)) + type-error) + t) (deftest elt-v.11 - (classify-error + (signals-error (let ((x (make-array '(3) :initial-contents (list 'a 'b 'c)))) - (setf (elt x -100) 'd))) - type-error) + (setf (elt x -100) 'd)) + type-error) + t) (deftest elt-v.12 (let ((x (make-int-array 100000))) @@ -210,8 +218,8 @@ ;;; Adjustable arrays (deftest elt-adj-array.1 - (classify-error (elt (make-adj-array '(0)) 0)) - type-error) + (signals-error (elt (make-adj-array '(0)) 0) type-error) + t) ;;; (deftest elt-adj-array.2 (elt (make-adj-array '(1)) 0) nil) ;; actually undefined @@ -250,16 +258,18 @@ (a b c e e)) (deftest elt-adj-array.10 - (classify-error + (signals-error (let ((x (make-adj-array '(3) :initial-contents (list 'a 'b 'c)))) - (setf (elt x 4) 'd))) - type-error) + (setf (elt x 4) 'd)) + type-error) + t) (deftest elt-adj-array.11 - (classify-error + (signals-error (let ((x (make-adj-array '(3) :initial-contents (list 'a 'b 'c)))) - (setf (elt x -100) 'd))) - type-error) + (setf (elt x -100) 'd)) + type-error) + t) (deftest elt-adj-array.12 (let ((x (make-int-array 100000 #'make-adj-array))) @@ -277,8 +287,8 @@ ;; displaced arrays (deftest elt-displaced-array.1 - (classify-error (elt (make-displaced-array '(0) 100) 0)) - type-error) + (signals-error (elt (make-displaced-array '(0) 100) 0) type-error) + t) (deftest elt-displaced-array.2 (elt (make-displaced-array '(1) 100) 0) @@ -305,21 +315,23 @@ 0 0 1) (deftest elt-fill-pointer.3 - (classify-error + (signals-error (let ((a (make-array '(5) :initial-contents '(0 0 1 0 0) :fill-pointer 3))) - (elt a 4))) - type-error) + (elt a 4)) + type-error) + t) (deftest elt-fill-pointer.4 - (classify-error + (signals-error (let ((a (make-array '(5) :initial-contents '(0 0 1 0 0) :element-type 'bit :fill-pointer 3))) - (elt a 4))) - type-error) + (elt a 4)) + type-error) + t) (deftest elt-fill-pointer.5 (let ((a (make-array '(5) @@ -330,13 +342,14 @@ #\a #\b #\c) (deftest elt-fill-pointer.6 - (classify-error + (signals-error (let ((a (make-array '(5) :initial-contents '(#\a #\b #\c #\d #\e) :element-type 'character :fill-pointer 3))) - (elt a 4))) - type-error) + (elt a 4)) + type-error) + t) (deftest elt-fill-pointer.7 (let ((a (make-array '(5) @@ -347,22 +360,23 @@ #\a #\b #\c) (deftest elt-fill-pointer.8 - (classify-error + (signals-error (let ((a (make-array '(5) :initial-contents '(#\a #\b #\c #\d #\e) :element-type 'base-char :fill-pointer 3))) - (elt a 4))) - type-error) + (elt a 4)) + type-error) + t) (deftest elt.error.1 - (classify-error (elt)) - program-error) + (signals-error (elt) program-error) + t) (deftest elt.error.2 - (classify-error (elt nil)) - program-error) + (signals-error (elt nil) program-error) + t) (deftest elt.error.3 - (classify-error (elt nil 0 nil)) - program-error) + (signals-error (elt nil 0 nil) program-error) + t) diff --git a/ansi-tests/endp.lsp b/ansi-tests/endp.lsp index 12b66c17d023e9e9cb61cdc45694f3021a4f0a2e..a82029832131141adde1122795c9288fc45dd678 100644 --- a/ansi-tests/endp.lsp +++ b/ansi-tests/endp.lsp @@ -40,13 +40,14 @@ type-error) (deftest endp.error.4 - (classify-error (endp)) - program-error) + (signals-error (endp) program-error) + t) (deftest endp.error.5 - (classify-error (endp nil nil)) - program-error) + (signals-error (endp nil nil) program-error) + t) (deftest endp.error.6 - (catch-type-error (locally (endp 1))) - type-error) + (signals-error (locally (endp 1)) type-error) + t) + diff --git a/ansi-tests/ensure-directories-exist.lsp b/ansi-tests/ensure-directories-exist.lsp index fd7edcbd6e2f474422f248370e05c27ecc91cb4a..50e80433608a75b930c91e2cf85511ef491e7230 100644 --- a/ansi-tests/ensure-directories-exist.lsp +++ b/ansi-tests/ensure-directories-exist.lsp @@ -138,16 +138,13 @@ ;; Need to add a LPN test (deftest ensure-directories-exist.error.1 - (classify-error + (signals-error (ensure-directories-exist (make-pathname :directory '(:relative :wild) - :defaults *default-pathname-defaults*))) - file-error) + :defaults *default-pathname-defaults*)) + file-error) + t) (deftest ensure-directories-exist.error.2 - (classify-error (ensure-directories-exist)) - program-error) - - - - + (signals-error (ensure-directories-exist) program-error) + t) diff --git a/ansi-tests/eql.lsp b/ansi-tests/eql.lsp index 10318a03b48131e29550a7f228ae33c9a84bf79a..e85a6d9d9867141485487181e835de6165bbc7d2 100644 --- a/ansi-tests/eql.lsp +++ b/ansi-tests/eql.lsp @@ -58,30 +58,30 @@ i x y)) nil 2 1 2) +;;; Error tests for EQL + (deftest eql.error.1 - (classify-error (eql)) - program-error) + (signals-error (eql) program-error) + t) (deftest eql.error.2 - (classify-error (eql nil)) - program-error) + (signals-error (eql nil) program-error) + t) (deftest eql.error.3 - (classify-error (eql nil nil nil)) - program-error) + (signals-error (eql nil nil nil) program-error) + t) ;;; Error tests for EQ (deftest eq.error.1 - (classify-error (eq)) - program-error) + (signals-error (eq) program-error) + t) (deftest eq.error.2 - (classify-error (eq nil)) - program-error) + (signals-error (eq nil) program-error) + t) (deftest eq.error.3 - (classify-error (eq nil nil nil)) - program-error) - - \ No newline at end of file + (signals-error (eq nil nil nil) program-error) + t) diff --git a/ansi-tests/equal.lsp b/ansi-tests/equal.lsp index 1e0e7595ab968c94bcbe89273a417bea9ed6fecc..12393d81b99342b4330f2ca3d79fed300a364ebc 100644 --- a/ansi-tests/equal.lsp +++ b/ansi-tests/equal.lsp @@ -82,14 +82,16 @@ i x y)) nil 2 1 2) +;;; Error tests + (deftest equal.error.1 - (classify-error (equal)) - program-error) + (signals-error (equal) program-error) + t) (deftest equal.error.2 - (classify-error (equal nil)) - program-error) + (signals-error (equal nil) program-error) + t) (deftest equal.error.3 - (classify-error (equal nil nil nil)) - program-error) + (signals-error (equal nil nil nil) program-error) + t) diff --git a/ansi-tests/equalp.lsp b/ansi-tests/equalp.lsp index 9fce34fbcfeb95bca9b2d0af4c4a236f78d13374..f918f6f9e2fcafa053c542fed60644c61491c49a 100644 --- a/ansi-tests/equalp.lsp +++ b/ansi-tests/equalp.lsp @@ -44,14 +44,16 @@ i x y)) nil 2 1 2) +;;; Error tests + (deftest equalp.error.1 - (classify-error (equalp)) - program-error) + (signals-error (equalp) program-error) + t) (deftest equalp.error.2 - (classify-error (equalp nil)) - program-error) + (signals-error (equalp nil) program-error) + t) (deftest equalp.error.3 - (classify-error (equalp nil nil nil)) - program-error) + (signals-error (equalp nil nil nil) program-error) + t) diff --git a/ansi-tests/etypecase.lsp b/ansi-tests/etypecase.lsp index 67bf6d1e1980dd961d24b51f0617a3d10b2e4919..7880e18dc48174f7e51f1003070fe0a7e3af8138 100644 --- a/ansi-tests/etypecase.lsp +++ b/ansi-tests/etypecase.lsp @@ -10,8 +10,8 @@ a) (deftest etypecase.2 - (classify-error (etypecase 1 (symbol 'a))) - type-error) + (signals-error (etypecase 1 (symbol 'a)) type-error) + t) (deftest etypecase.3 (etypecase 1 (symbol 'a) (t 'b)) @@ -71,16 +71,18 @@ good) (deftest etypecase.error.1 - (classify-error (funcall (macro-function 'etypecase))) - program-error) + (signals-error (funcall (macro-function 'etypecase)) + program-error) + t) (deftest etypecase.error.2 - (classify-error (funcall (macro-function 'etypecase) - '(etypecase t))) - program-error) + (signals-error (funcall (macro-function 'etypecase) + '(etypecase t)) + program-error) + t) (deftest etypecase.error.3 - (classify-error (funcall (macro-function 'etypecase) - '(etypecase t) - nil nil)) - program-error) + (signals-error (funcall (macro-function 'etypecase) + '(etypecase t) nil nil) + program-error) + t) diff --git a/ansi-tests/eval.lsp b/ansi-tests/eval.lsp index cf16659d42f1a9aded196fc7357fc20ba523eedb..4593ee7d8c2c0704865efd98ede9e620aa55f701 100644 --- a/ansi-tests/eval.lsp +++ b/ansi-tests/eval.lsp @@ -39,14 +39,13 @@ ;;; Error cases (deftest eval.error.1 - (classify-error (eval)) - program-error) + (signals-error (eval) program-error) + t) (deftest eval.error.2 - (classify-error (eval nil nil)) - program-error) + (signals-error (eval nil nil) program-error) + t) (deftest eval.error.3 - (classify-error (eval (list (gensym)))) - undefined-function) - + (signals-error (eval (list (gensym))) undefined-function) + t) diff --git a/ansi-tests/evenp.lsp b/ansi-tests/evenp.lsp index 9ad594728cbd5c78ee3ea354aea4875b71007552..37a3f6c0ccec91e703426d7ef7be554e6832e38a 100644 --- a/ansi-tests/evenp.lsp +++ b/ansi-tests/evenp.lsp @@ -8,12 +8,12 @@ (compile-and-load "numbers-aux.lsp") (deftest evenp.error.1 - (classify-error (evenp)) - program-error) + (signals-error (evenp) program-error) + t) (deftest evenp.error.2 - (classify-error (evenp 0 nil)) - program-error) + (signals-error (evenp 0 nil) program-error) + t) (deftest evenp.1 (loop for x in *numbers* @@ -24,7 +24,7 @@ (deftest evenp.2 (loop for x in *mini-universe* unless (or (integerp x) - (eq (classify-error** `(evenp (quote ,x))) 'type-error)) + (eval `(signals-error (evenp ',x) type-error))) collect x) nil) diff --git a/ansi-tests/every.lsp b/ansi-tests/every.lsp index 412fb158c7c46aacf0dcd72b987dabffec6fa6e8..65cf645f8117de3a2641ed5055a693d2146142a9 100644 --- a/ansi-tests/every.lsp +++ b/ansi-tests/every.lsp @@ -98,53 +98,54 @@ ;;; Error cases (deftest every.error.1 - (classify-error (every 1 '(a b c))) - type-error) + (signals-error (every 1 '(a b c)) type-error) + t) (deftest every.error.2 - (classify-error (every #\a '(a b c))) - type-error) + (signals-error (every #\a '(a b c)) type-error) + t) (deftest every.error.3 - (classify-error (every #() '(a b c))) - type-error) + (signals-error (every #() '(a b c)) type-error) + t) (deftest every.error.4 - (classify-error (every #'null 'a)) - type-error) + (signals-error (every #'null 'a) type-error) + t) (deftest every.error.5 - (classify-error (every #'null 100)) - type-error) + (signals-error (every #'null 100) type-error) + t) (deftest every.error.6 - (classify-error (every #'null 'a)) - type-error) + (signals-error (every #'null 'a) type-error) + t) (deftest every.error.7 - (classify-error (every #'eq () 'a)) - type-error) -` + (signals-error (every #'eq () 'a) type-error) + t) + (deftest every.error.8 - (classify-error (every)) - program-error) + (signals-error (every) program-error) + t) (deftest every.error.9 - (classify-error (every #'null)) - program-error) + (signals-error (every #'null) program-error) + t) (deftest every.error.10 - (classify-error (locally (every 1 '(a b c)) t)) - type-error) + (signals-error (locally (every 1 '(a b c)) t) type-error) + t) (deftest every.error.11 - (classify-error (every #'cons '(a b c))) - program-error) + (signals-error (every #'cons '(a b c)) program-error) + t) (deftest every.error.12 - (classify-error (every #'cons '(a b c) '(1 2 3) '(4 5 6))) - program-error) + (signals-error (every #'cons '(a b c) '(1 2 3) '(4 5 6)) program-error) + t) (deftest every.error.13 - (classify-error (every #'car '(a b c))) - type-error) + (signals-error (every #'car '(a b c)) type-error) + t) + diff --git a/ansi-tests/exp.lsp b/ansi-tests/exp.lsp index b6ead4a9c05a79e764663460a1a1842e1ccecabf..925725b0fccd161e6dd75ffb14a9c1989bfc997d 100644 --- a/ansi-tests/exp.lsp +++ b/ansi-tests/exp.lsp @@ -8,17 +8,21 @@ (compile-and-load "numbers-aux.lsp") (compile-and-load "exp-aux.lsp") +;;; Error tests + (deftest exp.error.1 - (classify-error (exp)) - program-error) + (signals-error (exp) program-error) + t) (deftest exp.error.2 - (classify-error (exp 0 nil)) - program-error) + (signals-error (exp 0 nil) program-error) + t) (deftest exp.error.3 - (classify-error (exp 0 0 0)) - program-error) + (signals-error (exp 0 0 0) program-error) + t) + +;;; Other tests (deftest exp.1 (let ((result (exp 0))) @@ -34,3 +38,5 @@ (mapcar #'exp '(-0.0s0 -0.0f0 -0.0d0 -0.0l0)) (1.0s0 1.0f0 1.0d0 1.0l0)) +;;; FIXME +;;; Add more tests here for floating point accuracy \ No newline at end of file diff --git a/ansi-tests/expt.lsp b/ansi-tests/expt.lsp index a974fba7989ef5eb0781c4433f42ea0670455d68..4b288363a12cd46be286df5f76ba1548fc0fc6af 100644 --- a/ansi-tests/expt.lsp +++ b/ansi-tests/expt.lsp @@ -5,17 +5,21 @@ (in-package :cl-test) +;;; Error tests + (deftest expt.error.1 - (classify-error (expt)) - program-error) + (signals-error (expt) program-error) + t) (deftest expt.error.2 - (classify-error (expt 1 1 1)) - program-error) + (signals-error (expt 1 1 1) program-error) + t) (deftest expt.error.3 - (classify-error (expt 1 1 nil nil)) - program-error) + (signals-error (expt 1 1 nil nil) program-error) + t) + +;;; Non-error tests (deftest expt.1 (expt 0 0) @@ -180,6 +184,7 @@ nil) #| +;;; FIXME ;;; I need to think more about how to do approximate float ;;; equality in a principled way.