From ad0560cf983ae5622d8af6e55c258023086e24bc Mon Sep 17 00:00:00 2001
From: pfdietz <pfdietz@localhost>
Date: Fri, 16 Jan 2004 14:44:05 +0000
Subject: [PATCH] Begin updating error tests to use SIGNALS-ERROR instead of
 CLASSIFY-ERROR.  The latter made unwarranted assumptions about error
 conditions not being in mutiple standardized condition classes.

---
 ansi-tests/abort.lsp                 |  7 ++--
 ansi-tests/abs.lsp                   | 12 +++---
 ansi-tests/acons.lsp                 | 16 +++----
 ansi-tests/add-method.lsp            | 15 +++----
 ansi-tests/adjoin.lsp                | 41 +++++++++---------
 ansi-tests/adjustable-array-p.lsp    | 23 ++++++-----
 ansi-tests/allocate-instance.lsp     | 18 ++++----
 ansi-tests/and.lsp                   | 17 ++++----
 ansi-tests/ansi-aux.lsp              | 12 ++++++
 ansi-tests/append.lsp                | 10 +++--
 ansi-tests/apply.lsp                 | 17 ++++----
 ansi-tests/aref.lsp                  |  9 ++--
 ansi-tests/array-dimension.lsp       | 16 ++++---
 ansi-tests/array-dimensions.lsp      | 19 +++++----
 ansi-tests/array-displacement.lsp    | 18 ++++----
 ansi-tests/array-in-bounds-p.lsp     |  5 +--
 ansi-tests/array-rank.lsp            | 17 ++++----
 ansi-tests/array-row-major-index.lsp |  5 ++-
 ansi-tests/array-total-size.lsp      | 17 ++++----
 ansi-tests/arrayp.lsp                | 11 ++---
 ansi-tests/ash.lsp                   | 20 +++++----
 ansi-tests/assoc-if-not.lsp          | 62 ++++++++++++++++------------
 ansi-tests/assoc-if.lsp              | 62 ++++++++++++++++------------
 ansi-tests/assoc.lsp                 | 55 +++++++++++++-----------
 ansi-tests/atom.lsp                  |  8 ++--
 ansi-tests/bit-and.lsp               | 14 ++++---
 ansi-tests/bit-andc1.lsp             | 13 +++---
 ansi-tests/bit-andc2.lsp             | 13 +++---
 ansi-tests/bit-eqv.lsp               | 14 +++----
 ansi-tests/bit-ior.lsp               | 14 +++----
 ansi-tests/bit-nand.lsp              | 14 +++----
 ansi-tests/bit-nor.lsp               | 14 +++----
 ansi-tests/bit-not.lsp               |  9 ++--
 ansi-tests/bit-orc1.lsp              | 14 ++++---
 ansi-tests/bit-orc2.lsp              | 13 +++---
 ansi-tests/bit-vector-p.lsp          | 10 ++---
 ansi-tests/bit-xor.lsp               | 14 +++----
 ansi-tests/bit.lsp                   |  4 +-
 ansi-tests/block.lsp                 |  7 ++--
 ansi-tests/boole.lsp                 | 24 +++++------
 ansi-tests/boundp.lsp                | 24 +++++------
 ansi-tests/butlast.lsp               | 22 +++++-----
 ansi-tests/byte.lsp                  | 29 ++++++-------
 43 files changed, 419 insertions(+), 359 deletions(-)

diff --git a/ansi-tests/abort.lsp b/ansi-tests/abort.lsp
index df4f3ddc..0c65eedc 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 33cdc901..2b8280a9 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 94558d3d..cc193d4c 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 f33754da..491d38b9 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 943c100b..669881f4 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 6a392188..76461067 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 830bec3c..42c6322c 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 30319b23..290007e6 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 ef783937..3af8bc8c 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 1d3d8242..f37f72a0 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 56ab0073..30b91262 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 1b8c0938..7565b19e 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 f6f4ee08..256b172f 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 5cdeb558..de216def 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 f1c34f2f..780721ba 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 26e9afce..b18ff0ec 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 b57d67f2..1e6d46aa 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 75f33521..418b88eb 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 7f05c2d2..211c48da 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 4f46dd03..eadc342d 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 a82904f6..17071640 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 061157f8..239a35d2 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 ea790fdc..347f1c25 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 b5632e77..37f32609 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 574525e7..9b4af9e1 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 0b62bb38..ef1e91c4 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 5597ad16..67f72b38 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 b61cbf7d..54b57f79 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 6593d97d..b44847b7 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 469c7780..87401cc0 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 840e6867..07e6c071 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 36031ef3..0064fd83 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 550dce3a..44c9832a 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 96467f90..33b651ad 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 1f7af724..cbd172eb 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 93ebbd22..0100befe 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 a2b58dd5..4e7955e7 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 70b807c3..4b2de409 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 84321ffb..2f61a345 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 90fd5821..14fa005a 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 ee512be7..1f25b183 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 03805dd6..5a531e11 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 f4c8351f..e005bd40 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)
-- 
GitLab