diff --git a/ansi-tests/README b/ansi-tests/README
index 1d56d8059b9f3cad633148327bdf70f73aebe7c8..f40f50a395082cc8b0c111855d8d4dbe94bea90e 100644
--- a/ansi-tests/README
+++ b/ansi-tests/README
@@ -12,3 +12,12 @@ Please tell me when you find incorrect test cases.
 	Paul Dietz
 	dietz@dls.net
 
+--------------------------------
+
+(30 Jun 2003) I've decided to add metainformation to the tests,
+in the form of :<attribute> <value> pairs after DEFTEST.  Also,
+I've added a DEFNOTE form to define note objects whose names
+can be attached to properties of tests, to enable selective
+disabling of classes of tests.
+
+
diff --git a/ansi-tests/ansi-aux.lsp b/ansi-tests/ansi-aux.lsp
index 74456b228c66c9482c05633f17ca77706501405f..2ec44f1a7b762ae6e47b33c5e9cc7f00d34ecdd8 100644
--- a/ansi-tests/ansi-aux.lsp
+++ b/ansi-tests/ansi-aux.lsp
@@ -91,7 +91,11 @@ Results: ~A~%" expected-number form n results))))
   (loop for i from 0 below n collect i))
 
 (defun make-int-array (n &optional (fn #'make-array))
-  (let ((a (funcall fn n)))
+  (when (symbolp fn)
+    (assert (fboundp fn))
+    (setf fn (symbol-function (the symbol fn))))
+  (let ((a (funcall (the function fn) n)))
+    (declare (type (array * *) a))
     (loop for i from 0 below n do (setf (aref a i) i))
     a))
 
@@ -106,17 +110,19 @@ Results: ~A~%" expected-number form n results))))
 	   (equal (aref a1) (aref a2))
 	 (let ((ad (array-dimensions a1)))
 	   (and (equal ad (array-dimensions a2))
-		(if (= (array-rank a1) 1)
-		    (let ((as (first ad)))
-		      (loop
-		       for i from 0 below as
-		       always (equal (aref a1 i) (aref a2 i))))
-		  (let ((as (array-total-size a1)))
-		    (and (= as (array-total-size a2))
-			 (loop
-			  for i from 0 below as
-			  always (equal (row-major-aref a1 i)
-					(row-major-aref a2 i)))))))))))
+		(locally
+		 (declare (type (array * *) a1 a2))
+		 (if (= (array-rank a1) 1)
+		     (let ((as (first ad)))
+		       (loop
+			for i from 0 below as
+			always (equal (aref a1 i) (aref a2 i))))
+		   (let ((as (array-total-size a1)))
+		     (and (= as (array-total-size a2))
+			  (loop
+			   for i from 0 below as
+			   always (equal (row-major-aref a1 i)
+					 (row-major-aref a2 i))))))))))))
 
 ;;; *universe* is defined elsewhere -- it is a list of various
 ;;; lisp objects used when stimulating things in various tests.
@@ -207,11 +213,17 @@ Results: ~A~%" expected-number form n results))))
   "Check that a predicate P is the same as #'(lambda (x) (typep x TYPE))
    by applying both to all elements of *UNIVERSE*.  Print message
    when a mismatch is found, and return number of mistakes."
+
+  (when (symbolp p)
+    (assert (fboundp p))
+    (setf p (symbol-function p)))
+  (assert (typep p 'function))
+  
   (loop
       for x in *universe* count
 	(block failed
 	  (let ((p1 (handler-case
-			(funcall P x)
+			(funcall (the function p) x)
 		      (error () (format t "(FUNCALL ~S ~S) failed~%"
 					P x)
 			(return-from failed t))))
@@ -376,8 +388,8 @@ the condition to go uncaught if it cannot be classified."
 
 (defun compose (&rest fns)
   (let ((rfns (reverse fns)))
-    #'(lambda (x) (loop for f of-type function
-			in rfns do (setf x (funcall f x))) x)))
+    #'(lambda (x) (loop for f
+			in rfns do (setf x (funcall (the function f) x))) x)))
 
 (defun evendigitp (c)
   (notnot (find c "02468")))
