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.