diff --git a/ansi-tests/abort.lsp b/ansi-tests/abort.lsp
index df4f3ddcbed49b590045f91d694b8e87113d505f..0c65eedc89a1f36dfc12f017d16e32a247dde1ce 100644
--- a/ansi-tests/abort.lsp
+++ b/ansi-tests/abort.lsp
@@ -42,12 +42,13 @@
   good)
 
 (deftest abort.5
-  (classify-error
+  (signals-error
    (let ((c1 (make-condition 'error))
 	 (c2 (make-condition 'error)))
      (with-condition-restarts
       c1
       (compute-restarts)
       ;; All conditions are now associated with c1
-      (abort c2))))
-  control-error)
+      (abort c2)))
+   control-error)
+  t)
diff --git a/ansi-tests/abs.lsp b/ansi-tests/abs.lsp
index 33cdc9018e81d0c3600b2ea15a1d20f4c5f920e3..2b8280a916a4d30c9b5379dad1f63a97f3878ce2 100644
--- a/ansi-tests/abs.lsp
+++ b/ansi-tests/abs.lsp
@@ -8,16 +8,16 @@
 (compile-and-load "numbers-aux.lsp")
 
 (deftest abs.error.1
-  (classify-error (abs))
-  program-error)
+  (signals-error (abs) program-error)
+  t)
 
 (deftest abs.error.2
-  (classify-error (abs 0 0))
-  program-error)
+  (signals-error (abs 0 0) program-error)
+  t)
 
 (deftest abs.error.3
-  (classify-error (abs 0 nil nil))
-  program-error)
+  (signals-error (abs 0 nil nil) program-error)
+  t)
 
 (deftest abs.1
   (loop for x in *numbers*
diff --git a/ansi-tests/acons.lsp b/ansi-tests/acons.lsp
index 94558d3ddf60e149097cbebf909125073a245682..cc193d4c8f0a43466fdee44a7828f7bfb2c6fc6a 100644
--- a/ansi-tests/acons.lsp
+++ b/ansi-tests/acons.lsp
@@ -46,17 +46,17 @@
   3 1 2 3)
 
 (deftest acons.error.1
-  (classify-error (acons))
-  program-error)
+  (signals-error (acons) program-error)
+  t)
 
 (deftest acons.error.2
-  (classify-error (acons 'a))
-  program-error)
+  (signals-error (acons 'a) program-error)
+  t)
 
 (deftest acons.error.3
-  (classify-error (acons 'a 'b))
-  program-error)
+  (signals-error (acons 'a 'b) program-error)
+  t)
 
 (deftest acons.error.4
-  (classify-error (acons 'a 'b 'c 'd))
-  program-error)
+  (signals-error (acons 'a 'b 'c 'd) program-error)
+  t)
diff --git a/ansi-tests/add-method.lsp b/ansi-tests/add-method.lsp
index f33754da99b9e0f66217f04ec873a81bcb324ee3..491d38b9ce893fbb14bdb5958f2715642a6698f4 100644
--- a/ansi-tests/add-method.lsp
+++ b/ansi-tests/add-method.lsp
@@ -42,22 +42,23 @@
   :error)
 
 (deftest add-method.error.4
-  (classify-error (add-method))
-  program-error)
+  (signals-error (add-method) program-error)
+  t)
 
 (deftest add-method.error.5
-  (classify-error (add-method #'add-method-gf-01))
-  program-error)
+  (signals-error (add-method #'add-method-gf-01) program-error)
+  t)
 
 (deftest add-method.error.6
-  (classify-error
+  (signals-error
    (let* ((gf (eval '(defgeneric add-method-gf-07 (x)
 		       (:method ((x t)) 'a))))
 	  (method (find-method #'add-method-gf-07 nil (list (find-class t))))
 	  (gf2 (eval '(defgeneric add-method-gf-08 (x)))))
      (remove-method gf method)
-     (add-method gf2 method nil)))
-  program-error)
+     (add-method gf2 method nil))
+   program-error)
+  t)
 
 (deftest add-method.error.7
   (let* ((gf (eval '(defgeneric add-method-gf-09 (x y)
diff --git a/ansi-tests/adjoin.lsp b/ansi-tests/adjoin.lsp
index 943c100bf1528cf3df7d206f2032922bee6f4e8a..669881f4fa2391994e38ebd70624b8dfd42e416d 100644
--- a/ansi-tests/adjoin.lsp
+++ b/ansi-tests/adjoin.lsp
@@ -156,42 +156,41 @@
   (a b c))
 
 (deftest adjoin.error.1
-  (classify-error (adjoin))
-  program-error)
+  (signals-error (adjoin) program-error)
+  t)
 
 (deftest adjoin.error.2
-  (classify-error (adjoin 'a))
-  program-error)
+  (signals-error (adjoin 'a) program-error)
+  t)
 
 (deftest adjoin.error.3
-  (classify-error (adjoin 'a '(b c) :bad t))
-  program-error)
+  (signals-error (adjoin 'a '(b c) :bad t) program-error)
+  t)
 
 (deftest adjoin.error.4
-  (classify-error (adjoin 'a '(b c) :allow-other-keys nil :bad t))
-  program-error)
+  (signals-error (adjoin 'a '(b c) :allow-other-keys nil :bad t) program-error)
+  t)
 
 (deftest adjoin.error.5
-  (classify-error (adjoin 'a '(b c) 1 2))
-  program-error)
+  (signals-error (adjoin 'a '(b c) 1 2) program-error)
+  t)
 
 (deftest adjoin.error.6
-  (classify-error (adjoin 'a '(b c) :test))
-  program-error)
+  (signals-error (adjoin 'a '(b c) :test) program-error)
+  t)
 
 (deftest adjoin.error.7
-  (classify-error (adjoin 'a '(b c) :test #'identity))
-  program-error)
+  (signals-error (adjoin 'a '(b c) :test #'identity) program-error)
+  t)
 
 (deftest adjoin.error.8
-  (classify-error (adjoin 'a '(b c) :test-not #'identity))
-  program-error)
+  (signals-error (adjoin 'a '(b c) :test-not #'identity) program-error)
+  t)
 
 (deftest adjoin.error.9
-  (classify-error (adjoin 'a '(b c) :key #'cons))
-  program-error)
+  (signals-error (adjoin 'a '(b c) :key #'cons) program-error)
+  t)
 
 (deftest adjoin.error.10
-  (classify-error (adjoin 'a (list* 'b 'c 'd)))
-  type-error)
-
+  (signals-error (adjoin 'a (list* 'b 'c 'd)) type-error)
+  t)
diff --git a/ansi-tests/adjustable-array-p.lsp b/ansi-tests/adjustable-array-p.lsp
index 6a3921883b2d0eaab3941552b82ae140e058879e..76461067eca5f1d6bee0a45847f6936f8d673b0c 100644
--- a/ansi-tests/adjustable-array-p.lsp
+++ b/ansi-tests/adjustable-array-p.lsp
@@ -36,16 +36,16 @@
 ;;; Error tests
 
 (deftest adjustable-array-p.error.1
-  (classify-error (adjustable-array-p))
-  program-error)
+  (signals-error (adjustable-array-p) program-error)
+  t)
 
 (deftest adjustable-array-p.error.2
-  (classify-error (adjustable-array-p "aaa" nil))
-  program-error)
+  (signals-error (adjustable-array-p "aaa" nil) program-error)
+  t)
 
 (deftest adjustable-array-p.error.3
-  (classify-error (adjustable-array-p 10))
-  type-error)
+  (signals-error (adjustable-array-p 10) type-error)
+  t)
 
 (deftest adjustable-array-p.error.4
   (let (why)
@@ -58,11 +58,12 @@
   nil)
 
 (deftest adjustable-array-p.error.5
-  (classify-error (locally (adjustable-array-p 10)))
-  type-error)
+  (signals-error (locally (adjustable-array-p 10)) type-error)
+  t)
 
 (deftest adjustable-array-p.error.6
-  (classify-error (let ((x 10))
+  (signals-error (let ((x 10))
 		    (locally (declare (optimize (safety 3)))
-			   (adjustable-array-p x))))
-  type-error)
+			   (adjustable-array-p x)))
+		 type-error)
+  t)
diff --git a/ansi-tests/allocate-instance.lsp b/ansi-tests/allocate-instance.lsp
index 830bec3c5b6bebdca7d33c3cfc7dbf91d9601c99..42c6322cc3ed90e2566a071474ec178f5f3f45e7 100644
--- a/ansi-tests/allocate-instance.lsp
+++ b/ansi-tests/allocate-instance.lsp
@@ -108,8 +108,8 @@
 ;;; Error tests
 
 (deftest allocate-instance.error.1
-  (classify-error (allocate-instance))
-  program-error)
+  (signals-error (allocate-instance) program-error)
+  t)
 
 ;;; Duane Rettig made a convincing argument that the next two
 ;;; tests are bad, since the caller of allocate-instance
@@ -117,12 +117,14 @@
 
 #|
 (deftest allocate-instance.error.2
-  (classify-error (allocate-instance (find-class 'allocate-instance-class-01)
-				     :b))
-  program-error)
+  (signals-error (allocate-instance (find-class 'allocate-instance-class-01)
+				     :b)
+		 program-error)
+  t)
 
 (deftest allocate-instance.error.3
-  (classify-error (allocate-instance (find-class 'allocate-instance-class-01)
-				     '(a b c) nil))
-  program-error)
+  (signals-error (allocate-instance (find-class 'allocate-instance-class-01)
+				     '(a b c) nil)
+		 program-error)
+  t)
 |#
diff --git a/ansi-tests/and.lsp b/ansi-tests/and.lsp
index 30319b23028ed061727cbb595dc32d0e629ddb69..290007e6d003de33b7245da64905dd9d2df25b9d 100644
--- a/ansi-tests/and.lsp
+++ b/ansi-tests/and.lsp
@@ -56,15 +56,16 @@
   4 4 1 2 3 4)
 
 (deftest and.error.1
-  (classify-error (funcall (macro-function 'and)))
-  program-error)
+  (signals-error (funcall (macro-function 'and))
+		 program-error)
+  t)
 
 (deftest and.error.2
-  (classify-error (funcall (macro-function 'and)
-			   '(and)))
-  program-error)
+  (signals-error (funcall (macro-function 'and) '(and))
+		 program-error)
+  t)
 
 (deftest and.error.3
-  (classify-error (funcall (macro-function 'and)
-			   '(and) nil nil))
-  program-error)
\ No newline at end of file
+  (signals-error (funcall (macro-function 'and) '(and) nil nil)
+		 program-error)
+  t)
diff --git a/ansi-tests/ansi-aux.lsp b/ansi-tests/ansi-aux.lsp
index ef783937c554856aa2e65ccffab3fc80e26ac99a..3af8bc8c5c3ece0e9f0c9b21ab344fc34a23cf4d 100644
--- a/ansi-tests/ansi-aux.lsp
+++ b/ansi-tests/ansi-aux.lsp
@@ -335,6 +335,18 @@ the condition to go uncaught if it cannot be classified."
 (defmacro classify-error (form)
   `(classify-error** ',form))
 
+;;; The above is badly designed, since it fails when some signals
+;;; may be in more than one class/
+
+(defmacro signals-error (form error-name)
+  `(handler-bind
+    ((warning #'(lambda (c) (declare (ignore c))
+			      (muffle-warning))))
+    (proclaim '(optimize (safety 3)))
+    (handler-case
+     (apply #'values nil (multiple-value-list (normally ,form)))
+     (,error-name (c) t))))
+
 ;;;
 ;;; A scaffold is a structure that is used to remember the object
 ;;; identities of the cons cells in a (noncircular) data structure.
diff --git a/ansi-tests/append.lsp b/ansi-tests/append.lsp
index 1d3d82424554910dcd0c80af9ddbe3169a94bd72..f37f72a07865bd7e4b678a8696d2f5e3d6204954 100644
--- a/ansi-tests/append.lsp
+++ b/ansi-tests/append.lsp
@@ -62,9 +62,11 @@
   1 1)
 
 (deftest append.error.1
-  (classify-error (append '(a . b) '(z)))
-  type-error)
+  (signals-error (append '(a . b) '(z))
+		 type-error)
+  t)
 
 (deftest append.error.2
-  (classify-error (append '(x y z) '(a . b) '(z)))
-  type-error)
+  (signals-error (append '(x y z) '(a . b) '(z))
+		 type-error)
+  t)
diff --git a/ansi-tests/apply.lsp b/ansi-tests/apply.lsp
index 56ab0073ba0eff139c236dfccf78d0e8bbe2783c..30b9126281e224bfc88acf6922d177a59ce7a4d3 100644
--- a/ansi-tests/apply.lsp
+++ b/ansi-tests/apply.lsp
@@ -8,20 +8,21 @@
 ;;; Error cases
 
 (deftest apply.error.1
-  (classify-error (apply))
-  program-error)
+  (signals-error (apply) program-error)
+  t)
 
 (deftest apply.error.2
-  (classify-error (apply #'cons))
-  program-error)
+  (signals-error (apply #'cons) program-error)
+  t)
 
 (deftest apply.error.3
-  (classify-error (apply #'cons nil))
-  program-error)
+  (signals-error (apply #'cons nil) program-error)
+  t)
 
 (deftest apply.error.4
-  (classify-error (apply #'cons (list 1 2 3)))
-  program-error)
+  (signals-error (apply #'cons (list 1 2 3))
+		 program-error)
+  t)
 
 ;;; Non-error cases
 
diff --git a/ansi-tests/aref.lsp b/ansi-tests/aref.lsp
index 1b8c0938b2f79348faa148609a84a902084d2ef5..7565b19ea48f0e306c8a0a1b8d329cfd4a2c4507 100644
--- a/ansi-tests/aref.lsp
+++ b/ansi-tests/aref.lsp
@@ -136,9 +136,10 @@
 ;;; To add: aref on displaced arrays, arrays with fill pointers, etc.
 
 (deftest aref.error.1
-  (classify-error (aref))
-  program-error)
+  (signals-error (aref) program-error)
+  t)
 
 (deftest aref.error.2
-  (classify-error (funcall #'aref))
-  program-error)
+  (signals-error (funcall #'aref) program-error)
+  t)
+
diff --git a/ansi-tests/array-dimension.lsp b/ansi-tests/array-dimension.lsp
index f6f4ee0854eb30c6f53f6aba07286093452ea346..256b172ff9fe4b81b1e33b5c64fc6d80b277c423 100644
--- a/ansi-tests/array-dimension.lsp
+++ b/ansi-tests/array-dimension.lsp
@@ -48,16 +48,14 @@
 ;;; Error tests
 
 (deftest array-dimension.error.1
-  (classify-error (array-dimension))
-  program-error)
+  (signals-error (array-dimension) program-error)
+  t)
 
 (deftest array-dimension.error.2
-  (classify-error (array-dimension #(a b c)))
-  program-error)
+  (signals-error (array-dimension #(a b c)) program-error)
+  t)
 
 (deftest array-dimension.error.3
-  (classify-error (array-dimension #(a b c) 0 nil))
-  program-error)
-
-
-
+  (signals-error (array-dimension #(a b c) 0 nil)
+		 program-error)
+  t)
diff --git a/ansi-tests/array-dimensions.lsp b/ansi-tests/array-dimensions.lsp
index 5cdeb558a2735684758863886dadf77017aaacd7..de216def2bd09d2e79f53331e8911d10022a3929 100644
--- a/ansi-tests/array-dimensions.lsp
+++ b/ansi-tests/array-dimensions.lsp
@@ -42,12 +42,13 @@
 ;;; Error tests
 
 (deftest array-dimensions.error.1
-  (classify-error (array-dimensions))
-  program-error)
+  (signals-error (array-dimensions) program-error)
+  t)
 
 (deftest array-dimensions.error.2
-  (classify-error (array-dimensions #(a b c) nil))
-  program-error)
+  (signals-error (array-dimensions #(a b c) nil)
+		 program-error)
+  t)
 
 (deftest array-dimensions.error.3
   (let (why)
@@ -60,10 +61,10 @@
   nil)
 
 (deftest array-dimensions.error.4
-  (classify-error (array-dimensions nil))
-  type-error)
+  (signals-error (array-dimensions nil) type-error)
+  t)
 
 (deftest array-dimensions.error.5
-  (classify-error (locally (array-dimensions nil)))
-  type-error)
-
+  (signals-error (locally (array-dimensions nil))
+		 type-error)
+  t)
diff --git a/ansi-tests/array-displacement.lsp b/ansi-tests/array-displacement.lsp
index f1c34f2fd1cd6ca3f91c5653d79ff70f1f1e2931..780721ba4e78804d94eb7a4e5e9af22725f21de7 100644
--- a/ansi-tests/array-displacement.lsp
+++ b/ansi-tests/array-displacement.lsp
@@ -108,12 +108,12 @@
 ;;; Error tests
 
 (deftest array-displacement.error.1
-  (classify-error (array-displacement))
-  program-error)
+  (signals-error (array-displacement) program-error)
+  t)
 
 (deftest array-displacement.error.2
-  (classify-error (array-displacement #(a b c) nil))
-  program-error)
+  (signals-error (array-displacement #(a b c) nil) program-error)
+  t)
 
 (deftest array-displacement.error.3
   (let (why)
@@ -126,10 +126,12 @@
   nil)
 
 (deftest array-displacement.error.4
-  (classify-error (array-displacement nil))
-  type-error)
+  (signals-error (array-displacement nil) type-error)
+  t)
 
 (deftest array-displacement.error.5
-  (classify-error (let ((x nil)) (array-displacement x)))
-  type-error)
+  (signals-error (let ((x nil)) (array-displacement x))
+		 type-error)
+  t)
+
 
diff --git a/ansi-tests/array-in-bounds-p.lsp b/ansi-tests/array-in-bounds-p.lsp
index 26e9afcea230ecc961e6e7157e1c88e743d01703..b18ff0ec7ac1809a987a3cbc1d08450e80c50bc8 100644
--- a/ansi-tests/array-in-bounds-p.lsp
+++ b/ansi-tests/array-in-bounds-p.lsp
@@ -147,6 +147,5 @@
 ;;; Error tests
 
 (deftest array-in-bounds-p.error.1
-  (classify-error (array-in-bounds-p))
-  program-error)
-
+  (signals-error (array-in-bounds-p) program-error)
+  t)
diff --git a/ansi-tests/array-rank.lsp b/ansi-tests/array-rank.lsp
index b57d67f295afb680af361758b9ad9fbbc7b4d746..1e6d46aaa88b93a326b9152ba996ace52a1a0833 100644
--- a/ansi-tests/array-rank.lsp
+++ b/ansi-tests/array-rank.lsp
@@ -28,12 +28,12 @@
 ;;; Error tests
 
 (deftest array-rank.error.1
-  (classify-error (array-rank))
-  program-error)
+  (signals-error (array-rank) program-error)
+  t)
 
 (deftest array-rank.error.2
-  (classify-error (array-rank #(a b c) nil))
-  program-error)
+  (signals-error (array-rank #(a b c) nil)  program-error)
+  t)
 
 (deftest array-rank.error.3
   (loop for e in *mini-universe*
@@ -44,9 +44,10 @@
   nil)
 
 (deftest array-rank.error.4
-  (classify-error (array-rank nil))
-  type-error)
+  (signals-error (array-rank nil) type-error)
+  t)
 
 (deftest array-rank.error.5
-  (classify-error (locally (array-rank nil) t))
-  type-error)
+  (signals-error (locally (array-rank nil) t)
+		 type-error)
+  t)
diff --git a/ansi-tests/array-row-major-index.lsp b/ansi-tests/array-row-major-index.lsp
index 75f335214638072c18f9fa6718bc9f3b073dca50..418b88eb4ad67ce317426378632376a9314c3ee8 100644
--- a/ansi-tests/array-row-major-index.lsp
+++ b/ansi-tests/array-row-major-index.lsp
@@ -35,5 +35,6 @@
 ;;; Error tests
 
 (deftest array-row-major-index.error.1
-  (classify-error (array-row-major-index))
-  program-error)
+  (signals-error (array-row-major-index) program-error)
+  t)
+
diff --git a/ansi-tests/array-total-size.lsp b/ansi-tests/array-total-size.lsp
index 7f05c2d21a687c13a1526f0ff79750b048b0ae30..211c48daef87a2113c3b20550c91d2d919e6357e 100644
--- a/ansi-tests/array-total-size.lsp
+++ b/ansi-tests/array-total-size.lsp
@@ -37,12 +37,12 @@
 ;;; Error tests
 
 (deftest array-total-size.error.1
-  (classify-error (array-total-size))
-  program-error)
+  (signals-error (array-total-size) program-error)
+  t)
 
 (deftest array-total-size.error.2
-  (classify-error (array-total-size #(a b c) nil))
-  program-error)
+  (signals-error (array-total-size #(a b c) nil) program-error)
+  t)
 
 (deftest array-total-size.error.3
   (let (why)
@@ -55,9 +55,10 @@
   nil)
 
 (deftest array-total-size.error.4
-  (classify-error (array-total-size 0))
-  type-error)
+  (signals-error (array-total-size 0) type-error)
+  t)
 
 (deftest array-total-size.error.5
-  (classify-error (locally (array-total-size 0) t))
-  type-error)
+  (signals-error (locally (array-total-size 0) t)
+		 type-error)
+  t)
diff --git a/ansi-tests/arrayp.lsp b/ansi-tests/arrayp.lsp
index 4f46dd0339bd6fa8abf95955c3bd24d2e9491b0f..eadc342d2d83532363d0c19ae3a40e8bc986d134 100644
--- a/ansi-tests/arrayp.lsp
+++ b/ansi-tests/arrayp.lsp
@@ -46,12 +46,9 @@
 ;;; Error tests
 
 (deftest arrayp.error.1
-  (classify-error (arrayp))
-  program-error)
+  (signals-error (arrayp) program-error)
+  t)
 
 (deftest arrayp.error.2
-  (classify-error (arrayp #(a b c) nil))
-  program-error)
-
-
-
+  (signals-error (arrayp #(a b c) nil) program-error)
+  t)
diff --git a/ansi-tests/ash.lsp b/ansi-tests/ash.lsp
index a82904f6e9836fcd6264d03a6c1c8e0151c8a74c..170716402c6329380a41458db3de2b1b9787e848 100644
--- a/ansi-tests/ash.lsp
+++ b/ansi-tests/ash.lsp
@@ -5,32 +5,36 @@
 
 (in-package :cl-test)
 
+;;; Error tests
+
 (deftest ash.error.1
-  (classify-error (ash))
-  program-error)
+  (signals-error (ash) program-error)
+  t)
 
 (deftest ash.error.2
-  (classify-error (ash 1 1 1))
-  program-error)
+  (signals-error (ash 1 1 1) program-error)
+  t)
 
 (deftest ash.error.3
-  (classify-error (ash 1 1 nil))
-  program-error)
+  (signals-error (ash 1 1 nil) program-error)
+  t)
 
 (deftest ash.error.4
   (loop for x in *mini-universe*
 	unless (or (integerp x)
-		   (eq (eval `(classify-error (ash ',x 0))) 'type-error))
+		   (eval `(signals-error (ash ',x 0) type-error)))
 	collect x)
   nil)
 
 (deftest ash.error.5
   (loop for x in *mini-universe*
 	unless (or (integerp x)
-		   (eq (eval `(classify-error (ash 0 ',x))) 'type-error))
+		   (eval `(signals-error (ash 0 ',x) type-error)))
 	collect x)
   nil)
 
+;;; Non-error tests
+
 (deftest ash.1
   (loop for x in *integers*
 	always (eql (ash x 0) x))
diff --git a/ansi-tests/assoc-if-not.lsp b/ansi-tests/assoc-if-not.lsp
index 061157f8c316c165f22eb7d46b3c9df79d7c59d3..239a35d218d1d0239a5d9a24ea36a0440d4db9e9 100644
--- a/ansi-tests/assoc-if-not.lsp
+++ b/ansi-tests/assoc-if-not.lsp
@@ -97,53 +97,63 @@
 ;;; Error tests
 
 (deftest assoc-if-not.error.1
-  (classify-error (assoc-if-not))
-  program-error)
+  (signals-error (assoc-if-not) program-error)
+  t)
 
 (deftest assoc-if-not.error.2
-  (classify-error (assoc-if-not #'null))
-  program-error)
+  (signals-error (assoc-if-not #'null) program-error)
+  t)
 
 (deftest assoc-if-not.error.3
-  (classify-error (assoc-if-not #'null nil :bad t))
-  program-error)
+  (signals-error (assoc-if-not #'null nil :bad t)
+		 program-error)
+  t)
 
 (deftest assoc-if-not.error.4
-  (classify-error (assoc-if-not #'null nil :key))
-  program-error)
+  (signals-error (assoc-if-not #'null nil :key)
+		 program-error)
+  t)
 
 (deftest assoc-if-not.error.5
-  (classify-error (assoc-if-not #'null nil 1 1))
-  program-error)
+  (signals-error (assoc-if-not #'null nil 1 1)
+		 program-error)
+  t)
 
 (deftest assoc-if-not.error.6
-  (classify-error (assoc-if-not #'null nil :bad t :allow-other-keys nil))
-  program-error)
+  (signals-error (assoc-if-not #'null nil :bad t :allow-other-keys nil)
+		 program-error)
+  t)
 
 (deftest assoc-if-not.error.7
-  (classify-error (assoc-if-not #'cons '((a b)(c d))))
-  program-error)
+  (signals-error (assoc-if-not #'cons '((a b)(c d)))
+		 program-error)
+  t)
 
 (deftest assoc-if-not.error.8
-  (classify-error (assoc-if-not #'identity '((a b)(c d)) :key #'cons))
-  program-error)
+  (signals-error (assoc-if-not #'identity '((a b)(c d)) :key #'cons)
+		 program-error)
+  t)
 
 (deftest assoc-if-not.error.9
-  (classify-error (assoc-if-not #'car '((a b)(c d))))
-  type-error)
+  (signals-error (assoc-if-not #'car '((a b)(c d)))
+		 type-error)
+  t)
 
 (deftest assoc-if-not.error.10
-  (classify-error (assoc-if-not #'identity '((a b)(c d)) :key #'car))
-  type-error)
+  (signals-error (assoc-if-not #'identity '((a b)(c d)) :key #'car)
+		 type-error)
+  t)
 
 (deftest assoc-if-not.error.11
-  (classify-error (assoc-if-not #'identity '((a . b) . c)))
-  type-error)
+  (signals-error (assoc-if-not #'identity '((a . b) . c))
+		 type-error)
+  t)
 
 (deftest assoc-if-not.error.12
-  (classify-error (assoc-if-not #'identity '((a . b) :bad (c . d))))
-  type-error)
+  (signals-error (assoc-if-not #'identity '((a . b) :bad (c . d)))
+		 type-error)
+  t)
 
 (deftest assoc-if-not.error.13
-  (classify-error (assoc-if-not #'identity 'y))
-  type-error)
+  (signals-error (assoc-if-not #'identity 'y) type-error)
+  t)
diff --git a/ansi-tests/assoc-if.lsp b/ansi-tests/assoc-if.lsp
index ea790fdcb352b318637838280db5cc4d3a11a653..347f1c25441079caf8b86214ba885f5b8de4551b 100644
--- a/ansi-tests/assoc-if.lsp
+++ b/ansi-tests/assoc-if.lsp
@@ -101,53 +101,63 @@
 ;;; Error cases
 
 (deftest assoc-if.error.1
-  (classify-error (assoc-if))
-  program-error)
+  (signals-error (assoc-if) program-error)
+  t)
 
 (deftest assoc-if.error.2
-  (classify-error (assoc-if #'null))
-  program-error)
+  (signals-error (assoc-if #'null) program-error)
+  t)
 
 (deftest assoc-if.error.3
-  (classify-error (assoc-if #'null nil :bad t))
-  program-error)
+  (signals-error (assoc-if #'null nil :bad t)
+		 program-error)
+  t)
 
 (deftest assoc-if.error.4
-  (classify-error (assoc-if #'null nil :key))
-  program-error)
+  (signals-error (assoc-if #'null nil :key)
+		 program-error)
+  t)
 
 (deftest assoc-if.error.5
-  (classify-error (assoc-if #'null nil 1 1))
-  program-error)
+  (signals-error (assoc-if #'null nil 1 1)
+		 program-error)
+  t)
 
 (deftest assoc-if.error.6
-  (classify-error (assoc-if #'null nil :bad t :allow-other-keys nil))
-  program-error)
+  (signals-error (assoc-if #'null nil :bad t :allow-other-keys nil)
+		 program-error)
+  t)
 
 (deftest assoc-if.error.7
-  (classify-error (assoc-if #'cons '((a b)(c d))))
-  program-error)
+  (signals-error (assoc-if #'cons '((a b)(c d)))
+		 program-error)
+  t)
 
 (deftest assoc-if.error.8
-  (classify-error (assoc-if #'identity '((a b)(c d)) :key #'cons))
-  program-error)
+  (signals-error (assoc-if #'identity '((a b)(c d)) :key #'cons)
+		 program-error)
+  t)
 
 (deftest assoc-if.error.9
-  (classify-error (assoc-if #'car '((a b)(c d))))
-  type-error)
+  (signals-error (assoc-if #'car '((a b)(c d)))
+		 type-error)
+  t)
 
 (deftest assoc-if.error.10
-  (classify-error (assoc-if #'identity '((a b)(c d)) :key #'car))
-  type-error)
+  (signals-error (assoc-if #'identity '((a b)(c d)) :key #'car)
+		 type-error)
+  t)
 
 (deftest assoc-if.error.11
-  (classify-error (assoc-if #'null '((a . b) . c)))
-  type-error)
+  (signals-error (assoc-if #'null '((a . b) . c))
+		 type-error)
+  t)
 
 (deftest assoc-if.error.12
-  (classify-error (assoc-if #'null '((a . b) :bad (c . d))))
-  type-error)
+  (signals-error (assoc-if #'null '((a . b) :bad (c . d)))
+		 type-error)
+  t)
 
 (deftest assoc-if.error.13
-  (classify-error (assoc-if #'null 'y))
-  type-error)
+  (signals-error (assoc-if #'null 'y) type-error)
+  t)
diff --git a/ansi-tests/assoc.lsp b/ansi-tests/assoc.lsp
index b5632e7723a35f978c83c1aa84ba74ab20c1de54..37f32609294d921b537ba4dd75c58494c4f2ad0f 100644
--- a/ansi-tests/assoc.lsp
+++ b/ansi-tests/assoc.lsp
@@ -240,49 +240,56 @@
 
 
 (deftest assoc.error.1
-  (classify-error (assoc))
-  program-error)
+  (signals-error (assoc) program-error)
+  t)
 
 (deftest assoc.error.2
-  (classify-error (assoc nil))
-  program-error)
+  (signals-error (assoc nil) program-error)
+  t)
 
 (deftest assoc.error.3
-  (classify-error (assoc nil nil :bad t))
-  program-error)
+  (signals-error (assoc nil nil :bad t) program-error)
+  t)
 
 (deftest assoc.error.4
-  (classify-error (assoc nil nil :key))
-  program-error)
+  (signals-error (assoc nil nil :key) program-error)
+  t)
 
 (deftest assoc.error.5
-  (classify-error (assoc nil nil  1 1))
-  program-error)
+  (signals-error (assoc nil nil 1 1) program-error)
+  t)
 
 (deftest assoc.error.6
-  (classify-error (assoc nil nil :bad t :allow-other-keys nil))
-  program-error)
+  (signals-error (assoc nil nil :bad t :allow-other-keys nil)
+		 program-error)
+  t)
 
 (deftest assoc.error.7
-  (classify-error (assoc 'a '((a . b)) :test #'identity))
-  program-error)
+  (signals-error (assoc 'a '((a . b)) :test #'identity)
+		 program-error)
+  t)
 
 (deftest assoc.error.8
-  (classify-error (assoc 'a '((a . b)) :test-not #'identity))
-  program-error)
+  (signals-error (assoc 'a '((a . b)) :test-not #'identity)
+		 program-error)
+  t)
 
 (deftest assoc.error.9
-  (classify-error (assoc 'a '((a . b)) :key #'cons))
-  program-error)
+  (signals-error (assoc 'a '((a . b)) :key #'cons)
+		 program-error)
+  t)
 
 (deftest assoc.error.10
-  (classify-error (assoc 'z '((a . b) . c)))
-  type-error)
+  (signals-error (assoc 'z '((a . b) . c))
+		 type-error)
+  t)
 
 (deftest assoc.error.11
-  (classify-error (assoc 'z '((a . b) :bad (c . d))))
-  type-error)
+  (signals-error (assoc 'z '((a . b) :bad (c . d)))
+		 type-error)
+  t)
 
 (deftest assoc.error.12
-  (classify-error (assoc 'x 'y))
-  type-error)
+  (signals-error (assoc 'x 'y) type-error)
+  t)
+
diff --git a/ansi-tests/atom.lsp b/ansi-tests/atom.lsp
index 574525e726b7f99e001fe91b6c84902a43f0d1bd..9b4af9e1869ec1b83ed90551c5f82cbd5894dfb8 100644
--- a/ansi-tests/atom.lsp
+++ b/ansi-tests/atom.lsp
@@ -11,9 +11,9 @@
   nil 1)
 
 (deftest atom.error.1
-  (classify-error (atom))
-  program-error)
+  (signals-error (atom) program-error)
+  t)
 
 (deftest atom.error.2
-  (classify-error (atom 'a 'b))
-  program-error)
+  (signals-error (atom 'a 'b) program-error)
+  t)
diff --git a/ansi-tests/bit-and.lsp b/ansi-tests/bit-and.lsp
index 0b62bb383d92838a3c4f9cac126b16545d1d00a0..ef1e91c4cdf3a5f4281a49a945fa83c8def95cc2 100644
--- a/ansi-tests/bit-and.lsp
+++ b/ansi-tests/bit-and.lsp
@@ -231,13 +231,15 @@
 ;;; Error tests
 
 (deftest bit-and.error.1
-  (classify-error (bit-and))
-  program-error)
+  (signals-error (bit-and) program-error)
+  t)
 
 (deftest bit-and.error.2
-  (classify-error (bit-and #*000))
-  program-error)
+  (signals-error (bit-and #*000) program-error)
+  t)
 
 (deftest bit-and.error.3
-  (classify-error (bit-and #*000 #*0100 nil nil))
-  program-error)
+  (signals-error (bit-and #*000 #*0100 nil nil)
+		 program-error)
+  t)
+
diff --git a/ansi-tests/bit-andc1.lsp b/ansi-tests/bit-andc1.lsp
index 5597ad16d620af969ca53538eb4144ee80007bdd..67f72b38c8d9c1b103536300ce3d8e57bb43cb90 100644
--- a/ansi-tests/bit-andc1.lsp
+++ b/ansi-tests/bit-andc1.lsp
@@ -231,13 +231,14 @@
 ;;; Error tests
 
 (deftest bit-andc1.error.1
-  (classify-error (bit-andc1))
-  program-error)
+  (signals-error (bit-andc1) program-error)
+  t)
 
 (deftest bit-andc1.error.2
-  (classify-error (bit-andc1 #*000))
-  program-error)
+  (signals-error (bit-andc1 #*000) program-error)
+  t)
 
 (deftest bit-andc1.error.3
-  (classify-error (bit-andc1 #*000 #*0100 nil nil))
-  program-error)
+  (signals-error (bit-andc1 #*000 #*0100 nil nil)
+		 program-error)
+  t)
diff --git a/ansi-tests/bit-andc2.lsp b/ansi-tests/bit-andc2.lsp
index b61cbf7d14258e957f3e09a1470d58cb38c2cfa0..54b57f795242bc1821e34786005d2178d72e6f03 100644
--- a/ansi-tests/bit-andc2.lsp
+++ b/ansi-tests/bit-andc2.lsp
@@ -231,14 +231,15 @@
 ;;; Error tests
 
 (deftest bit-andc2.error.1
-  (classify-error (bit-andc2))
-  program-error)
+  (signals-error (bit-andc2) program-error)
+  t)
 
 (deftest bit-andc2.error.2
-  (classify-error (bit-andc2 #*000))
-  program-error)
+  (signals-error (bit-andc2 #*000) program-error)
+  t)
 
 (deftest bit-andc2.error.3
-  (classify-error (bit-andc2 #*000 #*0100 nil nil))
-  program-error)
+  (signals-error (bit-andc2 #*000 #*0100 nil nil)
+		 program-error)
+  t)
 
diff --git a/ansi-tests/bit-eqv.lsp b/ansi-tests/bit-eqv.lsp
index 6593d97dd9552e5a6efd803cde93b212260b9454..b44847b7f0b2e5a006ff443143ee709a9b2d2d2a 100644
--- a/ansi-tests/bit-eqv.lsp
+++ b/ansi-tests/bit-eqv.lsp
@@ -232,14 +232,14 @@
 ;;; Error tests
 
 (deftest bit-eqv.error.1
-  (classify-error (bit-eqv))
-  program-error)
+  (signals-error (bit-eqv) program-error)
+  t)
 
 (deftest bit-eqv.error.2
-  (classify-error (bit-eqv #*000))
-  program-error)
+  (signals-error (bit-eqv #*000) program-error)
+  t)
 
 (deftest bit-eqv.error.3
-  (classify-error (bit-eqv #*000 #*0100 nil nil))
-  program-error)
-
+  (signals-error (bit-eqv #*000 #*0100 nil nil)
+		 program-error)
+  t)
diff --git a/ansi-tests/bit-ior.lsp b/ansi-tests/bit-ior.lsp
index 469c778069761c9f12714f679a506dc23dd08b5b..87401cc0e8873f75ea24c40cd62fcc56141a5316 100644
--- a/ansi-tests/bit-ior.lsp
+++ b/ansi-tests/bit-ior.lsp
@@ -231,14 +231,14 @@
 ;;; Error tests
 
 (deftest bit-ior.error.1
-  (classify-error (bit-ior))
-  program-error)
+  (signals-error (bit-ior) program-error)
+  t)
 
 (deftest bit-ior.error.2
-  (classify-error (bit-ior #*000))
-  program-error)
+  (signals-error (bit-ior #*000) program-error)
+  t)
 
 (deftest bit-ior.error.3
-  (classify-error (bit-ior #*000 #*0100 nil nil))
-  program-error)
-
+  (signals-error (bit-ior #*000 #*0100 nil nil)
+		 program-error)
+  t)
diff --git a/ansi-tests/bit-nand.lsp b/ansi-tests/bit-nand.lsp
index 840e686743576b7e5574041f2ca17ebcf2e3d9ad..07e6c071a81a5d7804fa9499b9ef130bd9e698f3 100644
--- a/ansi-tests/bit-nand.lsp
+++ b/ansi-tests/bit-nand.lsp
@@ -231,14 +231,14 @@
 ;;; Error tests
 
 (deftest bit-nand.error.1
-  (classify-error (bit-nand))
-  program-error)
+  (signals-error (bit-nand) program-error)
+  t)
 
 (deftest bit-nand.error.2
-  (classify-error (bit-nand #*000))
-  program-error)
+  (signals-error (bit-nand #*000) program-error)
+  t)
 
 (deftest bit-nand.error.3
-  (classify-error (bit-nand #*000 #*0100 nil nil))
-  program-error)
-
+  (signals-error (bit-nand #*000 #*0100 nil nil)
+		 program-error)
+  t)
diff --git a/ansi-tests/bit-nor.lsp b/ansi-tests/bit-nor.lsp
index 36031ef39f29cfd8ecb83d4ede296759911e78e0..0064fd8332edba32a7f8d088764fb6d4ef849d29 100644
--- a/ansi-tests/bit-nor.lsp
+++ b/ansi-tests/bit-nor.lsp
@@ -231,14 +231,14 @@
 ;;; Error tests
 
 (deftest bit-nor.error.1
-  (classify-error (bit-nor))
-  program-error)
+  (signals-error (bit-nor) program-error)
+  t)
 
 (deftest bit-nor.error.2
-  (classify-error (bit-nor #*000))
-  program-error)
+  (signals-error (bit-nor #*000) program-error)
+  t)
 
 (deftest bit-nor.error.3
-  (classify-error (bit-nor #*000 #*0100 nil nil))
-  program-error)
-
+  (signals-error (bit-nor #*000 #*0100 nil nil)
+		 program-error)
+  t)
diff --git a/ansi-tests/bit-not.lsp b/ansi-tests/bit-not.lsp
index 550dce3abbd7aa3dd9499df26e55cbe622a9ac7f..44c9832a21fc482cba01cca68138e2988090232b 100644
--- a/ansi-tests/bit-not.lsp
+++ b/ansi-tests/bit-not.lsp
@@ -130,10 +130,9 @@
 ;;; Error tests
 
 (deftest bit-not.error.1
-  (classify-error (bit-not))
-  program-error)
+  (signals-error (bit-not) program-error)
+  t)
 
 (deftest bit-not.error.2
-  (classify-error (bit-not #*000 nil nil))
-  program-error)
-
+  (signals-error (bit-not #*000 nil nil) program-error)
+  t)
diff --git a/ansi-tests/bit-orc1.lsp b/ansi-tests/bit-orc1.lsp
index 96467f90db864b3116081e109289084d07f43f62..33b651ad10c7a573c97ee1034f3fa33ffcb50736 100644
--- a/ansi-tests/bit-orc1.lsp
+++ b/ansi-tests/bit-orc1.lsp
@@ -231,14 +231,16 @@
 ;;; Error tests
 
 (deftest bit-orc1.error.1
-  (classify-error (bit-orc1))
-  program-error)
+  (signals-error (bit-orc1) program-error)
+  t)
 
 (deftest bit-orc1.error.2
-  (classify-error (bit-orc1 #*000))
-  program-error)
+  (signals-error (bit-orc1 #*000) program-error)
+  t)
 
 (deftest bit-orc1.error.3
-  (classify-error (bit-orc1 #*000 #*0100 nil nil))
-  program-error)
+  (signals-error (bit-orc1 #*000 #*0100 nil nil)
+		 program-error)
+  t)
+
 
diff --git a/ansi-tests/bit-orc2.lsp b/ansi-tests/bit-orc2.lsp
index 1f7af7244c55c49c9a2978194c0a1c9be7dcc7fc..cbd172eb81661c51539268c002313ca3c5c9c84f 100644
--- a/ansi-tests/bit-orc2.lsp
+++ b/ansi-tests/bit-orc2.lsp
@@ -231,15 +231,16 @@
 ;;; Error tests
 
 (deftest bit-orc2.error.1
-  (classify-error (bit-orc2))
-  program-error)
+  (signals-error (bit-orc2) program-error)
+  t)
 
 (deftest bit-orc2.error.2
-  (classify-error (bit-orc2 #*000))
-  program-error)
+  (signals-error (bit-orc2 #*000) program-error)
+  t)
 
 (deftest bit-orc2.error.3
-  (classify-error (bit-orc2 #*000 #*0100 nil nil))
-  program-error)
+  (signals-error (bit-orc2 #*000 #*0100 nil nil)
+		 program-error)
+  t)
 
 
diff --git a/ansi-tests/bit-vector-p.lsp b/ansi-tests/bit-vector-p.lsp
index 93ebbd221b85b5063fcfcdd12d560fcd756f0c98..0100befe9b2813bbe34d9cf3c9b99ed45b2940ef 100644
--- a/ansi-tests/bit-vector-p.lsp
+++ b/ansi-tests/bit-vector-p.lsp
@@ -68,12 +68,10 @@
   nil 1 1)
 
 
-    
-
 (deftest bit-vector-p.error.1
-  (classify-error (bit-vector-p))
-  program-error)
+  (signals-error (bit-vector-p) program-error)
+  t)
 
 (deftest bit-vector-p.error.2
-  (classify-error (bit-vector-p #* #*))
-  program-error)
+  (signals-error (bit-vector-p #* #*) program-error)
+  t)
diff --git a/ansi-tests/bit-xor.lsp b/ansi-tests/bit-xor.lsp
index a2b58dd58e40e7fc1e1d79bc48ed8d4cab32202e..4e7955e7b22a733d9599906c173308944da1f04c 100644
--- a/ansi-tests/bit-xor.lsp
+++ b/ansi-tests/bit-xor.lsp
@@ -231,14 +231,14 @@
 ;;; Error tests
 
 (deftest bit-xor.error.1
-  (classify-error (bit-xor))
-  program-error)
+  (signals-error (bit-xor) program-error)
+  t)
 
 (deftest bit-xor.error.2
-  (classify-error (bit-xor #*000))
-  program-error)
+  (signals-error (bit-xor #*000) program-error)
+  t)
 
 (deftest bit-xor.error.3
-  (classify-error (bit-xor #*000 #*0100 nil nil))
-  program-error)
-
+  (signals-error (bit-xor #*000 #*0100 nil nil)
+		 program-error)
+  t)
diff --git a/ansi-tests/bit.lsp b/ansi-tests/bit.lsp
index 70b807c3d23e35037d4d3cde0df1b045daf838cf..4b2de4093457eb4aff307b0077330bfae9b89918 100644
--- a/ansi-tests/bit.lsp
+++ b/ansi-tests/bit.lsp
@@ -132,5 +132,5 @@
   0 #*00010 3 1 2 3)
 
 (deftest bit.error.1
-  (classify-error (bit))
-  program-error)
+  (signals-error (bit) program-error)
+  t)
diff --git a/ansi-tests/block.lsp b/ansi-tests/block.lsp
index 84321ffb7468f052880390ae282d62aa1fb8223d..2f61a3457eef34492e37c6a494566d05d0c64490 100644
--- a/ansi-tests/block.lsp
+++ b/ansi-tests/block.lsp
@@ -78,8 +78,9 @@
 
 #|
 (deftest return.error.1
-  (classify-error
+  (signals-error
    (block nil
-     (return 'a 'b)))
-  program-error)
+     (return 'a 'b))
+   program-error)
+  t)
 |#
diff --git a/ansi-tests/boole.lsp b/ansi-tests/boole.lsp
index 90fd5821e58e5f293f798ec9495612ea04e7b0ad..14fa005a9dcb1c3a52e222fed2efb62956820dd0 100644
--- a/ansi-tests/boole.lsp
+++ b/ansi-tests/boole.lsp
@@ -36,35 +36,35 @@
 	#'logxor))
 
 (deftest boole.error.1
-  (classify-error (boole))
-  program-error)
+  (signals-error (boole) program-error)
+  t)
 
 (deftest boole.error.2
-  (classify-error (boole boole-1))
-  program-error)
+  (signals-error (boole boole-1) program-error)
+  t)
 
 (deftest boole.error.3
-  (classify-error (boole boole-1 1))
-  program-error)
+  (signals-error (boole boole-1 1) program-error)
+  t)
 
 (deftest boole.error.4
-  (classify-error (boole boole-1 1 2 nil))
-  program-error)
+  (signals-error (boole boole-1 1 2 nil) program-error)
+  t)
 
 (deftest boole.error.5
   (let ((bad (loop for i from 1 until (not (member i *boole-vals*)))))
-    (eval `(classify-error (boole ,bad 1 1))))
-  type-error)
+    (eval `(signals-error (boole ,bad 1 1) type-error)))
+  t)
 
 (deftest boole.error.6
   (loop for n in *boole-val-names*
-	unless (eq (eval `(classify-error (boole ,n nil 1))) 'type-error)
+	unless (eval `(signals-error (boole ,n nil 1) type-error))
 	collect n)
   nil)
 
 (deftest boole.error.7
   (loop for n in *boole-val-names*
-	unless (eq (eval `(classify-error (boole ,n 1 nil))) 'type-error)
+	unless (eval `(signals-error (boole ,n 1 nil) type-error))
 	collect n)
   nil)
 
diff --git a/ansi-tests/boundp.lsp b/ansi-tests/boundp.lsp
index ee512be7155625f3d581b6340a25deb480529d28..1f25b183a14febeae53cac31280c3c60f28add8f 100644
--- a/ansi-tests/boundp.lsp
+++ b/ansi-tests/boundp.lsp
@@ -6,28 +6,28 @@
 (in-package :cl-test)
 
 (deftest boundp.error.1
-  (classify-error (boundp))
-  program-error)
+  (signals-error (boundp) program-error)
+  t)
 
 (deftest boundp.error.2
-  (classify-error (boundp 'a 'a))
-  program-error)
+  (signals-error (boundp 'a 'a) program-error)
+  t)
 
 (deftest boundp.error.3
-  (classify-error (boundp 1))
-  type-error)
+  (signals-error (boundp 1) type-error)
+  t)
 
 (deftest boundp.error.4
-  (classify-error (boundp '(setf car)))
-  type-error)
+  (signals-error (boundp '(setf car)) type-error)
+  t)
 
 (deftest boundp.error.5
-  (classify-error (boundp "abc"))
-  type-error)
+  (signals-error (boundp "abc") type-error)
+  t)
 
 (deftest boundp.error.6
-  (classify-error (locally (boundp "abc") t))
-  type-error)
+  (signals-error (locally (boundp "abc") t) type-error)
+  t)
 
 ;;; See other tests in cl-symbols.lsp
 
diff --git a/ansi-tests/butlast.lsp b/ansi-tests/butlast.lsp
index 03805dd668bcd34b1f7ad6fe8c52ec0d4db5b9ca..5a531e11912247d1110735e73f3864081821b0b0 100644
--- a/ansi-tests/butlast.lsp
+++ b/ansi-tests/butlast.lsp
@@ -75,22 +75,24 @@
   (a b c) 1)
 
 (deftest butlast.error.1
-  (classify-error (butlast (copy-tree '(a b c d)) 'a))
-  type-error)
+  (signals-error (butlast (copy-tree '(a b c d)) 'a)
+		 type-error)
+  t)
 
 (deftest butlast.error.2
-  (classify-error (butlast 'a 0))
-  type-error)
+  (signals-error (butlast 'a 0) type-error)
+  t)
 
 (deftest butlast.error.3
-  (classify-error (butlast))
-  program-error)
+  (signals-error (butlast) program-error)
+  t)
 
 (deftest butlast.error.4
-  (classify-error (butlast '(a b c) 3 3))
-  program-error)
+  (signals-error (butlast '(a b c) 3 3) program-error)
+  t)
 
 (deftest butlast.error.5
-  (classify-error (locally (butlast 'a 0) t))
-  type-error)
+  (signals-error (locally (butlast 'a 0) t) type-error)
+  t)
+
 
diff --git a/ansi-tests/byte.lsp b/ansi-tests/byte.lsp
index f4c8351f43c2421d0bb1b5ab0d380a9d1399fc01..e005bd40c371281b0e261ec7b1e0beada3ef7252 100644
--- a/ansi-tests/byte.lsp
+++ b/ansi-tests/byte.lsp
@@ -6,16 +6,16 @@
 (in-package :cl-test)
 
 (deftest byte.error.1
-  (classify-error (byte))
-  program-error)
+  (signals-error (byte) program-error)
+  t)
 
 (deftest byte.error.2
-  (classify-error (byte 1))
-  program-error)
+  (signals-error (byte 1) program-error)
+  t)
 
 (deftest byte.error.3
-  (classify-error (byte 1 1 nil))
-  program-error)
+  (signals-error (byte 1 1 nil) program-error)
+  t)
 
 (deftest byte.1
   (progn (byte 0 0) :good)
@@ -36,17 +36,18 @@
   t)
 
 (deftest byte-position.error.1
-  (classify-error (byte-position))
-  program-error)
+  (signals-error (byte-position) program-error)
+  t)
 
 (deftest byte-position.error.2
-  (classify-error (byte-position (byte 1 1) nil))
-  program-error)
+  (signals-error (byte-position (byte 1 1) nil)
+		 program-error)
+  t)
 
 (deftest byte-size.error.1
-  (classify-error (byte-size))
-  program-error)
+  (signals-error (byte-size) program-error)
+  t)
 
 (deftest byte-size.error.2
-  (classify-error (byte-size (byte 1 1) nil))
-  program-error)
+  (signals-error (byte-size (byte 1 1) nil) program-error)
+  t)