@@ -417,8 +429,9 @@ the condition to go uncaught if it cannot be classified."
     (cons 'list args)))  
 
 (defparameter +standard-chars+
+  (coerce
   "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~!@#$%^&*()_+|\\=-`{}[]:\";'<>?,./
- ")
+ " 'simple-base-string))
 
 (defparameter
   +base-chars+ #.(concatenate 'simple-base-string
@@ -436,16 +449,21 @@ the condition to go uncaught if it cannot be classified."
 (defparameter +upper-case-chars+ (subseq +alpha-chars+ 26 52))
 (defparameter +alphanumeric-chars+ (subseq +standard-chars+ 0 62))
 (defparameter +digit-chars+ "0123456789")
-(defparameter +extended-digit-chars+ "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+(defparameter +extended-digit-chars+ (coerce
+				      "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+				      'simple-base-string))
 
 (declaim (type simple-base-string +alpha-chars+ +lower-case-chars+
-	       +upper-case-chars+ +alphanumeric-chars+))
+	       +upper-case-chars+ +alphanumeric-chars+ +extended-digit-chars+
+	       +standard-chars+))
 
 (defparameter +code-chars+
   (coerce (loop for i from 0 below 256
 		for c = (code-char i)
 		when c collect c)
-	  'string))
+	  'simple-string))
+
+(declaim (type simple-string +code-chars+))
 
 (defparameter +rev-code-chars+ (reverse +code-chars+))
 
@@ -453,7 +471,7 @@ the condition to go uncaught if it cannot be classified."
 
 (defun has-non-abort-restart (c)
   (throw 'handled
-	 (if (position 'abort (compute-restarts c)
+	 (if (position 'abort (the list (compute-restarts c))
 		       :key #'restart-name :test-not #'eq)
 	     'success
 	   'fail)))
@@ -1256,11 +1274,11 @@ the condition to go uncaught if it cannot be classified."
   (classify-error* (elt x n)))
 
 (defmacro defstruct* (&body args)
-  `(eval-when (load eval compile)
+  `(eval-when #+gcl (load eval compile)
+	      #-gcl (:load-toplevel :compile-toplevel :execute)
      (handler-case (eval '(defstruct ,@args))
 		   (serious-condition () nil))))
 
-
 (defun sort-package-list (x)
   (sort (copy-list x)
 	#'string<
diff --git a/ansi-tests/char-aux.lsp b/ansi-tests/char-aux.lsp
index 61d6d42f07d5ff4ea0ae837fc88647bf697d2c8b..523f26940df7a539a801e47e1c9ad13f3d81dee3 100644
--- a/ansi-tests/char-aux.lsp
+++ b/ansi-tests/char-aux.lsp
@@ -6,6 +6,7 @@
 (in-package :cl-test)
 
 (defun is-ordered-by (seq fn)
+  (declare (type function fn))
   (let ((n (length seq)))
     (loop for i from 0 below (1- n)
 	  for e = (elt seq i)
@@ -14,21 +15,28 @@
 		always (funcall fn e (elt seq j))))))
 
 (defun is-antisymmetrically-ordered-by (seq fn)
+  (declare (type function fn))
   (and (is-ordered-by seq fn)
        (is-ordered-by (reverse seq) (complement fn))))
 
 (defun is-case-insensitive (fn)
-  (loop for c across +code-chars+
-	for c1 = (char-upcase c)
-	for c2 = (if (eql c c1) (char-downcase c) c1)
-	always
-	(loop for d across +code-chars+
-	      for d1 = (char-upcase d)
-	      for d2 = (if (eql d d1) (char-downcase d) d1)
-	      always (equiv (funcall fn c d)
-			    (funcall fn c2 d)
-			    (funcall fn c d2)
-			    (funcall fn c2 d2)))))
+  (when (symbolp fn)
+    (assert (fboundp fn))
+    (setf fn (symbol-function fn)))
+  (assert (typep fn 'function))
+  (locally
+   (declare (type function fn))
+   (loop for c across +code-chars+
+	 for c1 = (char-upcase c)
+	 for c2 = (if (eql c c1) (char-downcase c) c1)
+	 always
+	 (loop for d across +code-chars+
+	       for d1 = (char-upcase d)
+	       for d2 = (if (eql d d1) (char-downcase d) d1)
+	       always (equiv (funcall fn c d)
+			     (funcall fn c2 d)
+			     (funcall fn c d2)
+			     (funcall fn c2 d2))))))
 
 (defun equiv (&rest args)
   (declare (dynamic-extent args))
@@ -40,9 +48,15 @@
 
 ;;; From character.lsp
 (defun char-type-error-check (fn)
-  (loop for x in *universe*
-	always (or (characterp x)
-		   (eqt (catch-type-error (funcall fn x)) 'type-error))))
+  (when (symbolp fn)
+    (assert (fboundp fn))
+    (setf fn (symbol-function fn)))
+  (assert (typep fn 'function))
+  (locally
+   (declare (type function fn))
+   (loop for x in *universe*
+	 always (or (characterp x)
+		    (eqt (catch-type-error (funcall fn x)) 'type-error)))))
 
 (defun standard-char.5.body ()
   (loop for i from 0 below (min 65536 char-code-limit)
diff --git a/ansi-tests/cl-symbols.lsp b/ansi-tests/cl-symbols.lsp
index e0287fcfd399b82cb809a0fa3465322d964a4e25..a60cba8fdfddecde2ad1e33fe7d4cd7a120e0fa8 100644
--- a/ansi-tests/cl-symbols.lsp
+++ b/ansi-tests/cl-symbols.lsp
@@ -1134,14 +1134,6 @@
 
 ;;; Various error cases for symbol-related functions
 
-(deftest symbolp.error.1
-  (classify-error (symbolp))
-  program-error)
-
-(deftest symbolp.error.2
-  (classify-error (symbolp nil nil))
-  program-error)
-
 (deftest symbol-function.error.1
   (classify-error (symbol-function))
   program-error)
diff --git a/ansi-tests/cl-test-package.lsp b/ansi-tests/cl-test-package.lsp
index 5a77e47cc2b0aea9694c859564aaea5d6f7e15a0..042d44c92f88a5e30e4558e5b095879838b5d574 100644
--- a/ansi-tests/cl-test-package.lsp
+++ b/ansi-tests/cl-test-package.lsp
@@ -8,8 +8,6 @@
   ;; #+gcl (:use defpackage)
   (:nicknames)
   (:import-from "COMMON-LISP-USER" #:compile-and-load "==>")
-  (:export))
+  (:export #:random-from-seq #:random-case #:coin #:random-permute))
 
 #+cmu (import 'cl::quit :cl-test)
-
-
diff --git a/ansi-tests/compile-and-load.lsp b/ansi-tests/compile-and-load.lsp
index a1a3e500f2fef2405df09178f4ab9b8741ac90f0..5fa9615662f61e23450f00945617650be08a550d 100644
--- a/ansi-tests/compile-and-load.lsp
+++ b/ansi-tests/compile-and-load.lsp
@@ -6,7 +6,8 @@
   (when (eq excl:*current-case-mode* :case-sensitive-lower)
     (push :lower-case *features*)))
 
-(eval-when (load eval compile)
+(eval-when #+gcl (load eval compile)
+	   #-gcl (:load-toplevel :compile-toplevel :execute)
   (intern "==>" "CL-USER")
   (unless (fboundp 'compile-file-pathname)
     (defun compile-file-pathname (pathname)
diff --git a/ansi-tests/defclass-aux.lsp b/ansi-tests/defclass-aux.lsp
index 10c1e18905139fd1e6d206f278ae186c1934918c..b65ff7709adde8906eb29d26a72ecd8c7ec5d0b9 100644
--- a/ansi-tests/defclass-aux.lsp
+++ b/ansi-tests/defclass-aux.lsp
@@ -167,7 +167,8 @@
     `(progn
        (declaim (special ,class-var-name))
        
-       (eval-when (load eval compile)
+       (eval-when #+gcl (load eval compile)
+		  #-gcl (:load-toplevel :compile-toplevel :execute)
 	 (ignore-errors (setq ,class-var-name (defclass ,@(cdr args)))))
 
        (deftest ,(make-defclass-test-name class-name "-DEFCLASS-RETURNS-CLASS")
diff --git a/ansi-tests/define-condition-aux.lsp b/ansi-tests/define-condition-aux.lsp
index eabafeb712a6cfd293cb83c373dede3b92406558..4e94c7437aa09b8827943b8af675b42ab1680990 100644
--- a/ansi-tests/define-condition-aux.lsp
+++ b/ansi-tests/define-condition-aux.lsp
@@ -19,7 +19,8 @@
   (dolist (parent parents) (assert (symbolp parent)))
   
   (let ((name (symbol-name name-symbol)))
-  `(eval-when (load eval compile)
+  `(eval-when #+gcl (load eval compile)
+	      #-gcl (:load-toplevel :compile-toplevel :execute)
      (ignore-errors (eval '(define-condition ,name-symbol ,parents
 			    ,slot-specs ,@options)))
      ,@(loop for parent in (adjoin 'condition parents)
diff --git a/ansi-tests/defun.lsp b/ansi-tests/defun.lsp
index 6ed7830dc3b9aadc8306fa208074724e174f08d2..d422cf3059d2673489601ed210b24d66dd4232ea 100644
--- a/ansi-tests/defun.lsp
+++ b/ansi-tests/defun.lsp
@@ -53,7 +53,8 @@
   c
   (c b))
 
-(eval-when (load eval compile)
+(eval-when #+gcl (load eval compile)
+	   #-gcl (:load-toplevel :compile-toplevel :execute)
   (ignore-errors
     (defun (setf defun-test-fun-4) (newval x)
       (return-from defun-test-fun-4 (setf (car x) newval)))))
diff --git a/ansi-tests/fboundp.lsp b/ansi-tests/fboundp.lsp
index 0ec7332dfdebfbcb095d0818453b95e54b634ddf..c993d48f23ef8a40b94edd896bd5415d509d582c 100644
--- a/ansi-tests/fboundp.lsp
+++ b/ansi-tests/fboundp.lsp
@@ -27,7 +27,8 @@
   (not-mv (fboundp 'fboundp-5-fn))
   nil)
 
-(eval-when (eval compile)
+(eval-when #+gcl (eval compile)
+	   #-gcl (:load-toplevel :compile-toplevel)
   (ignore-errors
     (defun (setf fboundp-6-accessor) (y x) (setf (car x) y))))
 
diff --git a/ansi-tests/function.lsp b/ansi-tests/function.lsp
index f6039c651669a03dbb224514624172f164b9080a..cd4733cb40d7c17b8868dafd420eb5bed09495c3 100644
--- a/ansi-tests/function.lsp
+++ b/ansi-tests/function.lsp
@@ -47,7 +47,8 @@
   (typep '(lambda (x) x) 'function)
   nil)
 
-(eval-when (eval compile)
+(eval-when #+gcl (eval compile)
+	   #-gcl (:load-toplevel :compile-toplevel)
   (ignore-errors
     (defun (setf function-7-accessor) (y x) (setf (car x) y) y)))
 
diff --git a/ansi-tests/functionp.lsp b/ansi-tests/functionp.lsp
index 23edd0939af2c72185729c413b937a3f64b1214d..5275ed8a3a8bd731068d274fcc6f4ac362456d0b 100644
--- a/ansi-tests/functionp.lsp
+++ b/ansi-tests/functionp.lsp
@@ -46,7 +46,8 @@
   (functionp '(lambda (x) x))
   nil)
 
-(eval-when (eval compile)
+(eval-when #+gcl (eval compile)
+	   #-gcl (:load-toplevel :compile-toplevel)
   (ignore-errors
     (defun (setf functionp-7-accessor) (y x) (setf (car x) y) y)))
 
diff --git a/ansi-tests/gensym.lsp b/ansi-tests/gensym.lsp
index 6d4e66842c213d8af7e2a4e3ca16954ff3aeea88..7661c03c2ae07a69d0009b252704ab4aec4aa405 100644
--- a/ansi-tests/gensym.lsp
+++ b/ansi-tests/gensym.lsp
@@ -93,6 +93,13 @@
     *gensym-counter*)
   10)
 
+;;; GENSYM counter is a non-negative integer
+(deftest gensym-counter.1
+  (and (integerp *gensym-counter*)
+       (>= *gensym-counter* 0)
+       t)
+  t)
+
 ;;; Check response to erroneous arguments
 ;;; Note! NIL is not the same as no argument
 ;;; gensym should be implemented so that its only
diff --git a/ansi-tests/gentemp.lsp b/ansi-tests/gentemp.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..85c0e240164e8a30243f873da0be2b2ac47c6cc8
--- /dev/null
+++ b/ansi-tests/gentemp.lsp
@@ -0,0 +1,8 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sun Jun 22 09:32:09 2003
+;;;; Contains: Tests of GENTEMP
+
+(in-package :cl-test)
+
+
diff --git a/ansi-tests/load-symbols.lsp b/ansi-tests/load-symbols.lsp
index d8863f009a313bb7e5d9d6f7810249ce01bb2b5e..27c014d054dd72bb50c2446d80cef8ae95a1b232 100644
--- a/ansi-tests/load-symbols.lsp
+++ b/ansi-tests/load-symbols.lsp
@@ -2,10 +2,13 @@
 (compile-and-load "cl-symbols-aux.lsp")
 ;; (load "cl-symbol-names.lsp")  ;; moved to gclload1.lsp
 (load "cl-symbols.lsp")
+(load "symbolp.lsp")
 (load "boundp.lsp")
 (load "copy-symbol.lsp")
 (load "gensym.lsp")
+(load "gentemp.lsp")
 (load "keywordp.lsp")
 (load "make-symbol.lsp")
 (load "symbol-name.lsp")
 (load "special-operator-p.lsp")
+(load "set.lsp")
diff --git a/ansi-tests/rt-package.lsp b/ansi-tests/rt-package.lsp
index 02fc12f363738d44fe4cf511fe5bfb57788fb24e..351617e7c96cef997939f5e11f3e423bee00f66d 100644
--- a/ansi-tests/rt-package.lsp
+++ b/ansi-tests/rt-package.lsp
@@ -4,8 +4,8 @@
 ;;;; Contains: Package definition for RT
 
 (eval-when
- ;;(:execute :compile-toplevel :load-toplevel)
- (load eval compile)
+ #-gcl (:execute :compile-toplevel :load-toplevel)
+ #+gcl (load eval compile)
  (defpackage :regression-test
     (:use :cl)
     (:nicknames :rtest #-lispworks :rt)
@@ -21,6 +21,7 @@
      #:pending-tests
      #:rem-all-tests
      #:rem-test
+     #:defnote
      )))
 
 (in-package :regression-test)
diff --git a/ansi-tests/rt.lsp b/ansi-tests/rt.lsp
index 31191705c09f15e8c8f877dd0f491a2fccc88897..6525c3cb4d63629ea0a01a5a473ec6c96bfe90f2 100644
--- a/ansi-tests/rt.lsp
+++ b/ansi-tests/rt.lsp
@@ -46,9 +46,23 @@
 (defvar *expected-failures* nil
   "A list of test names that are expected to fail.")
 
+(defvar *notes* (make-hash-table :test 'equal)
+  "A mapping from names of notes to note objects.")
+  
 (defstruct (entry (:conc-name nil))
   pend name props form vals)
 
+;;; Note objects are used to attach information to tests.
+;;; A typical use is to mark tests that depend on a particular
+;;; part of a set of requirements, or a particular interpretation
+;;; of the requirements.
+
+(defstruct note
+  name  
+  contents
+  disabled ;; When true, tests with this note are considered inactive
+  )
+
 ;; (defmacro vals (entry) `(cdddr ,entry))
 
 (defmacro defn (entry)
@@ -87,6 +101,20 @@
 	name))
     entry))
 
+(defun entry-notes (entry)
+  (let* ((props (props entry))
+	 (notes (getf props :notes)))
+    (if (listp notes)
+	notes
+      (list notes))))
+
+(defun has-disabled-note (entry)
+  (let ((notes (entry-notes entry)))
+    (loop for n in notes
+	  for note = (if (note-p n) n
+		       (gethash n *notes*))
+	  thereis (and note (note-disabled note)))))
+
 (defmacro deftest (name &rest body)
   (let* ((p body)
 	 (properties
@@ -279,11 +307,11 @@
 (defun do-entries (s)
   (format s "~&Doing ~A pending test~:P ~
              of ~A tests total.~%"
-          (count t (cdr *entries*)
-		 :key #'pend)
+          (count t (the list (cdr *entries*)) :key #'pend)
 	  (length (cdr *entries*)))
   (dolist (entry (cdr *entries*))
-    (when (pend entry)
+    (when (and (pend entry)
+	       (not (has-disabled-note entry)))
       (format s "~@[~<~%~:; ~:@(~S~)~>~]"
 	      (do-entry entry s))))
   (let ((pending (pending-tests))
@@ -314,3 +342,12 @@
 		    new-failures)))
 	  ))
       (null pending))))
+
+;;; Note handling functions and macros
+
+(defmacro defnote (name contents)
+  `(eval-when #+gcl (load eval) #-gcl (:load-toplevel :execute)
+     (let ((note (make-note :name ,name :contents ,contents)))
+       (setf (gethash *notes* (note-name note)) note)
+       note)))
+
diff --git a/ansi-tests/structure-00.lsp b/ansi-tests/structure-00.lsp
index d1b00e3b0f2931280ba94912c025097b6f991090..83d07d46d58d1074857483dce41aba3ce6861583 100644
--- a/ansi-tests/structure-00.lsp
+++ b/ansi-tests/structure-00.lsp
@@ -263,7 +263,8 @@ do the defstruct."
 		     (cons slot-name (defstruct-maketemp name "SLOTTEMP" i)))))
 	 )
     ;; Build the tests in an eval-when form
-    `(eval-when (compile load eval)
+    `(eval-when #+gcl (compile load eval)
+		#-gcl (:load-toplevel :compile-toplevel :execute)
 
        (ignore-errors
 	 (eval '(defstruct ,name-and-options
diff --git a/ansi-tests/structures-02.lsp b/ansi-tests/structures-02.lsp
index e34e25262371a1a9cb75911f9c29ef83859d0d98..9c15d71ac57b2f9fcb57b2c26c2bbe855027545b 100644
--- a/ansi-tests/structures-02.lsp
+++ b/ansi-tests/structures-02.lsp
@@ -376,7 +376,8 @@
 ;;; Initializer forms are evaluated only when needed, and are
 ;;; evaluated in the lexical environment in which they were defined
 
-(eval-when (load eval)
+(eval-when #+gcl (load eval)
+	   #-gcl (:load-toplevel)
   (let ((x nil))
     (flet ((%f () x)
 	  (%g (y) (setf x y)))
diff --git a/ansi-tests/subtypep-array.lsp b/ansi-tests/subtypep-array.lsp
index 49d0d0180239cd6184909fabf5af6f67521e0769..edd0bf34988a69c62366b1dd4cf2810ce6e0db76 100644
--- a/ansi-tests/subtypep-array.lsp
+++ b/ansi-tests/subtypep-array.lsp
@@ -98,11 +98,11 @@
 
 ;;;; Tests on the definitions of various vector types
 
-(deftest string-is-vector-of-character.1
+(deftest string-is-not-vector-of-character.1
   (subtypep* 'string '(vector character))
-  t t)
+  nil t)
 
-(deftest string-is-vector-of-character.2
+(deftest vector-of-character-is-string.2
   (subtypep* '(vector character) 'string)
   t t)
 
@@ -110,7 +110,7 @@
   (subtypep* '(string *) '(vector character))
   nil t)
 
-(deftest string-is-vector-of-character.4
+(deftest vector-of-character-is-string.4
   (subtypep* '(vector character) '(string *))
   t t)
 
@@ -118,7 +118,7 @@
   (subtypep* '(string 17) '(vector character 17))
   nil t)
 
-(deftest string-is-vector-of-character.6
+(deftest vector-of-character-is-string.6
   (subtypep* '(vector character 17) '(string 17))
   t t)
 
@@ -174,7 +174,7 @@
   (subtypep* 'simple-string '(simple-array character (*)))
   nil t)
 
-(deftest simple-string-is-simple-1d-array-of-character.2
+(deftest simple-1d-array-of-character-is-simple-string.2
   (subtypep* '(simple-array character (*)) 'simple-string)
   t t)
 
@@ -182,7 +182,7 @@
   (subtypep* '(simple-string *) '(simple-array character (*)))
   nil t)
 
-(deftest simple-string-is-simple-1d-array-of-character.4
+(deftest simple-1d-array-of-character-is-simple-string.4
   (subtypep* '(simple-array character (*)) '(simple-string *))
   t t)
 
@@ -190,7 +190,7 @@
   (subtypep* '(simple-string 17) '(simple-array character (17)))
   nil t)
 
-(deftest simple-string-is-simple-1d-array-of-character.6
+(deftest simple-1d-array-of-character-is-simple-string.6
   (subtypep* '(simple-array character (17)) '(simple-string 17))
   t t)
 
diff --git a/ansi-tests/symbolp.lsp b/ansi-tests/symbolp.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..a2c7b4d09e2660dfe8d90236da3ce2a6e24f2f2e
--- /dev/null
+++ b/ansi-tests/symbolp.lsp
@@ -0,0 +1,32 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sun Jun 22 08:59:12 2003
+;;;; Contains: Tests for SYMBOLP
+
+(in-package :cl-test)
+
+(deftest symbolp.1
+  (notnot-mv (symbolp nil))
+  t)
+
+(deftest symbolp.2
+  (loop for x in *symbols*
+	unless (symbolp x)
+	collect x)
+  nil)
+
+(deftest symbolp.3
+  (loop for x in (set-difference *universe* *symbols*)
+	when (symbolp x)
+	collect x)
+  nil)
+
+;;; Error cases
+
+(deftest symbolp.error.1
+  (classify-error (symbolp))
+  program-error)
+
+(deftest symbolp.error.2
+  (classify-error (symbolp nil nil))
+  program-error)
diff --git a/ansi-tests/universe.lsp b/ansi-tests/universe.lsp
index b47affae0a55673668054411938597c32486a9a0..c4700a01e6b4e669dc71507c90f2b73f01736e71 100644
--- a/ansi-tests/universe.lsp
+++ b/ansi-tests/universe.lsp
@@ -294,7 +294,12 @@
       (make-array '(5) :element-type 'long-float
 		  :initial-contents '(1.0l0 2.0l0 3.0l0 4.0l0 5.0l0))
       )
-     
+
+     ;; The ever-popular NIL array
+     (handler-case
+      (list (make-array '(0) :element-type nil))
+      (error () nil))
+
      ;; more kinds of arrays here later
      ))
 
@@ -353,7 +358,7 @@
 (defgeneric meaningless-user-generic-function-for-universe (x y z)
   (:method ((x integer) (y integer) (z integer)) (+ x y z)))
 
-(eval-when (load)
+(eval-when #+gcl (load) #-gcl (:load-toplevel)
   (compile 'meaningless-user-function-for-universe)
   (compile 'meaningless-user-generic-function-for-universe)
   )