diff --git a/ansi-tests/and.lsp b/ansi-tests/and.lsp
index 1a1ffdaad1971cfa5890c9483051c19ffc21ba1e..30319b23028ed061727cbb595dc32d0e629ddb69 100644
--- a/ansi-tests/and.lsp
+++ b/ansi-tests/and.lsp
@@ -55,3 +55,16 @@
      i a b c d))
   4 4 1 2 3 4)
 
+(deftest and.error.1
+  (classify-error (funcall (macro-function 'and)))
+  program-error)
+
+(deftest and.error.2
+  (classify-error (funcall (macro-function 'and)
+			   '(and)))
+  program-error)
+
+(deftest and.error.3
+  (classify-error (funcall (macro-function 'and)
+			   '(and) nil nil))
+  program-error)
\ No newline at end of file
diff --git a/ansi-tests/ansi-aux.lsp b/ansi-tests/ansi-aux.lsp
index 3357d12bf47dcab19a782389f9ac692483a011a1..5fac9ada010d9bd79d493e6a3c2c2baa505e9d57 100644
--- a/ansi-tests/ansi-aux.lsp
+++ b/ansi-tests/ansi-aux.lsp
@@ -1438,3 +1438,18 @@ the condition to go uncaught if it cannot be classified."
   (loop for e on plist by #'cddr
 	when (eql (car e) prop)
 	collect (cadr e)))
+
+(defmacro def-macro-test (test-name macro-form)
+  (let ((macro-name (car macro-form)))
+    (assert (symbolp macro-name))
+    `(deftest ,test-name
+       (values
+	(eqlt (classify-error (funcall (macro-function ',macro-name)))
+	      'program-error)
+	(eqlt (classify-error (funcall (macro-function ',macro-name)
+				       ',macro-form))
+	      'program-error)
+	(eqlt (classify-error (funcall (macro-function ',macro-name)
+				       ',macro-form nil nil))
+	      'program-error))
+       t t t)))
\ No newline at end of file
diff --git a/ansi-tests/case.lsp b/ansi-tests/case.lsp
index 0ec8b1bd3813ad70a3b4367ea128a36587811b0e..584e11e52ca1659a3c3faccbb044c6cd011bd980 100644
--- a/ansi-tests/case.lsp
+++ b/ansi-tests/case.lsp
@@ -194,3 +194,17 @@
 ;;; (deftest case.error.1
 ;;;  (classify-error (case))
 ;;;  program-error)
+
+(deftest case.error.1
+  (classify-error (funcall (macro-function 'case)))
+  program-error)
+
+(deftest case.error.2
+  (classify-error (funcall (macro-function 'case)
+			   '(case t)))
+  program-error)
+
+(deftest case.error.3
+  (classify-error (funcall (macro-function 'case)
+			   '(case t) nil nil))
+  program-error)
\ No newline at end of file
diff --git a/ansi-tests/ccase.lsp b/ansi-tests/ccase.lsp
index 76642a35f228a7c4fe31ad876a1bc94d873d97df..befd49b58e844bcd6baca8ecc23c1f5ed61e0863 100644
--- a/ansi-tests/ccase.lsp
+++ b/ansi-tests/ccase.lsp
@@ -197,3 +197,17 @@
 ;;; (deftest ccase.error.1
 ;;;  (classify-error (ccase))
 ;;;  program-error)
+
+(deftest ccase.error.1
+  (classify-error (funcall (macro-function 'ccase)))
+  program-error)
+
+(deftest ccase.error.2
+  (classify-error (funcall (macro-function 'ccase)
+			   '(ccase t)))
+  program-error)
+
+(deftest ccase.error.3
+  (classify-error (funcall (macro-function 'ccase)
+			   '(ccase t) nil nil))
+  program-error)
\ No newline at end of file
diff --git a/ansi-tests/cond.lsp b/ansi-tests/cond.lsp
index 1150887c2a7da605ac3563ab0db5873ef5046f2e..3394da41f72cfdafc40a0b50cbbf45d4f76131b6 100644
--- a/ansi-tests/cond.lsp
+++ b/ansi-tests/cond.lsp
@@ -80,3 +80,17 @@
      10
      (return-from done 'good)))
   good)
+
+(deftest cond.error.1
+  (classify-error (funcall (macro-function 'cond)))
+  program-error)
+
+(deftest cond.error.2
+  (classify-error (funcall (macro-function 'cond)
+			   '(cond)))
+  program-error)
+
+(deftest cond.error.3
+  (classify-error (funcall (macro-function 'cond)
+			   '(cond) nil nil))
+  program-error)
diff --git a/ansi-tests/ctypecase.lsp b/ansi-tests/ctypecase.lsp
index c786a7c121725064c1912dd65e86fc22257b5062..87348d6c5446e7d9b8bcdedd274e4b4ff1242560 100644
--- a/ansi-tests/ctypecase.lsp
+++ b/ansi-tests/ctypecase.lsp
@@ -81,9 +81,10 @@
 
 
 (deftest ctypecase.13
-  (ctypecase 'a
-	     (number 'bad)
-	     (#.(find-class 'symbol nil) 'good))
+  (let ((x 'a))
+    (ctypecase x
+	       (number 'bad)
+	       (#.(find-class 'symbol nil) 'good)))
   good)
 
 (deftest ctypecase.14
@@ -97,3 +98,17 @@
      (return-from done 'good)))
   good)
 
+(deftest ctypecase.error.1
+  (classify-error (funcall (macro-function 'ctypecase)))
+  program-error)
+
+(deftest ctypecase.error.2
+  (classify-error (funcall (macro-function 'ctypecase)
+			   '(ctypecase t)))
+  program-error)
+
+(deftest ctypecase.error.3
+  (classify-error (funcall (macro-function 'ctypecase)
+			   '(ctypecase t)
+			   nil nil))
+  program-error)
\ No newline at end of file
diff --git a/ansi-tests/defconstant.lsp b/ansi-tests/defconstant.lsp
index f0b132c24d9024fd1d4e3d5a2c6d6f398b31128d..af229580b8e0826889c6985206c2b70a133a9e0c 100644
--- a/ansi-tests/defconstant.lsp
+++ b/ansi-tests/defconstant.lsp
@@ -43,3 +43,19 @@
 ;;; 		    "This is a docstring"
 ;;; 		    "This is an unnecessary extra argument."))
 ;;;   program-error)
+
+(deftest defconstant.error.1
+  (classify-error (funcall (macro-function 'defconstant)))
+  program-error)
+
+(deftest defconstant.error.2
+  (classify-error (funcall (macro-function 'defconstant)
+			   '(defconstant +nonexistent-constant+ 0)))
+  program-error)
+
+(deftest defconstant.error.3
+  (classify-error (funcall (macro-function 'defconstant)
+			   '(defconstant +nonexistent-constant+ 0)
+			   nil nil))
+  program-error)
+			   
\ No newline at end of file
diff --git a/ansi-tests/define-compiler-macro.lsp b/ansi-tests/define-compiler-macro.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..4fbd03d07ec2315bbd4f63a96e59a544f5c8fb5d
--- /dev/null
+++ b/ansi-tests/define-compiler-macro.lsp
@@ -0,0 +1,23 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sun Apr 20 12:33:02 2003
+;;;; Contains: Tests of DEFINE-COMPILER-MACRO
+
+(in-package :cl-test)
+
+;;; Need to add non-error tests
+
+(deftest define-compiler-macro.error.1
+  (classify-error (funcall (macro-function 'define-compiler-macro)))
+  program-error)
+
+(deftest define-compiler-macro.error.2
+  (classify-error (funcall (macro-function 'define-compiler-macro)
+			   '(definee-compiler-macro nonexistent-function ())))
+  program-error)
+
+(deftest define-compiler-macro.error.3
+  (classify-error (funcall (macro-function 'define-compiler-macro)
+			   '(definee-compiler-macro nonexistent-function ())
+			   nil nil))
+  program-error)
diff --git a/ansi-tests/define-modify-macro.lsp b/ansi-tests/define-modify-macro.lsp
index e1d43814fa13aeebcb2c4c7bbd343ca1f8b78ad8..b3a5fb4baf1db5d8e56b370833c9199bfa41183b 100644
--- a/ansi-tests/define-modify-macro.lsp
+++ b/ansi-tests/define-modify-macro.lsp
@@ -81,3 +81,5 @@
 ;;; 		    "extra illegal argument"))
 ;;;   program-error)
 
+(def-macro-test define-modify-macro.error.1
+  (define-modify-macro nonexistent-modify-macro () foo))
diff --git a/ansi-tests/define-setf-expander.lsp b/ansi-tests/define-setf-expander.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..482713b5a93550767aaef2ea349f890b7a3fe71f
--- /dev/null
+++ b/ansi-tests/define-setf-expander.lsp
@@ -0,0 +1,11 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sun Apr 20 17:19:35 2003
+;;;; Contains: Tests of DEFINE-SETF-EXPANDER
+
+(in-package :cl-test)
+
+;;; Need to add non-error tests
+
+(def-macro-test define-setf-expander.error.1
+  (define-setf-expander nonexistent-access-fn (x)))
diff --git a/ansi-tests/define-symbol-macro.lsp b/ansi-tests/define-symbol-macro.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..9a02631c460b0a7e0370eba73f220ddb389de566
--- /dev/null
+++ b/ansi-tests/define-symbol-macro.lsp
@@ -0,0 +1,23 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sun Apr 20 12:55:05 2003
+;;;; Contains: Tests of DEFINE-SYMBOL-MACRO
+
+(in-package :cl-test)
+
+(deftest define-symbol-macro.error.1
+  (classify-error (funcall (macro-function 'define-symbol-macro)))
+  program-error)
+
+(deftest define-symbol-macro.error.2
+  (classify-error (funcall (macro-function 'define-symbol-macro)
+			   '(define-symbol-macro
+			      nonexistent-symbol-macro nil)))
+  program-error)
+
+(deftest define-symbol-macro.error.3
+  (classify-error (funcall (macro-function 'define-symbol-macro)
+			   '(define-symbol-macro
+			      nonexistent-symbol-macro nil)
+			   nil nil))
+  program-error)
diff --git a/ansi-tests/defmacro.lsp b/ansi-tests/defmacro.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..91f799a65e1133a6708d90e6121b54655c309b05
--- /dev/null
+++ b/ansi-tests/defmacro.lsp
@@ -0,0 +1,23 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sun Apr 20 12:35:24 2003
+;;;; Contains: Tests of DEFMACRO
+
+(in-package :cl-test)
+
+;;; Need to add non-error tests
+
+(deftest defmacro.error.1
+  (classify-error (funcall (macro-function 'defmacro)))
+  program-error)
+
+(deftest defmacro.error.2
+  (classify-error (funcall (macro-function 'defmacro)
+			   '(defmacro nonexistent-macro ())))
+  program-error)
+
+(deftest defmacro.error.3
+  (classify-error (funcall (macro-function 'defmacro)
+			   '(defmacro nonexistent-macro ())
+			   nil nil))
+  program-error)
diff --git a/ansi-tests/defparameter.lsp b/ansi-tests/defparameter.lsp
index 4cc3c908b9ed70e767fd7efd5aef1aaee54ce0c3..a285c3a621f033a5f7b8b9385316e0edfd79fd65 100644
--- a/ansi-tests/defparameter.lsp
+++ b/ansi-tests/defparameter.lsp
@@ -64,3 +64,19 @@
 ;;; 		    "documentation"
 ;;; 		    "illegal extra argument"))
 ;;;   program-error)
+
+(deftest defparameter.error.1
+  (classify-error (funcall (macro-function 'defparameter)))
+  program-error)
+
+(deftest defparameter.error.2
+  (classify-error (funcall (macro-function 'defparameter)
+			   '(defparameter *nonexistent-variable* nil)))
+  program-error)
+
+(deftest defparameter.error.3
+  (classify-error (funcall (macro-function 'defparameter)
+			   '(defparameter *nonexistent-variable* nil)
+			   nil nil))
+  program-error)
+
diff --git a/ansi-tests/defsetf.lsp b/ansi-tests/defsetf.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..0375c73bbeadc141244ff910041e6f4e8eb86693
--- /dev/null
+++ b/ansi-tests/defsetf.lsp
@@ -0,0 +1,11 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sun Apr 20 17:18:01 2003
+;;;; Contains: Tests of DEFSETF
+
+(in-package :cl-test)
+
+;;; Need to add non-error tests
+
+(def-macro-test defsetf.error.1 (defsetf nonexistent-access-fn
+				  nonexistent-update-fn))
diff --git a/ansi-tests/deftype.lsp b/ansi-tests/deftype.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..003d3bebdd4615e47051f4d0ffa755387a32eb84
--- /dev/null
+++ b/ansi-tests/deftype.lsp
@@ -0,0 +1,21 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sun Apr 20 12:56:56 2003
+;;;; Contains: Tests of DEFTYPE
+
+(in-package :cl-test)
+
+(deftest deftype.error.1
+  (classify-error (funcall (macro-function 'deftype)))
+  program-error)
+
+(deftest deftype.error.2
+  (classify-error (funcall (macro-function 'deftype)
+			   '(deftype nonexistent-type () nil)))
+  program-error)
+
+(deftest deftype.error.3
+  (classify-error (funcall (macro-function 'deftype)
+			   '(deftype nonexistent-type () nil)
+			   nil nil))
+  program-error)
diff --git a/ansi-tests/defun.lsp b/ansi-tests/defun.lsp
index 35fb6d0f834659416aa0ed115c16434878bf450e..2b9d90824e147825bffa8f006c6bb1d3f74170d1 100644
--- a/ansi-tests/defun.lsp
+++ b/ansi-tests/defun.lsp
@@ -5,15 +5,20 @@
 
 (in-package :cl-test)
 
-#|
 (deftest defun.error.1
-  (classify-error (defun))
+  (classify-error (funcall (macro-function 'defun)))
   program-error)
 
 (deftest defun.error.2
-  (classify-error (defun ignored-defun-name))
+  (classify-error (funcall (macro-function 'defun)
+			   '(defun nonexistent-function ())))
+  program-error)
+
+(deftest defun.error.3
+  (classify-error (funcall (macro-function 'defun)
+			   '(defun nonexistent-function ())
+			   nil nil))
   program-error)
-|#
 
 ;;; Tests for implicit blocks
 
diff --git a/ansi-tests/defvar.lsp b/ansi-tests/defvar.lsp
index 02aadc83a61ee78f8e77e967ae8ff663a09336dd..1e1d3c9c7a0d205fc0951c2c3ac9dd87d52f4d27 100644
--- a/ansi-tests/defvar.lsp
+++ b/ansi-tests/defvar.lsp
@@ -62,3 +62,19 @@
 ;;;   (classify-error (defvar *ignored-defvar-name* nil "documentation"
 ;;; 		    "illegal extra argument"))
 ;;;   program-error)
+
+(deftest defvar.error.1
+  (classify-error (funcall (macro-function 'defvar)))
+  program-error)
+
+(deftest defvar.error.2
+  (classify-error (funcall (macro-function 'defvar)
+			   '(defvar *nonexistent-variable* nil)))
+  program-error)
+
+(deftest defvar.error.3
+  (classify-error (funcall (macro-function 'defvar)
+			   '(defvar *nonexistent-variable* nil)
+			   nil nil))
+  program-error)
+
diff --git a/ansi-tests/destructuring-bind.lsp b/ansi-tests/destructuring-bind.lsp
index cf353d2b7eca8022d47d18cc6bd610caf8aec139..4f1980561947c5d710193634345fc880cb933740 100644
--- a/ansi-tests/destructuring-bind.lsp
+++ b/ansi-tests/destructuring-bind.lsp
@@ -129,3 +129,18 @@
 ;;;  (classify-error (destructuring-bind x))
 ;;;  program-error)
 
+(deftest destructuring-bind.error.7
+  (classify-error (funcall (macro-function 'destructuring-bind)))
+  program-error)
+
+(deftest destructuring-bind.error.8
+  (classify-error (funcall (macro-function 'destructuring-bind)
+			   '(destructuring-bind (a . b) '(1 2) nil)))
+  program-error)
+
+(deftest destructuring-bind.error.9
+  (classify-error (funcall (macro-function 'destructuring-bind)
+			   '(destructuring-bind (a . b) '(1 2) nil)
+			   nil nil))
+  program-error)
+
diff --git a/ansi-tests/ecase.lsp b/ansi-tests/ecase.lsp
index 72c377151a740fc8885d50f9be05f1b0c1667948..bc41a5ba1a6c22dc635742d04589f105b0d3a290 100644
--- a/ansi-tests/ecase.lsp
+++ b/ansi-tests/ecase.lsp
@@ -158,3 +158,18 @@
      10
      (return-from done 'good)))
   good)
+
+(deftest ecase.error.1
+  (classify-error (funcall (macro-function 'ecase)))
+  program-error)
+
+(deftest ecase.error.2
+  (classify-error (funcall (macro-function 'ecase)
+			   '(ecase t)))
+  program-error)
+
+(deftest ecase.error.3
+  (classify-error (funcall (macro-function 'ecase)
+			   '(ecase t)
+			   nil nil))
+  program-error)
diff --git a/ansi-tests/etypecase.lsp b/ansi-tests/etypecase.lsp
index 189cbde75bb06a42a59676aea4a81faea5db4bee..67bf6d1e1980dd961d24b51f0617a3d10b2e4919 100644
--- a/ansi-tests/etypecase.lsp
+++ b/ansi-tests/etypecase.lsp
@@ -70,4 +70,17 @@
      (return 'good)))
   good)
 
-
+(deftest etypecase.error.1
+  (classify-error (funcall (macro-function 'etypecase)))
+  program-error)
+
+(deftest etypecase.error.2
+  (classify-error (funcall (macro-function 'etypecase)
+			   '(etypecase t)))
+  program-error)
+
+(deftest etypecase.error.3
+  (classify-error (funcall (macro-function 'etypecase)
+			   '(etypecase t)
+			   nil nil))
+  program-error)
diff --git a/ansi-tests/iteration.lsp b/ansi-tests/iteration.lsp
index 5de230e75700a881f076bf8555ab361713fa594b..eb17e088998a83a73cc10353096af261e4bc188b 100644
--- a/ansi-tests/iteration.lsp
+++ b/ansi-tests/iteration.lsp
@@ -131,6 +131,9 @@
 	      (push #'(lambda () i) x))))
   (5 5 5 5 5))
 
+(def-macro-test do.error.1
+  (do ((i 0 (1+ i))) ((= i 5) 'a)))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;;;; Tests of DO*
@@ -250,6 +253,9 @@
 	      (push #'(lambda () i) x))))
   (5 5 5 5 5))
 
+(def-macro-test do*.error.1
+  (do* ((i 0 (1+ i))) ((= i 5) 'a)))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;;;; Tests for DOLIST
@@ -361,6 +367,9 @@
       (when (eq e 'c) (return x))))
   (c b a))
 
+(def-macro-test dolist.error.1
+  (dolist (x nil)))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;;; Tests for DOTIMES
@@ -491,6 +500,8 @@
     y)
   (3 2 1 0))
 
+(def-macro-test dotimes.error.1
+  (dotimes (i 10)))
 
 
 
diff --git a/ansi-tests/lambda.lsp b/ansi-tests/lambda.lsp
index 07d830eae07ea2c3cb95dafb7c96353e0699631d..20966292069067a3166c2802cdd3b51aa40ff193 100644
--- a/ansi-tests/lambda.lsp
+++ b/ansi-tests/lambda.lsp
@@ -234,19 +234,19 @@
    :d 40 :allow-other-keys nil :a 1 :b 2 :c 20)
   (nil 1 2))
 
-(deftest lambda.48
+(deftest lambda.49
   ((lambda (&key a b allow-other-keys &allow-other-keys)
      (list allow-other-keys a b))
    :d 40 :a 1 :b 2 :c 20)
   (nil 1 2))
 
-(deftest lambda.49
+(deftest lambda.50
   ((lambda (&key a b ((:allow-other-keys aok)))
      (list aok a b))
    :d 40 :a 1 :allow-other-keys t :b 2 :c 20)
   (t 1 2))
 
-(deftest lambda.50
+(deftest lambda.51
   ((lambda (&key &allow-other-keys)) :a 1 :b 2 :c 3)
   nil)
 
@@ -261,4 +261,14 @@
   (funcall (eval (macroexpand '(lambda () 10))))
   10)
 
-  
\ No newline at end of file
+(deftest lambda.error.1
+  (classify-error (funcall (macro-function 'lambda)))
+  program-error)
+
+(deftest lambda.error.2
+  (classify-error (funcall (macro-function 'lambda) '(lambda ())))
+  program-error)
+
+(deftest lambda.error.3
+  (classify-error (funcall (macro-function 'lambda) '(lambda ()) nil nil))
+  program-error)
diff --git a/ansi-tests/load-data-and-control-flow.lsp b/ansi-tests/load-data-and-control-flow.lsp
index d4ea1dab8b2b302c6bf4b3e4a907115fe01b95e6..e5bd1b60fdc730453bf489de122040eac253917c 100644
--- a/ansi-tests/load-data-and-control-flow.lsp
+++ b/ansi-tests/load-data-and-control-flow.lsp
@@ -2,6 +2,13 @@
 
 (load "data-and-control-flow.lsp")
 (load "places.lsp")
+(load "psetq.lsp")
+(load "psetf.lsp")
+(load "shiftf.lsp")
+(load "rotatef.lsp")
+(load "return.lsp")
+(load "defsetf.lsp")
+(load "define-setf-expander.lsp")
 
 (load "and.lsp")
 (load "apply.lsp")
diff --git a/ansi-tests/load-eval-and-compile.lsp b/ansi-tests/load-eval-and-compile.lsp
index 4229d557f1c12b31a85571662edda0db8a353861..64b64aa39b424a1dc14425d56b2d50aa4394cba3 100644
--- a/ansi-tests/load-eval-and-compile.lsp
+++ b/ansi-tests/load-eval-and-compile.lsp
@@ -6,3 +6,6 @@
 (load "constantp.lsp")
 (load "lambda.lsp")
 (load "eval-when.lsp")
+(load "define-compiler-macro.lsp")
+(load "define-symbol-macro.lsp")
+(load "defmacro.lsp")
diff --git a/ansi-tests/load-types-and-class.lsp b/ansi-tests/load-types-and-class.lsp
index 3ad82e4f9b2638ac57dfaf37bfc53bd9bbafc64b..fc6cd38d94b4b7d6c76df1560a53b6e17617242e 100644
--- a/ansi-tests/load-types-and-class.lsp
+++ b/ansi-tests/load-types-and-class.lsp
@@ -13,3 +13,5 @@
 (load "subtypep-eql.lsp")
 (load "subtypep-array.lsp")
 
+(load "deftype.lsp")
+
diff --git a/ansi-tests/loop.lsp b/ansi-tests/loop.lsp
index 2a362faa6b7d9db1efc697fb56e20d2e511d8a30..026a541ae32660fb98a54fce57f26d2204f89706 100644
--- a/ansi-tests/loop.lsp
+++ b/ansi-tests/loop.lsp
@@ -51,3 +51,36 @@
      (incf i)
      (push 'a x))))
   (a a a a))
+
+;;; Loop errors
+
+(def-macro-test loop.error.1 (loop))
+
+(deftest loop-finish.error.1
+  (block done
+    (loop
+     for i from 1 to 10
+     do (macrolet
+	    ((%m (&environment env)
+		 (let ((mfn (macro-function 'loop-finish env)))
+		   (cond
+		    ((not mfn) '(return-from done :fail1))
+		    ((not (eqt (eval `(classify-error (funcall ,mfn)))
+			       'program-error))
+		     '(return-from done :fail2))
+		    ((not (eqt (eval `(classify-error (funcall ,mfn
+						      '(loop-finish))))
+			       'program-error))
+		     '(return-from done :fail3))
+		       
+		    ((not (eqt (eval `(classify-error (funcall ,mfn
+							       '(loop-finish)
+							       nil nil)))
+			       'program-error))
+		     '(return-from done :fail4))
+		    (t '(return-from done :good))))))
+	  (%m))))
+  :good)
+
+		       
+		   
\ No newline at end of file
diff --git a/ansi-tests/macrolet.lsp b/ansi-tests/macrolet.lsp
index d470210821e296471df1ceb1d3fbb964bb438527..8c2b804ca3d810c17201c3b93b1163ecbb5ae647 100644
--- a/ansi-tests/macrolet.lsp
+++ b/ansi-tests/macrolet.lsp
@@ -189,7 +189,7 @@
   (a 2 3)
   (a b c))
 
-(deftest macrolet.22
+(deftest macrolet.22a
   (macrolet ((%m (x &optional ((y z) '(2 3) y-z-p))
 		 `(quote (,x ,y ,z ,y-z-p))))
     (values
@@ -339,6 +339,14 @@
     (%m 1 2))
   (%m 1 2 1 2))
 
+;;; Macro names are shadowed by local functions
+
+(deftest macrolet.37
+  (macrolet ((%f () :bad))
+    (flet ((%f () :good))
+      (%f)))
+  :good)
+
 ;;; Symbol-macrolet tests
 
 (deftest symbol-macrolet.1
diff --git a/ansi-tests/multiple-value-bind.lsp b/ansi-tests/multiple-value-bind.lsp
index 6ffc1b8f3a953803affa11928111786fe3a01da4..a6547568487a313c569c901cd3c956d623064303 100644
--- a/ansi-tests/multiple-value-bind.lsp
+++ b/ansi-tests/multiple-value-bind.lsp
@@ -71,4 +71,18 @@
 ;;;  (classify-error (multiple-value-bind (a b c)))
 ;;;  program-error)
 
-  
\ No newline at end of file
+(deftest multiple-value-bind.error.1
+  (classify-error (funcall (macro-function 'multiple-value-bind)))
+  program-error)
+  
+(deftest multiple-value-bind.error.2
+  (classify-error (funcall (macro-function 'multiple-value-bind)
+			   '(multiple-value-bind nil nil)))
+  program-error)
+
+(deftest multiple-value-bind.error.3
+  (classify-error (funcall (macro-function 'multiple-value-bind)
+			   '(multiple-value-bind nil nil)
+			   nil nil))
+  program-error)
+  
diff --git a/ansi-tests/multiple-value-list.lsp b/ansi-tests/multiple-value-list.lsp
index cdb32778b4ce9d50cfb2fe95ded944e9997212d2..25e42c588d1bea881a32efa504e0be724b13a8c6 100644
--- a/ansi-tests/multiple-value-list.lsp
+++ b/ansi-tests/multiple-value-list.lsp
@@ -35,3 +35,18 @@
   (classify-error (multiple-value-list 'a 'b))
   program-error)
 |#
+
+(deftest multiple-value-list.error.1
+  (classify-error (funcall (macro-function 'multiple-value-list)))
+  program-error)
+  
+(deftest multiple-value-list.error.2
+  (classify-error (funcall (macro-function 'multiple-value-list)
+			   '(multiple-value-list nil)))
+  program-error)
+
+(deftest multiple-value-list.error.3
+  (classify-error (funcall (macro-function 'multiple-value-list)
+			   '(multiple-value-list nil)
+			   nil nil))
+  program-error)
\ No newline at end of file
diff --git a/ansi-tests/multiple-value-setq.lsp b/ansi-tests/multiple-value-setq.lsp
index 088ff88c794dec3d1912302d654caebb8945438f..fede5eeaac2c87c720962c63fd3eb254c5c2ecf6 100644
--- a/ansi-tests/multiple-value-setq.lsp
+++ b/ansi-tests/multiple-value-setq.lsp
@@ -107,3 +107,18 @@
      collect (list i form)))
   nil)
 
+(deftest multiple-value-setq.error.1
+  (classify-error (funcall (macro-function 'multiple-value-setq)))
+  program-error)
+  
+(deftest multiple-value-setq.error.2
+  (classify-error (funcall (macro-function 'multiple-value-setq)
+			   '(multiple-value-setq nil nil)))
+  program-error)
+
+(deftest multiple-value-setq.error.3
+  (classify-error (funcall (macro-function 'multiple-value-setq)
+			   '(multiple-value-setq nil nil)
+			   nil nil))
+  program-error)
+  
\ No newline at end of file
diff --git a/ansi-tests/nth-value.lsp b/ansi-tests/nth-value.lsp
index 1d825ad7a330a032ed24e4aa932acef3bcbe66a7..8c49e75f7a12ab1adf0e17db20c4e0b5afcbec27 100644
--- a/ansi-tests/nth-value.lsp
+++ b/ansi-tests/nth-value.lsp
@@ -34,3 +34,19 @@
 		(progn (setf y (incf i)) (values 'a 'b 'c 'd 'e 'f 'g)))
      i x y))
   d 2 1 2)
+
+(deftest nth-value.error.1
+  (classify-error (funcall (macro-function 'nth-value)))
+  program-error)
+  
+(deftest nth-value.error.2
+  (classify-error (funcall (macro-function 'nth-value)
+			   '(nth-value 1 '(a b c))))
+  program-error)
+
+(deftest nth-value.error.3
+  (classify-error (funcall (macro-function 'nth-value)
+			   '(nth-value 1 '(a b c))
+			   nil nil))
+  program-error)
+  
diff --git a/ansi-tests/or.lsp b/ansi-tests/or.lsp
index 4b7d746226d9cf8f2878a691d7eed0a5719c7e4e..d9d965b8369ddb81c910cc9278dc0756f142cb90 100644
--- a/ansi-tests/or.lsp
+++ b/ansi-tests/or.lsp
@@ -41,8 +41,19 @@
   (or (values nil 1 2) (values 1 nil 2))
   1 nil 2)
 
-
-
+(deftest or.error.1
+  (classify-error (funcall (macro-function 'or)))
+  program-error)
+
+(deftest or.error.2
+  (classify-error (funcall (macro-function 'or)
+			   '(or)))
+  program-error)
+
+(deftest or.error.3
+  (classify-error (funcall (macro-function 'or)
+			   '(or) nil nil))
+  program-error)
 
   
 
diff --git a/ansi-tests/packages-10.lsp b/ansi-tests/packages-10.lsp
index d8ff8979063353a90326b2b4cb9ae09630ff2e3a..306b533310072ccbc31f5e480dd93acb4db4cbc2 100644
--- a/ansi-tests/packages-10.lsp
+++ b/ansi-tests/packages-10.lsp
@@ -119,3 +119,6 @@
 	   (format t "Error ~S on package ~S~%" c p)
 	   t)))
   0)
+
+(def-macro-test with-package-iterator.error.1
+  (with-package-iterator (x "CL" :external) nil))
diff --git a/ansi-tests/packages-13.lsp b/ansi-tests/packages-13.lsp
index 4add73c782ec5d64dea25145f659aa76d32f357f..4cba3327f7c81d1da7db0fe703304448e3eb3354 100644
--- a/ansi-tests/packages-13.lsp
+++ b/ansi-tests/packages-13.lsp
@@ -50,3 +50,6 @@
      (package-error () 'package-error)
      (error (c) c)))
   package-error)
+
+(def-macro-test in-package.error.1
+  (in-package :cl-test))
diff --git a/ansi-tests/packages-16.lsp b/ansi-tests/packages-16.lsp
index 44a052a6d5217ed3d90539528fca471eae83e000..56a409c4e82b2aed4391dfd49e56c58d2a0e732d 100644
--- a/ansi-tests/packages-16.lsp
+++ b/ansi-tests/packages-16.lsp
@@ -612,3 +612,6 @@
 	(list (%do-it% args)
 	      (%do-it% (reverse args))))))
   (success success))
+
+(def-macro-test defpackage.error.1
+  (defpackage :nonexistent-package (:use)))
\ No newline at end of file
diff --git a/ansi-tests/packages-17.lsp b/ansi-tests/packages-17.lsp
index 2555f7b8c1ed316f8da5deb085695279db9ee8b9..52a9994351830ee5ae43309fca2512e57f0005dd 100644
--- a/ansi-tests/packages-17.lsp
+++ b/ansi-tests/packages-17.lsp
@@ -140,6 +140,14 @@
    (error (c) c))
   (NIL (DS1:B T)))
 
+(def-macro-test do-symbols.error.1
+  (do-symbols (x "CL")))
 
+(def-macro-test do-external-symbols.error.1
+  (do-external-symbols (x "CL")))
+
+(def-macro-est do-all-symbols.error.1
+  (do-all-symbols (x)))
+
+;;; Need to add DO-ALL-SYMBOLS tests
 
-  
diff --git a/ansi-tests/places.lsp b/ansi-tests/places.lsp
index caf7815f80fd7f75f54e7f216d11a1e623b4a7c3..497cee5c9f66f648fe23efa3cca4df479706edbf 100644
--- a/ansi-tests/places.lsp
+++ b/ansi-tests/places.lsp
@@ -6,14 +6,15 @@
 (in-package :cl-test)
 
 ;;; Section 5.1.1.1
-(deftest setf-order
+
+(deftest setf.order.1
   (let ((x (vector nil nil nil nil))
 	(i 0))
     (setf (aref x (incf i)) (incf i))
     (values x i))
   #(nil 2 nil nil) 2)
 
-(deftest setf-order.2
+(deftest setf.order.2
   (let ((x (vector nil nil nil nil))
 	(i 0))
     (setf (aref x (incf i)) (incf i)
@@ -21,47 +22,7 @@
     (values x i))
   #(nil 2 nil 13) 13)
 
-(deftest push-order
-  (let ((x (vector nil nil nil nil))
-	(y (vector 'a 'b 'c 'd))
-	(i 1))
-    (push (aref y (incf i)) (aref x (incf i)))
-    (values x y i))
-  #(nil nil nil (c))
-  #(a b c d)
-  3)
-
-(deftest pushnew-order
-  (let ((x (vector nil nil nil nil))
-	(y (vector 'a 'b 'c 'd))
-	(i 1))
-    (pushnew (aref y (incf i)) (aref x (incf i)))
-    (values x y i))
-  #(nil nil nil (c))
-  #(a b c d)
-  3)
-
-(deftest pushnew-order.2
-  (let ((x (vector nil nil nil nil nil))
-	(y (vector 'a 'b 'c 'd 'e))
-	(i 1))
-    (pushnew (aref y (incf i)) (aref x (incf i))
-	     :test (progn (incf i) #'eql))
-    (values x y i))
-  #(nil nil nil (c) nil)
-  #(a b c d e)
-  4)
-
-(deftest remf-order
-  (let ((x  (copy-seq #(nil :a :b)))
-	(pa (vector (list :a 1) (list :b 2) (list :c 3) (list :d 4)))
-	(i 0))
-    (values
-     (not (remf (aref pa (incf i)) (aref x (incf i))))
-     pa))
-  nil #((:a 1) nil (:c 3) (:d 4)))
-
-(deftest incf-order
+(deftest incf.order.1
   (let ((x (copy-seq #(0 0 0 0 0)))
 	(i 1))
     (values
@@ -69,7 +30,7 @@
      x i))
   3 #(0 0 3 0 0) 3)
 
-(deftest decf-order
+(deftest decf.order.1
   (let ((x (copy-seq #(0 0 0 0 0)))
 	(i 1))
     (values
@@ -77,60 +38,7 @@
      x i))
   -3 #(0 0 -3 0 0) 3)
 
-(deftest shiftf-order.1
-  (let ((x (vector 'a 'b 'c 'd 'e))
-	(i 2))
-    (values (shiftf (aref x (incf i)) (incf i)) x i))
-  d #(a b c 4 e) 4)
-    
-(deftest shiftf-order.2
-  (let ((x (vector 'a 'b 'c 'd 'e 'f 'g 'h))
-	(i 2))
-    (values (shiftf (aref x (incf i)) (aref x (incf i)) (incf i)) x i))
-  d #(a b c e 5 f g h) 5)
-
-(deftest rotatef-order.1
-  (let ((x (vector 'a 'b 'c 'd 'e 'f))
-	(i 2))
-    (values
-     (rotatef (aref x (incf i)) (aref x (incf i)))
-     x i))
-  nil
-  #(a b c e d f)
-  4)
-
-(deftest rotatef-order.2
-  (let ((x (vector 'a 'b 'c 'd 'e 'f))
-	(i 2))
-    (values
-     (rotatef (aref x (incf i)) (aref x (incf i)) (aref x (incf i)))
-     x i))
-  nil
-  #(a b c e f d)
-  5)
-    
-(deftest psetf-order
-  (let ((x (vector nil nil nil nil))
-	(i 0))
-    (psetf (aref x (incf i)) (incf i))
-    (values x i))
-  #(nil 2 nil nil) 2)
-
-(deftest psetf-order.2
-  (let ((x (vector nil nil nil nil))
-	(i 0))
-    (psetf (aref x (incf i)) (incf i)
-	   (aref x (incf i)) (incf i 10))
-    (values x i))
-  #(nil 2 nil 13) 13)
-
-(deftest pop-order
-  (let ((x (vector '(a b) '(c d) '(e f)))
-	(i 0))
-    (values (pop (aref x (incf i))) x i))
-  c #((a b) (d) (e f)) 1)
-
-
+   
 ;;; Section 5.1.2.1
 (deftest setf-var
   (let ((x nil))
@@ -336,132 +244,3 @@
 (deftest setf.4
   (let (x) (setf x (values 1 2)))
   1)
-
-;;; Tests of PSETQ
-
-(deftest psetq.1
-  (psetq)
-  nil)
-
-(deftest psetq.2
-  (let ((x 0))
-    (values (psetq x 1) x))
-  nil 1)
-
-(deftest psetq.3
-  (let ((x 0) (y 1))
-    (values (psetq x y y x) x y))
-  nil 1 0)
-
-(deftest psetq.4
-  (let ((x 0))
-    (values
-     (symbol-macrolet ((x y))
-       (let ((y 1))
-	 (psetq x 2)
-	 y))
-     x))
-  2 0)
-
-(deftest psetq.5
-  (let ((w (list nil)))
-    (values
-     (symbol-macrolet ((x (car w)))
-       (psetq x 2))
-     w))
-  nil (2))
-
-(deftest psetq.6
-  (let ((c 0) x y)
-    (psetq x (incf c)
-	   y (incf c))
-    (values c x y))
-  2 1 2)
-
-;;; The next test is a PSETQ that is equivalent to a PSETF
-;;; See PSETF.7 for comments related to this test.
-
-(deftest psetq.7
-  (symbol-macrolet ((x (aref a (incf i)))
-		    (y (aref a (incf i))))
-    (let ((a (copy-seq #(0 1 2 3 4 5 6 7 8 9)))
-	  (i 0))
-      (psetq x (aref a (incf i))
-	     y (aref a (incf i)))
-      (values a i)))
-  #(0 2 2 4 4 5 6 7 8 9)
-  4)
-
-;;; Tests of PSETF
-
-(deftest psetf.1
-  (psetf)
-  nil)
-
-(deftest psetf.2
-  (let ((x 0))
-    (values (psetf x 1) x))
-  nil 1)
-
-(deftest psetf.3
-  (let ((x 0) (y 1))
-    (values (psetf x y y x) x y))
-  nil 1 0)
-
-(deftest psetf.4
-  (let ((x 0))
-    (values
-     (symbol-macrolet ((x y))
-       (let ((y 1))
-	 (psetf x 2)
-	 y))
-     x))
-  2 0)
-
-(deftest psetf.5
-  (let ((w (list nil)))
-    (values
-     (symbol-macrolet ((x (car w)))
-       (psetf x 2))
-     w))
-  nil (2))
-
-(deftest psetf.6
-  (let ((c 0) x y)
-    (psetf x (incf c)
-	   y (incf c))
-    (values c x y))
-  2 1 2)
-
-;;; According to the standard, the forms to be assigned and
-;;; the subforms in the places to be assigned to are evaluated
-;;; from left to right.  Therefore, PSETF.7 and PSETF.8 should
-;;; do the same thing to A as PSETF.9 does.
-;;; (See the page for PSETF)
-
-(deftest psetf.7
-  (symbol-macrolet ((x (aref a (incf i)))
-		    (y (aref a (incf i))))
-    (let ((a (copy-seq #(0 1 2 3 4 5 6 7 8 9)))
-	  (i 0))
-      (psetf x (aref a (incf i))
-	     y (aref a (incf i)))
-      (values a i)))
-  #(0 2 2 4 4 5 6 7 8 9)
-  4)
-
-(deftest psetf.8
-  (let ((a (copy-seq #(0 1 2 3 4 5 6 7 8 9)))
-	(i 0))
-    (psetf (aref a (incf i)) (aref a (incf i))
-	   (aref a (incf i)) (aref a (incf i)))
-    (values a i))
-  #(0 2 2 4 4 5 6 7 8 9)
-  4)
-
-(deftest psetf.9
-  (let ((a (copy-seq #(0 1 2 3 4 5 6 7 8 9))))
-    (psetf (aref a 1) (aref a 2)
-	   (aref a 3) (aref a 4))
-    a)
-  #(0 2 2 4 4 5 6 7 8 9))
diff --git a/ansi-tests/pop.lsp b/ansi-tests/pop.lsp
index f6b7cc26b11ab4344b3885d588d1e9a4b9cd983f..f58d8f065ebd2ea9027a285e95b07cafe3c0276b 100644
--- a/ansi-tests/pop.lsp
+++ b/ansi-tests/pop.lsp
@@ -35,4 +35,6 @@
      (pop x)))
   c)
 
+(def-macro-test pop.error.1 (pop x))
+
 ;;; Need to add tests of POP vs. various accessors
diff --git a/ansi-tests/prog.lsp b/ansi-tests/prog.lsp
index 8b508f2864a24d0f58b0c0b7576f23604fb547c2..737fb89381beadd5eb70768946b419d359bfde16 100644
--- a/ansi-tests/prog.lsp
+++ b/ansi-tests/prog.lsp
@@ -71,6 +71,7 @@
 	(return 'bad))
   2)
 
+(def-macro-test prog.error.1 (prog nil))
 
 ;;; Tests of PROG*
 
@@ -140,8 +141,4 @@
 	(return 'bad))
   2)
 
-    
-
-
-
-
+(def-macro-test prog*.error.1 (prog* nil))
diff --git a/ansi-tests/prog1.lsp b/ansi-tests/prog1.lsp
index 979b2c6cbbad8fc4ed7e9abefdb3cb31f58284c5..57fe441577906f9fbc515030f3ab9d79d3fcc318 100644
--- a/ansi-tests/prog1.lsp
+++ b/ansi-tests/prog1.lsp
@@ -35,3 +35,5 @@
      10
      (return 'good)))
   good)
+
+(def-macro-test prog1.error.1 (prog1 nil))
diff --git a/ansi-tests/prog2.lsp b/ansi-tests/prog2.lsp
index c3659fcab203043fc90df9d67c25d9c96c44779e..5da6e28a63223a94b3ef0193d3181e336752577c 100644
--- a/ansi-tests/prog2.lsp
+++ b/ansi-tests/prog2.lsp
@@ -45,4 +45,4 @@
      (return 'good)))
   good)
 
-
+(def-macro-test prog2.error.1 (prog2 nil nil))
diff --git a/ansi-tests/psetf.lsp b/ansi-tests/psetf.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..b34d5be1529628a4e6df32e8d52a021549300599
--- /dev/null
+++ b/ansi-tests/psetf.lsp
@@ -0,0 +1,95 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sun Apr 20 15:38:30 2003
+;;;; Contains: Tests of PSETF
+
+(in-package :cl-test)
+
+(deftest psetf.order.1
+  (let ((x (vector nil nil nil nil))
+	(i 0))
+    (psetf (aref x (incf i)) (incf i))
+    (values x i))
+  #(nil 2 nil nil) 2)
+
+(deftest psetf.order.2
+  (let ((x (vector nil nil nil nil))
+	(i 0))
+    (psetf (aref x (incf i)) (incf i)
+	   (aref x (incf i)) (incf i 10))
+    (values x i))
+  #(nil 2 nil 13) 13)
+
+(deftest psetf.1
+  (psetf)
+  nil)
+
+(deftest psetf.2
+  (let ((x 0))
+    (values (psetf x 1) x))
+  nil 1)
+
+(deftest psetf.3
+  (let ((x 0) (y 1))
+    (values (psetf x y y x) x y))
+  nil 1 0)
+
+(deftest psetf.4
+  (let ((x 0))
+    (values
+     (symbol-macrolet ((x y))
+       (let ((y 1))
+	 (psetf x 2)
+	 y))
+     x))
+  2 0)
+
+(deftest psetf.5
+  (let ((w (list nil)))
+    (values
+     (symbol-macrolet ((x (car w)))
+       (psetf x 2))
+     w))
+  nil (2))
+
+(deftest psetf.6
+  (let ((c 0) x y)
+    (psetf x (incf c)
+	   y (incf c))
+    (values c x y))
+  2 1 2)
+
+;;; According to the standard, the forms to be assigned and
+;;; the subforms in the places to be assigned to are evaluated
+;;; from left to right.  Therefore, PSETF.7 and PSETF.8 should
+;;; do the same thing to A as PSETF.9 does.
+;;; (See the page for PSETF)
+
+(deftest psetf.7
+  (symbol-macrolet ((x (aref a (incf i)))
+		    (y (aref a (incf i))))
+    (let ((a (copy-seq #(0 1 2 3 4 5 6 7 8 9)))
+	  (i 0))
+      (psetf x (aref a (incf i))
+	     y (aref a (incf i)))
+      (values a i)))
+  #(0 2 2 4 4 5 6 7 8 9)
+  4)
+
+(deftest psetf.8
+  (let ((a (copy-seq #(0 1 2 3 4 5 6 7 8 9)))
+	(i 0))
+    (psetf (aref a (incf i)) (aref a (incf i))
+	   (aref a (incf i)) (aref a (incf i)))
+    (values a i))
+  #(0 2 2 4 4 5 6 7 8 9)
+  4)
+
+(deftest psetf.9
+  (let ((a (copy-seq #(0 1 2 3 4 5 6 7 8 9))))
+    (psetf (aref a 1) (aref a 2)
+	   (aref a 3) (aref a 4))
+    a)
+  #(0 2 2 4 4 5 6 7 8 9))
+
+(def-macro-test psetf.error.1 (psetf))
diff --git a/ansi-tests/psetq.lsp b/ansi-tests/psetq.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..c5f52db456d0adaf2fc43df9f4a887f74e497ccf
--- /dev/null
+++ b/ansi-tests/psetq.lsp
@@ -0,0 +1,74 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sun Apr 20 15:37:20 2003
+;;;; Contains: Tests of PSETQ
+
+(in-package :cl-test)
+
+(deftest psetq.1
+  (psetq)
+  nil)
+
+(deftest psetq.2
+  (let ((x 0))
+    (values (psetq x 1) x))
+  nil 1)
+
+(deftest psetq.3
+  (let ((x 0) (y 1))
+    (values (psetq x y y x) x y))
+  nil 1 0)
+
+(deftest psetq.4
+  (let ((x 0))
+    (values
+     (symbol-macrolet ((x y))
+       (let ((y 1))
+	 (psetq x 2)
+	 y))
+     x))
+  2 0)
+
+(deftest psetq.5
+  (let ((w (list nil)))
+    (values
+     (symbol-macrolet ((x (car w)))
+       (psetq x 2))
+     w))
+  nil (2))
+
+(deftest psetq.6
+  (let ((c 0) x y)
+    (psetq x (incf c)
+	   y (incf c))
+    (values c x y))
+  2 1 2)
+
+;;; The next test is a PSETQ that is equivalent to a PSETF
+;;; See PSETF.7 for comments related to this test.
+
+(deftest psetq.7
+  (symbol-macrolet ((x (aref a (incf i)))
+		    (y (aref a (incf i))))
+    (let ((a (copy-seq #(0 1 2 3 4 5 6 7 8 9)))
+	  (i 0))
+      (psetq x (aref a (incf i))
+	     y (aref a (incf i)))
+      (values a i)))
+  #(0 2 2 4 4 5 6 7 8 9)
+  4)
+
+(deftest psetq.error.1
+  (classify-error (funcall (macro-function 'psetq)))
+  program-error)
+
+(deftest psetq.error.2
+  (classify-error (funcall (macro-function 'psetq)
+			   '(psetq)))
+  program-error)
+
+(deftest psetq.error.3
+  (classify-error (funcall (macro-function 'psetq)
+			   '(psetq)
+			   nil nil))
+  program-error)
diff --git a/ansi-tests/push.lsp b/ansi-tests/push.lsp
index ee99f99de63f4cf9e4d3799fef164b5172a39807..41e8f90729702d32e4fff94bfba55e81ebd19614 100644
--- a/ansi-tests/push.lsp
+++ b/ansi-tests/push.lsp
@@ -35,4 +35,16 @@
      i a b))
   (z) ((z)) 2 1 2)
 
+(deftest push.order.2
+  (let ((x (vector nil nil nil nil))
+	(y (vector 'a 'b 'c 'd))
+	(i 1))
+    (push (aref y (incf i)) (aref x (incf i)))
+    (values x y i))
+  #(nil nil nil (c))
+  #(a b c d)
+  3)
+
+(def-macro-test push.error.1 (push x y))
+
 ;;; Need to add push vs. various accessors
diff --git a/ansi-tests/pushnew.lsp b/ansi-tests/pushnew.lsp
index 745487514f89ba13ab8d16c128a95bc32d92fa0c..b35ae8be34d363fa95d9fa7eb15d9c92e709e371 100644
--- a/ansi-tests/pushnew.lsp
+++ b/ansi-tests/pushnew.lsp
@@ -5,8 +5,6 @@
 
 (in-package :cl-test)
 
-;;; See also places.lsp
-
 (deftest pushnew.1
   (let ((x nil))
     (let ((y (pushnew 'a x)))
@@ -156,6 +154,27 @@
   (a b c) (a b c)
   3 1 3 2)
 
+(deftest pushnew.order.1
+  (let ((x (vector nil nil nil nil))
+	(y (vector 'a 'b 'c 'd))
+	(i 1))
+    (pushnew (aref y (incf i)) (aref x (incf i)))
+    (values x y i))
+  #(nil nil nil (c))
+  #(a b c d)
+  3)
+
+(deftest pushnew.order.2
+  (let ((x (vector nil nil nil nil nil))
+	(y (vector 'a 'b 'c 'd 'e))
+	(i 1))
+    (pushnew (aref y (incf i)) (aref x (incf i))
+	     :test (progn (incf i) #'eql))
+    (values x y i))
+  #(nil nil nil (c) nil)
+  #(a b c d e)
+  4)
+
 (deftest pushnew.error.1
   (classify-error
    (let ((x '(a b)))
@@ -173,3 +192,5 @@
    (let ((x '(a b)))
      (pushnew 'c x :key #'cons)))
   program-error)
+
+(def-macro-test pushnew.error.4 (pushnew x y))
diff --git a/ansi-tests/remf.lsp b/ansi-tests/remf.lsp
index c3ef3aa1f52ec8ddfc5bded7c8a2fb8753db7a7a..6a1af54116ce2ac4dffcdeca1328c79f889c10ef 100644
--- a/ansi-tests/remf.lsp
+++ b/ansi-tests/remf.lsp
@@ -41,3 +41,13 @@
      i x y))
   t (a b e f) 2 1 2)
 
+(deftest remf.order.2
+  (let ((x  (copy-seq #(nil :a :b)))
+	(pa (vector (list :a 1) (list :b 2) (list :c 3) (list :d 4)))
+	(i 0))
+    (values
+     (not (remf (aref pa (incf i)) (aref x (incf i))))
+     pa))
+  nil #((:a 1) nil (:c 3) (:d 4)))
+
+(def-macro-test remf.error.1 (remf x 'a))
diff --git a/ansi-tests/return.lsp b/ansi-tests/return.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..6cff4030ff39eb252650189056f6264f8060c192
--- /dev/null
+++ b/ansi-tests/return.lsp
@@ -0,0 +1,22 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sun Apr 20 16:00:32 2003
+;;;; Contains: Tests of RETURN
+
+(in-package :cl-test)
+
+(deftest return.error.1
+  (classify-error (funcall (macro-function 'return)))
+  program-error)
+  
+(deftest return.error.2
+  (classify-error (funcall (macro-function 'return)
+			   '(return nil)))
+  program-error)
+
+(deftest return.error.3
+  (classify-error (funcall (macro-function 'return)
+			   '(return nil)
+			   nil nil))
+  program-error)
+  
diff --git a/ansi-tests/rotatef.lsp b/ansi-tests/rotatef.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..0743f96b2e2972db1ac0ac9afc21645e1d4cc36a
--- /dev/null
+++ b/ansi-tests/rotatef.lsp
@@ -0,0 +1,28 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sun Apr 20 15:44:38 2003
+;;;; Contains: Tests for ROTATEF
+
+(in-package :cl-test)
+
+(deftest rotatef-order.1
+  (let ((x (vector 'a 'b 'c 'd 'e 'f))
+	(i 2))
+    (values
+     (rotatef (aref x (incf i)) (aref x (incf i)))
+     x i))
+  nil
+  #(a b c e d f)
+  4)
+
+(deftest rotatef-order.2
+  (let ((x (vector 'a 'b 'c 'd 'e 'f))
+	(i 2))
+    (values
+     (rotatef (aref x (incf i)) (aref x (incf i)) (aref x (incf i)))
+     x i))
+  nil
+  #(a b c e f d)
+  5)
+
+;;; Need to add more tests for ROTATEF here
diff --git a/ansi-tests/shiftf.lsp b/ansi-tests/shiftf.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..397db35f05178667678e80ad05805f59de9c66fd
--- /dev/null
+++ b/ansi-tests/shiftf.lsp
@@ -0,0 +1,20 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sun Apr 20 15:43:44 2003
+;;;; Contains: Tests of SHIFTF
+
+(in-package :cl-test)
+
+(deftest shiftf-order.1
+  (let ((x (vector 'a 'b 'c 'd 'e))
+	(i 2))
+    (values (shiftf (aref x (incf i)) (incf i)) x i))
+  d #(a b c 4 e) 4)
+    
+(deftest shiftf-order.2
+  (let ((x (vector 'a 'b 'c 'd 'e 'f 'g 'h))
+	(i 2))
+    (values (shiftf (aref x (incf i)) (aref x (incf i)) (incf i)) x i))
+  d #(a b c e 5 f g h) 5)
+
+;;; Need to add more shiftf tests here
diff --git a/ansi-tests/structures-03.lsp b/ansi-tests/structures-03.lsp
index 11b9a4e30ddba9a9071f4deee9aca2a40c500f31..59fe3c25326cb966084d9798bab805ce8cb34b1a 100644
--- a/ansi-tests/structures-03.lsp
+++ b/ansi-tests/structures-03.lsp
@@ -415,3 +415,7 @@
 ;;;	     :a :b :c)
 ;;;  (3 6 9))
 
+
+;;; Error test
+
+(def-macro-test struct.error.1 (defstruct nonexistent-structure-type a b c))
diff --git a/ansi-tests/typecase.lsp b/ansi-tests/typecase.lsp
index 48f609cb6c1481049d3e9d70c300eef43530457f..c9dcab869d57a1df1bda9a5d9f0ad16eba4ddf69 100644
--- a/ansi-tests/typecase.lsp
+++ b/ansi-tests/typecase.lsp
@@ -93,6 +93,20 @@
      (return-from done 'good)))
   good)
 
+(deftest typecase.error.1
+  (classify-error (funcall (macro-function 'typecase)))
+  program-error)
+
+(deftest typecase.error.2
+  (classify-error (funcall (macro-function 'typecase)
+			   '(typecase t)))
+  program-error)
+
+(deftest typecase.error.3
+  (classify-error (funcall (macro-function 'typecase)
+			   '(typecase t)
+			   nil nil))
+  program-error)
 
 
 
diff --git a/ansi-tests/unless.lsp b/ansi-tests/unless.lsp
index 948c2c8ba52d02913ec05c1b2ba46957a0a1356f..e3b9691593988185872972a9af5b5d6657a4a961 100644
--- a/ansi-tests/unless.lsp
+++ b/ansi-tests/unless.lsp
@@ -59,3 +59,17 @@
 ;;; (deftest unless.error.1
 ;;;  (classify-error (unless))
 ;;;  program-error)
+
+(deftest unless.error.1
+  (classify-error (funcall (macro-function 'unless)))
+  program-error)
+
+(deftest unless.error.2
+  (classify-error (funcall (macro-function 'unless)
+			   '(unless t)))
+  program-error)
+
+(deftest unless.error.3
+  (classify-error (funcall (macro-function 'unless)
+			   '(unless t) nil nil))
+  program-error)
\ No newline at end of file
diff --git a/ansi-tests/when.lsp b/ansi-tests/when.lsp
index 3dc179d7d48ccb27b077becc9404f0b1570ddec8..8b29c55dfd3dbea709bd450788e7cf73f6638806 100644
--- a/ansi-tests/when.lsp
+++ b/ansi-tests/when.lsp
@@ -50,3 +50,17 @@
 ;;; (deftest when.error.1
 ;;;  (classify-error (when))
 ;;;  program-error)
+
+(deftest when.error.1
+  (classify-error (funcall (macro-function 'when)))
+  program-error)
+
+(deftest when.error.2
+  (classify-error (funcall (macro-function 'when)
+			   '(when t)))
+  program-error)
+
+(deftest when.error.3
+  (classify-error (funcall (macro-function 'when)
+			   '(when t) nil nil))
+  program-error)
\ No newline at end of file