diff --git a/ansi-tests/reduce.lsp b/ansi-tests/reduce.lsp
index 0968fe4340d4a0c27236fc5ccbb1a6dccd7e880f..8f15549b094c5d9bd3f8a1e9a71803a18ed25dfe 100644
--- a/ansi-tests/reduce.lsp
+++ b/ansi-tests/reduce.lsp
@@ -223,8 +223,8 @@
 ;;;;;;;;
 
 (deftest reduce.error.1
-  (signals-error (reduce 'cons 'a) type-error)
-  t)
+  (check-type-error #'(lambda (x) (reduce 'cons x)) #'sequencep)
+  nil)
 
 (deftest reduce.error.2
   (signals-error (reduce) program-error)
diff --git a/ansi-tests/remove-duplicates.lsp b/ansi-tests/remove-duplicates.lsp
index 50a7aaf2b12f127a6cf4fe4f254559eeb4519e7c..58dc556ec558719b4149e8cd09c881160e431d31 100644
--- a/ansi-tests/remove-duplicates.lsp
+++ b/ansi-tests/remove-duplicates.lsp
@@ -237,6 +237,10 @@
   (signals-error (remove-duplicates (list 'a 'b 'c) :key #'car) type-error)
   t)
 
+(deftest remove-duplicates.error.9
+  (check-type-error #'remove-duplicates #'sequencep)
+  nil)
+
 ;;;
 
 (deftest delete-duplicates.error.1
@@ -275,6 +279,10 @@
   (signals-error (delete-duplicates (list 'a 'b 'c) :key #'car) type-error)
   t)
 
+(deftest delete-duplicates.error.10
+  (check-type-error #'delete-duplicates #'sequencep)
+  nil)
+
 ;;; Specialized string tests
 
 (deftest remove-duplicates.string.1
diff --git a/ansi-tests/remove.lsp b/ansi-tests/remove.lsp
index ec11fbebe41f7e9fc9c138a923fb4716c81a5817..db015a4966d929a0187cd3a5d940ae4fc4f09412 100644
--- a/ansi-tests/remove.lsp
+++ b/ansi-tests/remove.lsp
@@ -861,6 +861,10 @@
   (signals-error (remove 'a (list 'a 'b 'c) :key #'car) type-error)
   t)
 
+(deftest remove.error.11
+  (check-type-error #'(lambda (x) (remove 'a x)) #'sequencep)
+  nil)
+
 
 ;;;
 
@@ -904,6 +908,10 @@
   (signals-error (delete 'a (list 'a 'b 'c) :key #'car) type-error)
   t)
 
+(deftest delete.error.11
+  (check-type-error #'(lambda (x) (delete 'a x)) #'sequencep)
+  nil)
+
 ;;; More specialized string tests
 
 (deftest remove-if-string.1
diff --git a/ansi-tests/remprop.lsp b/ansi-tests/remprop.lsp
index 8950b8258e8435fb1788367c73429f48f85abf06..8a535becadaec6e03ab96e4dddcbcfd1f5cdb995 100644
--- a/ansi-tests/remprop.lsp
+++ b/ansi-tests/remprop.lsp
@@ -69,12 +69,5 @@
   t)
 
 (deftest remprop.error.4
-  (loop for x in *mini-universe*
-	unless (or (symbolp x)
-		   (eval `(signals-error (remprop ',x nil) type-error)))
-	collect x)
+  (check-type-error #'(lambda (x) (remprop x nil)) #'symbolp)
   nil)
-
-
-
-	
diff --git a/ansi-tests/reverse.lsp b/ansi-tests/reverse.lsp
index fa84ea8e137e93a242025fbf7fe33f6b38695294..2038683a6ced30bf1da631e379e198c982dd270c 100644
--- a/ansi-tests/reverse.lsp
+++ b/ansi-tests/reverse.lsp
@@ -169,24 +169,8 @@
 ;;; Error cases
 
 (deftest reverse.error.1
-  (signals-error (reverse 'a) type-error)
-  t)
-
-(deftest reverse.error.2
-  (signals-error (reverse #\a) type-error)
-  t)
-
-(deftest reverse.error.3
-  (signals-error (reverse 10) type-error)
-  t)
-
-(deftest reverse.error.4
-  (signals-error (reverse 0.3) type-error)
-  t)
-
-(deftest reverse.error.5
-  (signals-error (reverse 10/3) type-error)
-  t)
+  (check-type-error #'reverse #'sequencep)
+  nil)
 
 (deftest reverse.error.6
   (signals-error (reverse) program-error)
diff --git a/ansi-tests/rplaca.lsp b/ansi-tests/rplaca.lsp
index ec5ea782b142800f73fe84a0fa712ddce9705b76..cb7c43d416211970e8eb39c4a8e4807bd5505606 100644
--- a/ansi-tests/rplaca.lsp
+++ b/ansi-tests/rplaca.lsp
@@ -27,9 +27,7 @@
 
 ;; rplaca on a non-cons is a type error
 (deftest rplaca.error.1
-  (loop for x in *universe*
-	thereis (and (not (consp x))
-		     (not (eval `(signals-error (rplaca ',x 1) type-error)))))
+  (check-type-error #'(lambda (x) (rplaca x 1)) #'consp)
   nil)
 
 (deftest rplaca.error.2
@@ -44,10 +42,6 @@
   (signals-error (rplaca (cons 'a 'b) (cons 'c 'd) 'garbage) program-error)
   t)
 
-(deftest rplaca.error.5
-  (signals-error (rplaca 'a 1) type-error)
-  t)
-
 (deftest rplaca.error.6
   (signals-error (locally (rplaca 'a 1) t) type-error)
   t)
diff --git a/ansi-tests/rplacd.lsp b/ansi-tests/rplacd.lsp
index f8e55119a90d02884825ffd8c7ee09dc23a2e8fc..bf53c10b689f14a04d7242fa7472d92d84870adf 100644
--- a/ansi-tests/rplacd.lsp
+++ b/ansi-tests/rplacd.lsp
@@ -27,9 +27,7 @@
 
 ;; rplacd on a non-cons is a type error
 (deftest rplacd.error.1
-  (loop for x in *universe*
-	thereis (and (not (consp x))
-		     (not (eval `(signals-error (rplacd ',x 1) type-error)))))
+  (check-type-error #'(lambda (x) (rplacd x 1)) #'consp)
   nil)
 
 (deftest rplacd.error.2
@@ -44,10 +42,6 @@
   (signals-error (rplacd (cons 'a 'b) (cons 'c 'd) 'garbage) program-error)
   t)
 
-(deftest rplacd.error.5
-  (signals-error (rplacd 'a 1) type-error)
-  t)
-
 (deftest rplacd.error.6
   (signals-error (locally (rplacd 'a 1) t) type-error)
   t)
diff --git a/ansi-tests/set-difference.lsp b/ansi-tests/set-difference.lsp
index 7a84b4cb8f88d6c15ef3c8fa28cb21a50ea8e7ab..c10c7ffa74300f748a8bea7ab4151318a9d9e539 100644
--- a/ansi-tests/set-difference.lsp
+++ b/ansi-tests/set-difference.lsp
@@ -320,3 +320,12 @@
 (deftest set-difference.error.12
   (signals-error (set-difference (list* 1 2 3) (list 4 5 6)) type-error)
   t)
+
+(deftest set-difference.error.13
+  (check-type-error #'(lambda (x) (set-difference x '(a b c))) #'listp)
+  nil)
+
+(deftest set-difference.error.14
+  (check-type-error #'(lambda (x) (set-difference '(a b c) x)) #'listp)
+  nil)
+
diff --git a/ansi-tests/set-exclusive-or.lsp b/ansi-tests/set-exclusive-or.lsp
index b937263a973cece12c40e44c49bb49d60b994cbc..f2a3e2f3198ab96982415907f1b46f4c751e8003 100644
--- a/ansi-tests/set-exclusive-or.lsp
+++ b/ansi-tests/set-exclusive-or.lsp
@@ -361,6 +361,14 @@
   (signals-error (set-exclusive-or (list* 1 2 3) (list 4 5 6)) type-error)
   t)
 
+(deftest set-exclusive-or.error.13
+  (check-type-error #'(lambda (x) (set-exclusive-or x '(a b c))) #'listp)
+  nil)
+
+(deftest set-exclusive-or.error.14
+  (check-type-error #'(lambda (x) (set-exclusive-or '(a b c) x)) #'listp)
+  nil)
+
 
 ;;; Randomized test
 
diff --git a/ansi-tests/sin.lsp b/ansi-tests/sin.lsp
index 723dc36d7e16d79f98243ecb7098adb9b7c5994d..0b4f2468b002e1317e6de004e390b99c9cb0633a 100644
--- a/ansi-tests/sin.lsp
+++ b/ansi-tests/sin.lsp
@@ -167,8 +167,5 @@
   t)
 
 (deftest sin.error.3
-  (loop for x in *mini-universe*
-	unless (or (numberp x)
-		   (eval `(signals-error (sin ',x) type-error)))
-	collect x)
+  (check-type-error #'sin #'numberp)
   nil)
diff --git a/ansi-tests/sinh.lsp b/ansi-tests/sinh.lsp
index 5efa0f85beabe3b868ff29c998ac22d00b435779..0df39b0ce9bb67bebf9e006775b17c7de63cbc1f 100644
--- a/ansi-tests/sinh.lsp
+++ b/ansi-tests/sinh.lsp
@@ -80,10 +80,7 @@
   t)
 
 (deftest sinh.error.3
-  (loop for x in *mini-universe*
-	unless (or (numberp x)
-		   (eval `(signals-error (sinh ',x) type-error)))
-	collect x)
+  (check-type-error #'sinh #'numberp)
   nil)
 
 
diff --git a/ansi-tests/some.lsp b/ansi-tests/some.lsp
index 6158b35bfe4a56f8103efc41c7e2687659ebc002..0e21c8d4262e72494fe11e7571f11e629e199d6a 100644
--- a/ansi-tests/some.lsp
+++ b/ansi-tests/some.lsp
@@ -273,32 +273,17 @@
 
 
 (deftest some.error.1
-  (signals-error (some 1 '(a b c)) type-error)
-  t)
-
-(deftest some.error.2
-  (signals-error (some #\a '(a b c)) type-error)
-  t)
-
-(deftest some.error.3
-  (signals-error (some #() '(a b c)) type-error)
-  t)
+  (check-type-error #'(lambda (x) (some x '(a b c)))
+		    (typef '(or symbol function)))
+  nil)
 
 (deftest some.error.4
-  (signals-error (some #'null 'a) type-error)
-  t)
-
-(deftest some.error.5
-  (signals-error (some #'null 100) type-error)
-  t)
-
-(deftest some.error.6
-  (signals-error (some #'null 'a) type-error)
-  t)
+  (check-type-error #'(lambda (x) (some #'null x)) #'sequencep)
+  nil)
 
 (deftest some.error.7
-  (signals-error (some #'eq () 'a) type-error)
-  t)
+  (check-type-error #'(lambda (x) (some #'eql () x)) #'sequencep)
+  nil)
 
 (deftest some.error.8
   (signals-error (some) program-error)
diff --git a/ansi-tests/sort.lsp b/ansi-tests/sort.lsp
index 4cf39828253110786442b0e3645a044363972738..9ef42fd9dd4538e9becce8d857e6abd43dca9568 100644
--- a/ansi-tests/sort.lsp
+++ b/ansi-tests/sort.lsp
@@ -235,3 +235,7 @@
 (deftest sort.error.10
   (signals-error (sort (list 1 2 3 4) #'elt) type-error)
   t)
+
+(deftest sort.error.11
+  (check-type-error #'(lambda (x) (sort x #'<)) #'sequencep)
+  nil)
diff --git a/ansi-tests/special-operator-p.lsp b/ansi-tests/special-operator-p.lsp
index f1ba5e5e470a458bccee04881772a26681ddc7ae..1695d80982e2cd3ff6e9c79c21342eec38497498 100644
--- a/ansi-tests/special-operator-p.lsp
+++ b/ansi-tests/special-operator-p.lsp
@@ -41,8 +41,8 @@
   t 1)
 
 (deftest special-operator-p.error.1
-  (signals-error (special-operator-p 1) type-error)
-  t)
+  (check-type-error #'special-operator-p #'symbolp)
+  nil)
 
 (deftest special-operator-p.error.2
   (signals-error (special-operator-p) program-error)
@@ -51,4 +51,3 @@
 (deftest special-operator-p.error.3
   (signals-error (special-operator-p 'cons 'cons) program-error)
   t)
-
diff --git a/ansi-tests/sqrt.lsp b/ansi-tests/sqrt.lsp
index cfba03640dbb91c5a06242ebe7f3e158a3a41608..58a1259c5f4a31cab3b4a3f3ecf4d8a8aec04c91 100644
--- a/ansi-tests/sqrt.lsp
+++ b/ansi-tests/sqrt.lsp
@@ -16,10 +16,7 @@
   t)
 
 (deftest sqrt.error.3
-  (loop for x in *mini-universe*
-	unless (or (numberp x)
-		   (eval `(signals-error (sqrt ',x) type-error)))
-	collect x)
+  (check-type-error #'sqrt #'numberp)
   nil)
 
 (deftest sqrt.1
diff --git a/ansi-tests/stable-sort.lsp b/ansi-tests/stable-sort.lsp
index ea0443d1c3fc44d54a6a71bf8a78c09736b12ba2..3ea8f726f23937bd31311f0100c7266b537fe4e2 100644
--- a/ansi-tests/stable-sort.lsp
+++ b/ansi-tests/stable-sort.lsp
@@ -216,3 +216,7 @@
 (deftest stable-sort.error.10
   (signals-error (stable-sort (list 1 2 3 4) #'elt) type-error)
   t)
+
+(deftest stable-sort.error.11
+  (check-type-error #'(lambda (x) (stable-sort x #'<)) #'sequencep)
+  nil)
diff --git a/ansi-tests/stream-element-type.lsp b/ansi-tests/stream-element-type.lsp
index 6142b229873eb4f33c1e1a5fbe56ae0ce468c319..e595ecea8ae21a10e830b320fa743aa5b8c4f04f 100644
--- a/ansi-tests/stream-element-type.lsp
+++ b/ansi-tests/stream-element-type.lsp
@@ -83,9 +83,5 @@
   t)
 
 (deftest stream-element-type.error.3
-  (loop for x in *mini-universe*
-	unless (or (typep x 'stream)
-		   (eval `(signals-error (stream-element-type ',x)
-					 type-error)))
-	collect x)
+  (check-type-error #'stream-element-type #'streamp)
   nil)
diff --git a/ansi-tests/subsetp.lsp b/ansi-tests/subsetp.lsp
index 9116091e0adbeabcb057a6d2e83d78a1439dfc7a..a296047f1c8ea4a90dda12be7b2841229354efa3 100644
--- a/ansi-tests/subsetp.lsp
+++ b/ansi-tests/subsetp.lsp
@@ -259,3 +259,12 @@
 (deftest subsetp.error.12
   (signals-error (subsetp (list* 1 2 3) (list 1 2 3 4 5 6)) type-error)
   t)
+
+(deftest subsetp.error.13
+  (check-type-error #'(lambda (x) (subsetp x nil)) #'listp)
+  nil)
+
+(deftest subsetp.error.14
+  (check-type-error #'(lambda (x) (subsetp nil x)) #'listp)
+  nil)
+
diff --git a/ansi-tests/substitute-if-not.lsp b/ansi-tests/substitute-if-not.lsp
index c8c3e5418dab3573441fe5e6e84e1308d68eebef..186c9548ba4effbfe5c665a4ffaabf984c191680 100644
--- a/ansi-tests/substitute-if-not.lsp
+++ b/ansi-tests/substitute-if-not.lsp
@@ -867,3 +867,6 @@
 		 program-error)
   t)
 
+(deftest substitute-if-not.error.12
+  (check-type-error #'(lambda (x) (substitute-if-not 'a #'not x)) #'sequencep)
+  nil)
diff --git a/ansi-tests/substitute-if.lsp b/ansi-tests/substitute-if.lsp
index b0868389aa7ceabb92ebbf986ca9d0b093f893ac..8a031356e2164560266f590b3086b91fa93f235c 100644
--- a/ansi-tests/substitute-if.lsp
+++ b/ansi-tests/substitute-if.lsp
@@ -890,3 +890,7 @@
 				  :key #'cons)
 		 program-error)
   t)
+
+(deftest substitute-if.error.12
+  (check-type-error #'(lambda (x) (substitute-if 'a #'not x)) #'sequencep)
+  nil)
diff --git a/ansi-tests/substitute.lsp b/ansi-tests/substitute.lsp
index 7526f6de50d2fd9fef61f5042adf5f5608494617..f8c24e9593d16c416c57dcd4dcfd1d48828c0d88 100644
--- a/ansi-tests/substitute.lsp
+++ b/ansi-tests/substitute.lsp
@@ -1138,3 +1138,6 @@
   (signals-error (substitute 'a 'b (list 'a 'b 'c) :key #'car) type-error)
   t)
 
+(deftest substitute.error.12
+  (check-type-error #'(lambda (x) (substitute 'a 'b x)) #'sequencep)
+  nil)
diff --git a/ansi-tests/symbol-function.lsp b/ansi-tests/symbol-function.lsp
index 70115081c7ece7363606732aa54cbf07d4c1230c..9aa6b64cc925272aafc64c630d3f300b1e239866 100644
--- a/ansi-tests/symbol-function.lsp
+++ b/ansi-tests/symbol-function.lsp
@@ -24,18 +24,12 @@
   t)
 
 (deftest symbol-function.error.3
-  (loop for x in *mini-universe*
-	for form = `(signals-error (symbol-function ',x) type-error)
-	unless (or (symbolp x) (eval form))
-	collect x)
+  (check-type-error #'symbol-function #'symbolp)
   nil)
 
 (deftest symbol-function.error.4
-  (loop for x in *mini-universe*
-	for form = `(signals-error (setf (symbol-function ',x) #'identity)
-				   type-error)
-	unless (or (symbolp x) (eval form))
-	collect x)
+  (check-type-error #'(lambda (x) (setf (symbol-function x) #'identity))
+		    #'symbolp)
   nil)
 
 (deftest symbol-function.error.5
diff --git a/ansi-tests/symbol-name.lsp b/ansi-tests/symbol-name.lsp
index 3c07259f182a4527a138ab37ad24131385b2b3f8..65d7bb3cfe33e7cda459569657dcd82efd7f34f6 100644
--- a/ansi-tests/symbol-name.lsp
+++ b/ansi-tests/symbol-name.lsp
@@ -14,22 +14,6 @@
   "1234abcdABCD")
 
 (deftest symbol-name.3
-  (signals-error (symbol-name 1) type-error)
-  t)
-
-(deftest symbol-name.4
-  (signals-error (symbol-name '(a)) type-error)
-  t)
-
-(deftest symbol-name.5
-  (signals-error (symbol-name "ABCDE") type-error)
-  t)
-
-(deftest symbol-name.6
-  (signals-error (symbol-name 12913.0213) type-error)
-  t)
-
-(deftest symbol-name.7
   (symbol-name :|abcdefg|)
   "abcdefg")
 
@@ -44,10 +28,7 @@
   t)
 
 (deftest symbol-name.error.3
-  (loop for x in *mini-universe*
-	for form = `(signals-error (symbol-name ',x) type-error)
-	unless (or (symbolp x) (eval form))
-	collect x)
+  (check-type-error #'symbol-name #'symbolp)
   nil)
 
 
diff --git a/ansi-tests/tan.lsp b/ansi-tests/tan.lsp
index fa2764ae62c43d73c2eab67f6909340532831126..778ed1fedaf9ee73642bd0d331c2876d99f9d55c 100644
--- a/ansi-tests/tan.lsp
+++ b/ansi-tests/tan.lsp
@@ -154,9 +154,5 @@
   t)
 
 (deftest tan.error.3
-  (loop for x in *mini-universe*
-	unless (or (numberp x)
-		   (eval `(signals-error (tan ',x) type-error)))
-	collect x)
+  (check-type-error #'tan #'numberp)
   nil)
-
diff --git a/ansi-tests/tanh.lsp b/ansi-tests/tanh.lsp
index 5b1479276500895bbdb0318eca7c4cb926783a5f..b36feb20d4d1b20c6ce6bb2cfcd5d9fc15ae43c6 100644
--- a/ansi-tests/tanh.lsp
+++ b/ansi-tests/tanh.lsp
@@ -80,8 +80,5 @@
   t)
 
 (deftest tanh.error.3
-  (loop for x in *mini-universe*
-	unless (or (numberp x)
-		   (eval `(signals-error (tanh ',x) type-error)))
-	collect x)
+  (check-type-error #'tanh #'numberp)
   nil)
diff --git a/ansi-tests/union.lsp b/ansi-tests/union.lsp
index 7446049498723cd108be6f19702d2a0d13e519a9..b4309cd3493e2e7eec4185d66686f7642e2bcc41 100644
--- a/ansi-tests/union.lsp
+++ b/ansi-tests/union.lsp
@@ -412,3 +412,12 @@
 (deftest union.error.12
   (signals-error (union (list* 1 2 3) (list 4 5 6)) type-error)
   t)
+
+(deftest union.error.13
+  (check-type-error #'(lambda (x) (union x nil)) #'listp)
+  nil)
+
+(deftest union.error.14
+  (check-type-error #'(lambda (x) (union nil x)) #'listp)
+  nil)
+
diff --git a/ansi-tests/values-list.lsp b/ansi-tests/values-list.lsp
index faae61e6ddddb136dde37d90a65b21436beba72f..e3c92169b9a1092061b64e1e5fb4cc90de62807b 100644
--- a/ansi-tests/values-list.lsp
+++ b/ansi-tests/values-list.lsp
@@ -14,8 +14,8 @@
   t)
 
 (deftest values-list.error.3
-  (signals-error (values-list 'a) type-error)
-  t)
+  (check-type-error #'values-list #'list)
+  nil)
 
 (deftest values-list.error.4
   (signals-error (values-list '(a b c . d)) type-error)
diff --git a/ansi-tests/wild-pathname-p.lsp b/ansi-tests/wild-pathname-p.lsp
index d8a66b66c4c18133f15981f524e551fa40ca6c79..d161c434856f656a638044f26dc77cf072b10141 100644
--- a/ansi-tests/wild-pathname-p.lsp
+++ b/ansi-tests/wild-pathname-p.lsp
@@ -221,18 +221,14 @@
   t)
 
 (deftest wild-pathname-p.error.3
-  (loop for x in *mini-universe*
-	unless (or (could-be-pathname-designator x)
-		   (eval `(signals-error (wild-pathname-p ',x)
-					 type-error)))
-	collect x)
+  (check-type-error #'wild-pathname-p
+		    (typef '(or pathname string file-stream
+				synonym-stream)))
   nil)
 
 (deftest wild-pathname-p.error.4
-  (loop for x in *mini-universe*
-	unless (or (could-be-pathname-designator x)
-		   (eval `(signals-error (wild-pathname-p ',x)
-					 type-error
-					 :safety 0)))
-	collect x)
+  (check-type-error #'(lambda (x) (declare (optimize (safety 0)))
+			(wild-pathname-p x))
+		    (typef '(or pathname string file-stream
+				synonym-stream)))
   nil)
diff --git a/ansi-tests/with-compilation-unit.lsp b/ansi-tests/with-compilation-unit.lsp
index 7f4661ba8514684daec3d4fb516cdbf20e495d92..b748b1c53900b39a057c4a087df06afa70b4a5b9 100644
--- a/ansi-tests/with-compilation-unit.lsp
+++ b/ansi-tests/with-compilation-unit.lsp
@@ -43,6 +43,7 @@
      x))
   2 1)
 
-
-
- 
+;;; Add a test that (1) checks if the compiler normally delays
+;;; warnings until the end of a file and, if so, (2) checks that
+;;; with-compilation-unit delays the warnings for more than one
+;;; file compilation until the end of the unit.
diff --git a/ansi-tests/write-sequence.lsp b/ansi-tests/write-sequence.lsp
index bbc39fcbd152af960451f5a6be8e61e87b2b5d2b..c16ef8e5978422d394026e42b35cba97988f85eb 100644
--- a/ansi-tests/write-sequence.lsp
+++ b/ansi-tests/write-sequence.lsp
@@ -205,3 +205,21 @@
   (signals-error (write-sequence "abcde" *standard-output* :start)
 		 program-error)
   t)
+
+(deftest write-sequence.error.14
+  (check-type-error #'(lambda (x) (write-sequence x *standard-output*))
+		    #'sequencep)
+  nil)
+
+(deftest write-sequence.error.15
+  (check-type-error #'(lambda (x) (write-sequence "abcde" *standard-output*
+						  :start x))
+		    (typef 'unsigned-byte))
+  nil)
+
+(deftest write-sequence.error.16
+  (check-type-error #'(lambda (x) (write-sequence "abcde" *standard-output*
+						  :end x))
+		    (typef '(or null unsigned-byte)))
+  nil)
+
diff --git a/ansi-tests/zerop.lsp b/ansi-tests/zerop.lsp
index c21d08d5594d06b254aaa4e86b85458306b98e64..bc12c1d660a69a268e6713cd71a6698f230f9bbe 100644
--- a/ansi-tests/zerop.lsp
+++ b/ansi-tests/zerop.lsp
@@ -18,10 +18,7 @@
   t)
 
 (deftest zerop.error.4
-  (loop for x in *mini-universe*
-	unless (or (numberp x)
-		   (eval `(signals-error (zerop ',x) type-error)))
-	collect x)
+  (check-type-error #'zerop #'numberp)
   nil)
 
 (deftest zerop.1