From 1d9c754d7e71d56a8adebe56e517e75bb6ab0366 Mon Sep 17 00:00:00 2001
From: pfdietz <pfdietz@localhost>
Date: Mon, 17 Feb 2003 04:22:04 +0000
Subject: [PATCH] Spruced up order/number of evaluation tests, fixed some test
 names.

---
 ansi-tests/bit-and.lsp             |   2 +-
 ansi-tests/bit-andc1.lsp           |   2 +-
 ansi-tests/bit-andc2.lsp           |   2 +-
 ansi-tests/bit-eqv.lsp             |   2 +-
 ansi-tests/bit-ior.lsp             |   2 +-
 ansi-tests/bit-nand.lsp            |   2 +-
 ansi-tests/bit-nor.lsp             |   2 +-
 ansi-tests/bit-not.lsp             |   8 +
 ansi-tests/bit-orc1.lsp            |   2 +-
 ansi-tests/bit-orc2.lsp            |   2 +-
 ansi-tests/bit-vector-p.lsp        |  17 ++
 ansi-tests/bit-xor.lsp             |   2 +-
 ansi-tests/bit.lsp                 |   4 +-
 ansi-tests/boundp.lsp              |   8 +
 ansi-tests/cell-error-name.lsp     |  10 ++
 ansi-tests/char-compare.lsp        | 269 +++++++++++++++++++++++++++--
 ansi-tests/char-schar.lsp          |   8 +-
 ansi-tests/character.lsp           | 186 +++++++++++++++++++-
 ansi-tests/cl-symbols.lsp          | 181 ++++++++++---------
 ansi-tests/coerce.lsp              |   2 +-
 ansi-tests/compile.lsp             |  10 +-
 ansi-tests/compiled-function-p.lsp |   7 +
 ansi-tests/complement.lsp          |   9 +
 ansi-tests/concatenate.lsp         |  14 +-
 ansi-tests/cons-test-01.lsp        |  79 +++++----
 ansi-tests/cons-test-02.lsp        |  25 ++-
 ansi-tests/cons-test-03.lsp        |  59 +++++--
 ansi-tests/cons-test-04.lsp        |  25 ++-
 ansi-tests/cons-test-05.lsp        |   4 +-
 ansi-tests/cons-test-06.lsp        |   7 +
 ansi-tests/cons-test-07.lsp        |  20 ++-
 ansi-tests/cons-test-08.lsp        |  16 +-
 ansi-tests/cons-test-09.lsp        |  18 +-
 ansi-tests/cons-test-10.lsp        |   7 +-
 ansi-tests/cons-test-11.lsp        |   7 +-
 ansi-tests/cons-test-12.lsp        |   7 +-
 ansi-tests/cons-test-13.lsp        |  10 +-
 ansi-tests/cons-test-14.lsp        |   8 +-
 ansi-tests/cons-test-15.lsp        |   3 -
 ansi-tests/cons-test-16.lsp        |  18 +-
 ansi-tests/cons-test-17.lsp        |  16 +-
 ansi-tests/cons-test-18.lsp        |  12 +-
 ansi-tests/cons-test-19.lsp        |  20 +--
 ansi-tests/cons-test-20.lsp        |   6 +-
 ansi-tests/cons-test-21.lsp        |  20 +--
 ansi-tests/cons-test-22.lsp        |  12 +-
 ansi-tests/cons-test-23.lsp        |  72 ++++----
 ansi-tests/cons-test-24.lsp        |   8 +-
 ansi-tests/constantly.lsp          |  11 ++
 ansi-tests/constantp.lsp           |   7 +
 ansi-tests/copy-seq.lsp            |   5 +
 ansi-tests/count-if-not.lsp        |   4 +-
 ansi-tests/count-if.lsp            |   4 +-
 ansi-tests/count.lsp               |   4 +-
 ansi-tests/elt.lsp                 | 122 ++++++-------
 ansi-tests/eql.lsp                 |   2 +-
 ansi-tests/equal.lsp               |   2 +-
 ansi-tests/equalp.lsp              |   2 +-
 ansi-tests/eval.lsp                |  10 ++
 ansi-tests/every.lsp               |  11 +-
 ansi-tests/fboundp.lsp             |   5 +
 ansi-tests/fdefinition.lsp         |   7 +
 ansi-tests/fill-pointer.lsp        |  20 +++
 ansi-tests/fill-strings.lsp        |  10 +-
 64 files changed, 1064 insertions(+), 394 deletions(-)

diff --git a/ansi-tests/bit-and.lsp b/ansi-tests/bit-and.lsp
index 4a15b3c3..0b62bb38 100644
--- a/ansi-tests/bit-and.lsp
+++ b/ansi-tests/bit-and.lsp
@@ -218,7 +218,7 @@
   #2a((0 0)(1 1))
   #2a((0 0)(0 1)))
 
-(deftest bit-and.20
+(deftest bit-and.order.1
   (let* ((s1 (make-array 1 :initial-element 0 :element-type 'bit))
 	 (s2 (make-array 1 :initial-element 0 :element-type 'bit))
 	 (x 0) y z)
diff --git a/ansi-tests/bit-andc1.lsp b/ansi-tests/bit-andc1.lsp
index fecdbaa7..5597ad16 100644
--- a/ansi-tests/bit-andc1.lsp
+++ b/ansi-tests/bit-andc1.lsp
@@ -218,7 +218,7 @@
   #2a((0 0)(1 1))
   #2a((0 0)(1 0)))
 
-(deftest bit-andc1.20
+(deftest bit-andc1.order.1
   (let* ((s1 (make-array 1 :initial-element 0 :element-type 'bit))
 	 (s2 (make-array 1 :initial-element 0 :element-type 'bit))
 	 (x 0) y z)
diff --git a/ansi-tests/bit-andc2.lsp b/ansi-tests/bit-andc2.lsp
index 0778d711..b61cbf7d 100644
--- a/ansi-tests/bit-andc2.lsp
+++ b/ansi-tests/bit-andc2.lsp
@@ -218,7 +218,7 @@
   #2a((0 0)(1 1))
   #2a((0 1)(0 0)))
 
-(deftest bit-andc2.20
+(deftest bit-andc2.order.1
   (let* ((s1 (make-array 1 :initial-element 0 :element-type 'bit))
 	 (s2 (make-array 1 :initial-element 0 :element-type 'bit))
 	 (x 0) y z)
diff --git a/ansi-tests/bit-eqv.lsp b/ansi-tests/bit-eqv.lsp
index 43674aa2..6593d97d 100644
--- a/ansi-tests/bit-eqv.lsp
+++ b/ansi-tests/bit-eqv.lsp
@@ -219,7 +219,7 @@
   #2a((0 0)(1 1))
   #2a((1 0)(0 1)))
 
-(deftest bit-eqv.20
+(deftest bit-eqv.order.1
   (let* ((s1 (make-array 1 :initial-element 0 :element-type 'bit))
 	 (s2 (make-array 1 :initial-element 0 :element-type 'bit))
 	 (x 0) y z)
diff --git a/ansi-tests/bit-ior.lsp b/ansi-tests/bit-ior.lsp
index 5b9940e0..469c7780 100644
--- a/ansi-tests/bit-ior.lsp
+++ b/ansi-tests/bit-ior.lsp
@@ -218,7 +218,7 @@
   #2a((0 0)(1 1))
   #2a((0 1)(1 1)))
 
-(deftest bit-ior.20
+(deftest bit-ior.order.1
   (let* ((s1 (make-array 1 :initial-element 0 :element-type 'bit))
 	 (s2 (make-array 1 :initial-element 0 :element-type 'bit))
 	 (x 0) y z)
diff --git a/ansi-tests/bit-nand.lsp b/ansi-tests/bit-nand.lsp
index 266f3e3c..840e6867 100644
--- a/ansi-tests/bit-nand.lsp
+++ b/ansi-tests/bit-nand.lsp
@@ -218,7 +218,7 @@
   #2a((0 0)(1 1))
   #2a((1 1)(1 0)))
 
-(deftest bit-nand.20
+(deftest bit-nand.order.1
   (let* ((s1 (make-array 1 :initial-element 0 :element-type 'bit))
 	 (s2 (make-array 1 :initial-element 0 :element-type 'bit))
 	 (x 0) y z)
diff --git a/ansi-tests/bit-nor.lsp b/ansi-tests/bit-nor.lsp
index 3055c123..36031ef3 100644
--- a/ansi-tests/bit-nor.lsp
+++ b/ansi-tests/bit-nor.lsp
@@ -218,7 +218,7 @@
   #2a((0 0)(1 1))
   #2a((1 0)(0 0)))
 
-(deftest bit-nor.20
+(deftest bit-nor.order.1
   (let* ((s1 (make-array 1 :initial-element 0 :element-type 'bit))
 	 (s2 (make-array 1 :initial-element 0 :element-type 'bit))
 	 (x 0) y z)
diff --git a/ansi-tests/bit-not.lsp b/ansi-tests/bit-not.lsp
index c8da583a..550dce3a 100644
--- a/ansi-tests/bit-not.lsp
+++ b/ansi-tests/bit-not.lsp
@@ -119,6 +119,14 @@
   #2a((0 1)(1 0))
   #2a((1 0)(0 1)))
 
+(deftest bit-not.order.1
+  (let ((a (copy-seq #*001101))
+	(i 0) x)
+    (values
+     (bit-not (progn (setf x (incf i)) a))
+     i x))
+  #*110010 1 1)
+
 ;;; Error tests
 
 (deftest bit-not.error.1
diff --git a/ansi-tests/bit-orc1.lsp b/ansi-tests/bit-orc1.lsp
index 7fe27f2d..96467f90 100644
--- a/ansi-tests/bit-orc1.lsp
+++ b/ansi-tests/bit-orc1.lsp
@@ -218,7 +218,7 @@
   #2a((0 0)(1 1))
   #2a((1 0)(1 1)))
 
-(deftest bit-orc1.20
+(deftest bit-orc1.order.1
   (let* ((s1 (make-array 1 :initial-element 0 :element-type 'bit))
 	 (s2 (make-array 1 :initial-element 0 :element-type 'bit))
 	 (x 0) y z)
diff --git a/ansi-tests/bit-orc2.lsp b/ansi-tests/bit-orc2.lsp
index c9145054..1f7af724 100644
--- a/ansi-tests/bit-orc2.lsp
+++ b/ansi-tests/bit-orc2.lsp
@@ -218,7 +218,7 @@
   #2a((0 0)(1 1))
   #2a((1 1)(0 1)))
 
-(deftest bit-orc2.20
+(deftest bit-orc2.order.1
   (let* ((s1 (make-array 1 :initial-element 0 :element-type 'bit))
 	 (s2 (make-array 1 :initial-element 0 :element-type 'bit))
 	 (x 0) y z)
diff --git a/ansi-tests/bit-vector-p.lsp b/ansi-tests/bit-vector-p.lsp
index 6038ca3a..93ebbd22 100644
--- a/ansi-tests/bit-vector-p.lsp
+++ b/ansi-tests/bit-vector-p.lsp
@@ -53,6 +53,23 @@
 	always (if p1 p2 (not p2)))
   t)
 
+(deftest bit-vector-p.order.1
+  (let ((i 0) x)
+    (values
+     (notnot (bit-vector-p (progn (setf x (incf i)) #*0010)))
+     i x))
+  t 1 1)
+
+(deftest bit-vector-p.order.2
+  (let ((i 0) x)
+    (values
+     (bit-vector-p (progn (setf x (incf i)) 'a))
+     i x))
+  nil 1 1)
+
+
+    
+
 (deftest bit-vector-p.error.1
   (classify-error (bit-vector-p))
   program-error)
diff --git a/ansi-tests/bit-xor.lsp b/ansi-tests/bit-xor.lsp
index e0e5a8a0..a2b58dd5 100644
--- a/ansi-tests/bit-xor.lsp
+++ b/ansi-tests/bit-xor.lsp
@@ -218,7 +218,7 @@
   #2a((0 0)(1 1))
   #2a((0 1)(1 0)))
 
-(deftest bit-xor.20
+(deftest bit-xor.order.1
   (let* ((s1 (make-array 1 :initial-element 0 :element-type 'bit))
 	 (s2 (make-array 1 :initial-element 0 :element-type 'bit))
 	 (x 0) y z)
diff --git a/ansi-tests/bit.lsp b/ansi-tests/bit.lsp
index 5a88fd35..70b807c3 100644
--- a/ansi-tests/bit.lsp
+++ b/ansi-tests/bit.lsp
@@ -111,7 +111,7 @@
 
 ;;; Order of evaluation tests
 
-(deftest bit.9
+(deftest bit.order.1
   (let ((x 0) y z
 	(b (copy-seq #*01010)))
     (values
@@ -120,7 +120,7 @@
      x y z))
   1 2 1 2)
 
-(deftest bit.10
+(deftest bit.order.2
   (let ((x 0) y z w
 	(b (copy-seq #*01010)))
     (values
diff --git a/ansi-tests/boundp.lsp b/ansi-tests/boundp.lsp
index 7a84dec9..b0385ff1 100644
--- a/ansi-tests/boundp.lsp
+++ b/ansi-tests/boundp.lsp
@@ -46,3 +46,11 @@
 (deftest boundp.4
   (boundp '#:foo)
   nil)
+
+(deftest boundp.order.1
+  (let ((i 0) x)
+    (values
+     (boundp (progn (setf x (incf i)) '#:foo))
+     i x))
+  nil 1 1)
+
diff --git a/ansi-tests/cell-error-name.lsp b/ansi-tests/cell-error-name.lsp
index c8bf93b8..3a418acf 100644
--- a/ansi-tests/cell-error-name.lsp
+++ b/ansi-tests/cell-error-name.lsp
@@ -14,6 +14,7 @@
 (deftest cell-error-name.2
   (handler-case
    (eval '(my-undefined-function))
+   ;; (warning (c) (muffle-warning c))
    (cell-error (c) (cell-error-name c)))
   my-undefined-function)
 
@@ -28,6 +29,15 @@
 (deftest cell-error-name.5
   (cell-error-name (make-condition 'unbound-slot :name 's))
   s)
+
+(deftest cell-error-name.6
+  (let ((i 0))
+    (values
+     (cell-error-name (progn (incf i) (make-condition
+				       'unbound-slot :name 's)))
+     i))
+  s 1)
+
   
 ;;; Need test raising condition unbound-slot
 
diff --git a/ansi-tests/char-compare.lsp b/ansi-tests/char-compare.lsp
index ff4c7e3a..e26205e0 100644
--- a/ansi-tests/char-compare.lsp
+++ b/ansi-tests/char-compare.lsp
@@ -35,7 +35,19 @@
 		 #'(lambda (c1 c2) (not (char= c1 c2))))
   t)
 
-(deftest char=.5
+(deftest char=.order.1
+  (let ((i 0))
+    (values (not (char= (progn (incf i) #\a))) i))
+  nil 1)
+  
+(deftest char=.order.2
+  (let ((i 0) a b)
+    (values (char= (progn (setf a (incf i)) #\a)
+		   (progn (setf b (incf i)) #\b))
+	    i a b))
+  nil 2 1 2)
+
+(deftest char=.order.3
   (let ((i 0) a b c)
     (values
      (char= (progn (setq a (incf i)) #\a)
@@ -44,6 +56,8 @@
      i a b c))
   nil 3 1 2 3)
 
+;;;
+
 (deftest char/=.1
   (is-ordered-by +code-chars+ #'char/=)
   t)
@@ -61,7 +75,19 @@
   (is-ordered-by +rev-code-chars+ #'char/=)
   t)
 
-(deftest char/=.5
+(deftest char/=.order.1
+  (let ((i 0))
+    (values (not (char/= (progn (incf i) #\a))) i))
+  nil 1)
+  
+(deftest char/=.order.2
+  (let ((i 0) a b)
+    (values (not (char/= (progn (setf a (incf i)) #\a)
+			 (progn (setf b (incf i)) #\b)))
+	    i a b))
+  nil 2 1 2)
+
+(deftest char/=.order.3
   (let ((i 0) a b c)
     (values
      (char/= (progn (setq a (incf i)) #\a)
@@ -70,6 +96,8 @@
      i a b c))
   nil 3 1 2 3)
 
+;;;
+  
 (deftest char<=.1
   (loop for c across +code-chars+
 	always (char<= c c))
@@ -103,7 +131,19 @@
   (notnot-mv (or (char<= #\9 #\a) (char<= #\z #\0)))
   t)
 
-(deftest char<=.9
+(deftest char<=.order.1
+  (let ((i 0))
+    (values (not (char<= (progn (incf i) #\a))) i))
+  nil 1)
+  
+(deftest char<=.order.2
+  (let ((i 0) a b)
+    (values (not (char<= (progn (setf a (incf i)) #\a)
+			 (progn (setf b (incf i)) #\b)))
+	    i a b))
+  nil 2 1 2)
+
+(deftest char<=.order.3
   (let ((i 0) a b c)
     (values
      (char<= (progn (setq a (incf i)) #\a)
@@ -112,6 +152,8 @@
      i a b c))
   nil 3 1 2 3)
 
+;;;
+
 (deftest char<.1
   (loop for c across +code-chars+
 	never (char< c c))
@@ -145,7 +187,19 @@
   (notnot-mv (or (char< #\9 #\a) (char< #\z #\0)))
   t)
   
-(deftest char<.9
+(deftest char<.order.1
+  (let ((i 0))
+    (values (not (char< (progn (incf i) #\a))) i))
+  nil 1)
+  
+(deftest char<.order.2
+  (let ((i 0) a b)
+    (values (not (char< (progn (setf a (incf i)) #\a)
+			(progn (setf b (incf i)) #\b)))
+	    i a b))
+  nil 2 1 2)
+
+(deftest char<.order.3
   (let ((i 0) a b c)
     (values
      (char< (progn (setq a (incf i)) #\a)
@@ -154,6 +208,17 @@
      i a b c))
   nil 3 1 2 3)
 
+(deftest char<.order.4
+  (let ((i 0) a b c)
+    (values
+     (char< (progn (setq a (incf i)) #\b)
+	    (progn (setq b (incf i)) #\a)
+	    (progn (setq c (incf i)) #\b))
+     i a b c))
+  nil 3 1 2 3)
+
+;;;
+
 (deftest char>=.1
   (loop for c across +code-chars+
 	always (char>= c c))
@@ -187,7 +252,19 @@
   (notnot-mv (or (char>= #\a #\9) (char>= #\0 #\z)))
   t)
 
-(deftest char>=.9
+(deftest char>=.order.1
+  (let ((i 0))
+    (values (not (char>= (progn (incf i) #\a))) i))
+  nil 1)
+  
+(deftest char>=.order.2
+  (let ((i 0) a b)
+    (values (not (char>= (progn (setf a (incf i)) #\b)
+			 (progn (setf b (incf i)) #\a)))
+	    i a b))
+  nil 2 1 2)
+
+(deftest char>=.order.3
   (let ((i 0) a b c)
     (values
      (char>= (progn (setq a (incf i)) #\b)
@@ -196,6 +273,17 @@
      i a b c))
   nil 3 1 2 3)
 
+(deftest char>=.order.4
+  (let ((i 0) a b c)
+    (values
+     (char>= (progn (setq a (incf i)) #\a)
+	     (progn (setq b (incf i)) #\b)
+	     (progn (setq c (incf i)) #\a))
+     i a b c))
+  nil 3 1 2 3)
+
+;;;
+
 (deftest char>.1
   (loop for c across +code-chars+
 	never (char> c c))
@@ -229,7 +317,19 @@
   (notnot-mv (or (char> #\a #\9) (char> #\0 #\z)))
   t)
 
-(deftest char>.9
+(deftest char>.order.1
+  (let ((i 0))
+    (values (not (char> (progn (incf i) #\a))) i))
+  nil 1)
+  
+(deftest char>.order.2
+  (let ((i 0) a b)
+    (values (not (char> (progn (setf a (incf i)) #\b)
+			(progn (setf b (incf i)) #\a)))
+	    i a b))
+  nil 2 1 2)
+
+(deftest char>.order.3
   (let ((i 0) a b c)
     (values
      (char> (progn (setq a (incf i)) #\b)
@@ -238,6 +338,15 @@
      i a b c))
   nil 3 1 2 3)
 
+(deftest char>.order.4
+  (let ((i 0) a b c)
+    (values
+     (char> (progn (setq a (incf i)) #\a)
+	    (progn (setq b (incf i)) #\b)
+	    (progn (setq c (incf i)) #\a))
+     i a b c))
+  nil 3 1 2 3)
+
 ;;; Case-insensitive comparisons
 
 (deftest char-equal.1
@@ -266,7 +375,19 @@
 			 (not (char-equal c1 c2)))))
   t)
 
-(deftest char-equal.5
+(deftest char-equal.order.1
+  (let ((i 0))
+    (values (not (char-equal (progn (incf i) #\a))) i))
+  nil 1)
+  
+(deftest char-equal.order.2
+  (let ((i 0) a b)
+    (values (char-equal (progn (setf a (incf i)) #\b)
+			(progn (setf b (incf i)) #\a))
+	    i a b))
+  nil 2 1 2)
+
+(deftest char-equal.order.3
   (let ((i 0) a b c)
     (values
      (char-equal (progn (setq a (incf i)) #\a)
@@ -275,6 +396,17 @@
      i a b c))
   nil 3 1 2 3)
 
+(deftest char-equal.order.4
+  (let ((i 0) a b c)
+    (values
+     (char-equal (progn (setq a (incf i)) #\a)
+		 (progn (setq b (incf i)) #\b)
+		 (progn (setq c (incf i)) #\a))
+     i a b c))
+  nil 3 1 2 3)
+
+;;;
+
 (deftest char-not-equal.1
   (is-ordered-by +code-chars+ #'(lambda (c1 c2)
 				  (or (char= (char-downcase c1)
@@ -298,7 +430,19 @@
 					  (char-not-equal c1 c2))))
   t)
 
-(deftest char-not-equal.5
+(deftest char-not-equal.order.1
+  (let ((i 0))
+    (values (not (char-not-equal (progn (incf i) #\a))) i))
+  nil 1)
+  
+(deftest char-not-equal.order.2
+  (let ((i 0) a b)
+    (values (not (char-not-equal (progn (setf a (incf i)) #\b)
+				 (progn (setf b (incf i)) #\a)))
+	    i a b))
+  nil 2 1 2)
+
+(deftest char-not-equal.order.3
   (let ((i 0) a b c)
     (values
      (char-not-equal (progn (setq a (incf i)) #\a)
@@ -307,6 +451,17 @@
      i a b c))
   nil 3 1 2 3)
 
+(deftest char-not-equal.order.4
+  (let ((i 0) a b c)
+    (values
+     (char-not-equal (progn (setq a (incf i)) #\a)
+		     (progn (setq b (incf i)) #\a)
+		     (progn (setq c (incf i)) #\b))
+     i a b c))
+  nil 3 1 2 3)
+
+;;;
+
 (deftest char-not-greaterp.1
   (loop for c across +code-chars+
 	always (char-not-greaterp c c))
@@ -340,7 +495,19 @@
   (notnot-mv (or (char-not-greaterp #\9 #\a) (char-not-greaterp #\z #\0)))
   t)
 
-(deftest char-not-greaterp.9
+(deftest char-not-greaterp.order.1
+  (let ((i 0))
+    (values (not (char-not-greaterp (progn (incf i) #\a))) i))
+  nil 1)
+  
+(deftest char-not-greaterp.order.2
+  (let ((i 0) a b)
+    (values (not (char-not-greaterp (progn (setf a (incf i)) #\a)
+				    (progn (setf b (incf i)) #\b)))
+	    i a b))
+  nil 2 1 2)
+
+(deftest char-not-greaterp.order.3
   (let ((i 0) a b c)
     (values
      (char-not-greaterp (progn (setq a (incf i)) #\a)
@@ -349,6 +516,17 @@
      i a b c))
   nil 3 1 2 3)
 
+(deftest char-not-greaterp.order.4
+  (let ((i 0) a b c)
+    (values
+     (char-not-greaterp (progn (setq a (incf i)) #\b)
+			(progn (setq b (incf i)) #\a)
+			(progn (setq c (incf i)) #\a))
+     i a b c))
+  nil 3 1 2 3)
+
+;;;
+
 (deftest char-lessp.1
   (loop for c across +code-chars+
 	never (char-lessp c c))
@@ -382,7 +560,19 @@
   (notnot-mv (or (char-lessp #\9 #\a) (char-lessp #\z #\0)))
   t)
 
-(deftest char-lessp.9
+(deftest char-lessp.order.1
+  (let ((i 0))
+    (values (not (char-lessp (progn (incf i) #\a))) i))
+  nil 1)
+  
+(deftest char-lessp.order.2
+  (let ((i 0) a b)
+    (values (not (char-lessp (progn (setf a (incf i)) #\a)
+			     (progn (setf b (incf i)) #\b)))
+	    i a b))
+  nil 2 1 2)
+
+(deftest char-lessp.order.3
   (let ((i 0) a b c)
     (values
      (char-lessp (progn (setq a (incf i)) #\a)
@@ -391,6 +581,17 @@
      i a b c))
   nil 3 1 2 3)
 
+(deftest char-lessp.order.4
+  (let ((i 0) a b c)
+    (values
+     (char-lessp (progn (setq a (incf i)) #\b)
+		 (progn (setq b (incf i)) #\a)
+		 (progn (setq c (incf i)) #\a))
+     i a b c))
+  nil 3 1 2 3)
+
+;;;
+
 (deftest char-not-lessp.1
   (loop for c across +code-chars+
 	always (char-not-lessp c c))
@@ -425,7 +626,19 @@
   (notnot-mv (or (char-not-lessp #\a #\9) (char-not-lessp #\0 #\z)))
   t)
 
-(deftest char-not-lessp.9
+(deftest char-not-lessp.order.1
+  (let ((i 0))
+    (values (not (char-not-lessp (progn (incf i) #\a))) i))
+  nil 1)
+  
+(deftest char-not-lessp.order.2
+  (let ((i 0) a b)
+    (values (not (char-not-lessp (progn (setf a (incf i)) #\b)
+				 (progn (setf b (incf i)) #\a)))
+	    i a b))
+  nil 2 1 2)
+
+(deftest char-not-lessp.order.3
   (let ((i 0) a b c)
     (values
      (char-not-lessp (progn (setq a (incf i)) #\b)
@@ -434,6 +647,17 @@
      i a b c))
   nil 3 1 2 3)
 
+(deftest char-not-lessp.order.4
+  (let ((i 0) a b c)
+    (values
+     (char-not-lessp (progn (setq a (incf i)) #\a)
+		     (progn (setq b (incf i)) #\b)
+		     (progn (setq c (incf i)) #\b))
+     i a b c))
+  nil 3 1 2 3)
+
+;;;
+
 (deftest char-greaterp.1
   (loop for c across +code-chars+
 	never (char-greaterp c c))
@@ -468,7 +692,19 @@
   (notnot-mv (or (char-greaterp #\a #\9) (char-greaterp #\0 #\z)))
   t)
 
-(deftest char-greaterp.9
+(deftest char-greaterp.order.1
+  (let ((i 0))
+    (values (not (char-greaterp (progn (incf i) #\a))) i))
+  nil 1)
+  
+(deftest char-greaterp.order.2
+  (let ((i 0) a b)
+    (values (not (char-greaterp (progn (setf a (incf i)) #\b)
+				(progn (setf b (incf i)) #\a)))
+	    i a b))
+  nil 2 1 2)
+
+(deftest char-greaterp.order.3
   (let ((i 0) a b c)
     (values
      (char-greaterp (progn (setq a (incf i)) #\b)
@@ -476,3 +712,12 @@
 		    (progn (setq c (incf i)) #\b))
      i a b c))
   nil 3 1 2 3)
+
+(deftest char-greaterp.order.4
+  (let ((i 0) a b c)
+    (values
+     (char-greaterp (progn (setq a (incf i)) #\a)
+		    (progn (setq b (incf i)) #\b)
+		    (progn (setq c (incf i)) #\a))
+     i a b c))
+  nil 3 1 2 3)
diff --git a/ansi-tests/char-schar.lsp b/ansi-tests/char-schar.lsp
index af00f03e..617316fa 100644
--- a/ansi-tests/char-schar.lsp
+++ b/ansi-tests/char-schar.lsp
@@ -78,7 +78,7 @@
     s)
   "aaaXa")
 
-(deftest char.11
+(deftest char.order.1
   (let ((i 0) a b)
     (values
      (char (progn (setf a (incf i)) "abc")
@@ -86,7 +86,7 @@
      i a b))
   #\b 2 1 2)
 
-(deftest char.12
+(deftest char.order.2
   (let ((i 0) a b c (s (make-string 5 :initial-element #\z)))
     (values
      (setf
@@ -145,7 +145,7 @@
     s)
   "xxXxxx")
 
-(deftest schar.11
+(deftest schar.order.1
   (let ((i 0) a b)
     (values
      (schar (progn (setf a (incf i)) "abc")
@@ -153,7 +153,7 @@
      i a b))
   #\b 2 1 2)
 
-(deftest schar.12
+(deftest schar.order.2
   (let ((i 0) a b c (s (copy-seq "zzzzz")))
     (values
      (setf
diff --git a/ansi-tests/character.lsp b/ansi-tests/character.lsp
index 3b9ee51b..923439ef 100644
--- a/ansi-tests/character.lsp
+++ b/ansi-tests/character.lsp
@@ -63,14 +63,23 @@
   (character.2.body)
   nil)
 
-(deftest character.3
+(deftest character.order.1
+  (let ((i 0))
+    (values
+     (character (progn (incf i) #\a))
+     i))
+  #\a 1)
+
+(deftest character.error.1
   (classify-error (character))
   program-error)
 
-(deftest character.4
+(deftest character.error.2
   (classify-error (character #\a #\a))
   program-error)
 
+;;;
+
 (deftest characterp.1
   (every #'characterp +standard-chars+)
   t)
@@ -83,6 +92,13 @@
   (characterp.3.body)
   t)
 
+(deftest characterp.order.1
+  (let ((i 0))
+    (values
+     (characterp (incf i))
+     i))
+  nil 1)
+
 (deftest characterp.error.1
   (classify-error (characterp))
   program-error)
@@ -99,6 +115,8 @@
 	    (not (alpha-char-p c))))
   t)
 
+;;;
+
 (deftest alpha-char-p.2
   (every #'alpha-char-p +alpha-chars+)
   t)
@@ -107,6 +125,13 @@
   (char-type-error-check #'alpha-char-p)
   t)
 
+(deftest alpha-char-p.order.1
+  (let ((i 0))
+    (values
+     (alpha-char-p (progn (incf i) #\8))
+     i))
+  nil 1)
+
 (deftest alpha-char-p.error.1
   (classify-error (alpha-char-p))
   program-error)
@@ -115,6 +140,8 @@
   (classify-error (alpha-char-p #\a #\b))
   program-error)
 
+;;;
+
 (deftest alphanumericp.1
   (loop for c across +standard-chars+
 	always
@@ -130,7 +157,6 @@
   (char-type-error-check #'alphanumericp)
   t)
 
-
 (deftest alphanumericp.4
   (alphanumericp.4.body)
   t)
@@ -139,6 +165,13 @@
   (alphanumericp.5.body)
   t)
 
+(deftest alphanumericp.order.1
+  (let ((i 0))
+    (values
+     (alphanumericp (progn (incf i) #\?))
+     i))
+  nil 1)
+
 (deftest alphanumericp.error.1
   (classify-error (alphanumericp))
   program-error)
@@ -147,6 +180,8 @@
   (classify-error (alphanumericp #\a #\b))
   program-error)
 
+;;;
+
 (deftest digit-char.1
   (digit-char.1.body)
   t)
@@ -158,6 +193,20 @@
    nil nil nil nil nil nil nil nil nil nil
    nil nil nil nil nil nil nil nil nil nil))
 
+(deftest digit-char.order.1
+  (let ((i 0))
+    (values
+     (digit-char (incf i))
+     i))
+  #\1 1)
+
+(deftest digit-char.order.2
+  (let ((i 0) x)
+    (values
+     (digit-char (incf i) (progn (setf x (incf i)) 10))
+     i x))
+  #\1 2 2)
+
 (deftest digit-char.error.1
   (classify-error (digit-char))
   program-error)
@@ -166,6 +215,8 @@
   (classify-error (digit-char 0 10 'foo))
   program-error)
 
+;;;
+
 (deftest digit-char-p.1
   (digit-char-p.1.body)
   t)
@@ -195,6 +246,21 @@
 	always (eqlt (digit-char-p c) i))
   t)
 
+(deftest digit-char-p.order.1
+  (let ((i 0))
+    (values
+     (digit-char-p (progn (incf i) #\0))
+     i))
+  0 1)
+
+(deftest digit-char-p.order.2
+  (let ((i 0) x y)
+    (values
+     (digit-char-p (progn (setf x (incf i)) #\0)
+		   (progn (setf y (incf i)) 10))
+     i x y))
+  0 2 1 2)
+
 (deftest digit-char-p.error.1
   (classify-error (digit-char-p))
   program-error)
@@ -202,7 +268,8 @@
 (deftest digit-char-p.error.2
   (classify-error (digit-char-p #\1 10 'foo))
   program-error)
-  
+
+;;;
 
 (deftest graphic-char-p.1
   (loop for c across +standard-chars+
@@ -211,17 +278,24 @@
 		 (graphic-char-p c)))
   t)
 
-(deftest graphic-char.2
+(deftest graphic-char-p.2
   (loop
    for name in '("Rubout" "Page" "Backspace" "Tab" "Linefeed" "Return")
    for c = (name-char name)
    when (and c (graphic-char-p c)) collect c)
   nil)
 
-(deftest graphic-char.3
+(deftest graphic-char-p.3
   (char-type-error-check #'graphic-char-p)
   t)
 
+(deftest graphic-char-p.order.1
+  (let ((i 0))
+    (values
+     (not (graphic-char-p (progn (incf i) #\a)))
+     i))
+  nil 1)
+
 (deftest graphic-char-p.error.1
   (classify-error (graphic-char-p))
   program-error)
@@ -230,6 +304,8 @@
   (classify-error (graphic-char-p #\a #\a))
   program-error)
 
+;;;
+
 (deftest standard-char-p.1
   (every #'standard-char-p +standard-chars+)
   t)
@@ -246,6 +322,13 @@
   (char-type-error-check #'standard-char-p)
   t)
 
+(deftest standard-char-p.order.1
+  (let ((i 0))
+    (values
+     (not (standard-char-p (progn (incf i) #\a)))
+     i))
+  nil 1)
+
 (deftest standard-char-p.error.1
   (classify-error (standard-char-p))
   program-error)
@@ -253,7 +336,8 @@
 (deftest standard-char-p.error.2
   (classify-error (standard-char-p #\a #\a))
   program-error)
-  
+
+;;;
 
 (deftest char-upcase.1
   (char-upcase.1.body)
@@ -271,6 +355,13 @@
   (char-type-error-check #'char-upcase)
   t)
 
+(deftest char-upcase.order.1
+  (let ((i 0))
+    (values
+     (char-upcase (progn (incf i) #\a))
+     i))
+  #\A 1)
+
 (deftest char-upcase.error.1
   (classify-error (char-upcase))
   program-error)
@@ -279,6 +370,8 @@
   (classify-error (char-upcase #\a #\a))
   program-error)
 
+;;;
+
 (deftest char-downcase.1
   (char-downcase.1.body)
   t)
@@ -295,6 +388,13 @@
   (char-type-error-check #'char-downcase)
   t)
 
+(deftest char-downcase.order.1
+  (let ((i 0))
+    (values
+     (char-downcase (progn (incf i) #\A))
+     i))
+  #\a 1)
+
 (deftest char-downcase.error.1
   (classify-error (char-downcase))
   program-error)
@@ -303,6 +403,8 @@
   (classify-error (char-downcase #\A #\A))
   program-error)
 
+;;;
+
 (deftest upper-case-p.1
   (find-if-not #'upper-case-p +standard-chars+ :start 26 :end 52)
   nil)
@@ -319,6 +421,13 @@
   (char-type-error-check #'upper-case-p)
   t)
 
+(deftest upper-case-p.order.1
+  (let ((i 0))
+    (values
+     (upper-case-p (progn (incf i) #\a))
+     i))
+  nil 1)
+
 (deftest upper-case-p.error.1
   (classify-error (upper-case-p))
   program-error)
@@ -327,6 +436,8 @@
   (classify-error (upper-case-p #\a #\A))
   program-error)
 
+;;;
+
 (deftest lower-case-p.1
   (find-if-not #'lower-case-p +standard-chars+ :end 26)
   nil)
@@ -339,6 +450,13 @@
   (char-type-error-check #'lower-case-p)
   t)
 
+(deftest lower-case-p.order.1
+  (let ((i 0))
+    (values
+     (lower-case-p (progn (incf i) #\A))
+     i))
+  nil 1)
+
 (deftest lower-case-p.error.1
   (classify-error (lower-case-p))
   program-error)
@@ -347,6 +465,8 @@
   (classify-error (lower-case-p #\a #\a))
   program-error)
 
+;;;
+
 (deftest both-case-p.1
   (both-case-p.1.body)
   t)
@@ -359,6 +479,13 @@
   (char-type-error-check #'both-case-p)
   t)
 
+(deftest both-case-p.order.1
+  (let ((i 0))
+    (values
+     (both-case-p (progn (incf i) #\5))
+     i))
+  nil 1)
+
 (deftest both-case-p.error.1
   (classify-error (both-case-p))
   program-error)
@@ -367,6 +494,8 @@
   (classify-error (both-case-p #\a #\a))
   program-error)
 
+;;;
+
 (deftest char-code.1
   (char-type-error-check #'char-code)
   t)
@@ -375,6 +504,13 @@
   (char-code.2.body)
   t)
 
+(deftest char-code.order.1
+  (let ((i 0))
+    (values
+     (not (numberp (char-code (progn (incf i) #\a))))
+     i))
+  nil 1)
+
 (deftest char-code.error.1
   (classify-error (char-code))
   program-error)
@@ -383,11 +519,20 @@
   (classify-error (char-code #\a #\a))
   program-error)
 
+;;;
+
 (deftest code-char.1
   (loop for x across +standard-chars+
 	always (eqlt (code-char (char-code x)) x))
   t)
 
+(deftest code-char.order.1
+  (let ((i 0))
+    (values
+     (code-char (progn (incf i) (char-code #\a)))
+     i))
+  #\a 1)
+
 (deftest code-char.error.1
   (classify-error (code-char))
   program-error)
@@ -396,6 +541,8 @@
   (classify-error (code-char 1 1))
   program-error)
 
+;;;
+
 (deftest char-int.1
   (loop for x across +standard-chars+
 	always (eqlt (char-int x) (char-code x)))
@@ -405,6 +552,13 @@
   (char-int.2.fn)
   t)
 
+(deftest char-int.order.1
+  (let ((i 0))
+    (values
+     (code-char (char-int (progn (incf i) #\a)))
+     i))
+  #\a 1)
+
 (deftest char-int.error.1
   (classify-error (char-int))
   program-error)
@@ -413,6 +567,8 @@
   (classify-error (char-int #\a #\a))
   program-error)
 
+;;;
+
 (deftest char-name.1
   (char-name.1.fn)
   t)
@@ -447,6 +603,13 @@
   (char-type-error-check #'char-name)
   t)
 
+(deftest char-name.order.1
+  (let ((i 0))
+    (values
+     (char-name (progn (incf i) #\Space))
+     i))
+  "Space" 1)
+
 (deftest char-name.error.1
   (classify-error (char-name))
   program-error)
@@ -455,6 +618,8 @@
   (classify-error (char-name #\a #\a))
   program-error)
 
+;;;
+
 (deftest name-char.1
   (name-char.1.body)
   t)
@@ -470,6 +635,13 @@
 	  (and (eqlt c1 c2) (eqlt c2 c3) (eqlt c3 c4))))
   t)
 
+(deftest name-char.order.1
+  (let ((i 0))
+    (values
+     (name-char (progn (incf i) "Space"))
+     i))
+  #\Space 1)
+
 (deftest name-char.error.1
   (classify-error (name-char))
   program-error)
diff --git a/ansi-tests/cl-symbols.lsp b/ansi-tests/cl-symbols.lsp
index eda4cd89..4dda1cdf 100644
--- a/ansi-tests/cl-symbols.lsp
+++ b/ansi-tests/cl-symbols.lsp
@@ -1048,6 +1048,12 @@
 	  collect name))
   nil)
 
+(deftest special-operator-p.order.1
+  (let ((i 0))
+    (values (notnot (special-operator-p (progn (incf i) 'catch)))
+	    i))
+  t 1)
+
 (deftest special-operator-p.error.1
   (classify-error (special-operator-p 1))
   type-error)
@@ -1063,142 +1069,163 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; keywordp
 
-(deftest keywordp-1 (keywordp 'hefalump)   nil)
-(deftest keywordp-2 (keywordp 17)          nil)
-(deftest keywordp-3 (notnot-mv (keywordp :stream))         t)
-(deftest keywordp-4 (notnot-mv (keywordp ':stream))        t)
-(deftest keywordp-5 (keywordp nil)         nil)
-(deftest keywordp-6 (notnot-mv (keywordp :nil))          t)
-(deftest keywordp-7 (keywordp '(:stream))    nil)
-(deftest keywordp-8 (keywordp "rest")     nil)
-(deftest keywordp-9 (keywordp ":rest")    nil)
-(deftest keywordp-10 (keywordp '&body) nil)
+(deftest keywordp.1 (keywordp 'hefalump)   nil)
+(deftest keywordp.2 (keywordp 17)          nil)
+(deftest keywordp.3 (notnot-mv (keywordp :stream))         t)
+(deftest keywordp.4 (notnot-mv (keywordp ':stream))        t)
+(deftest keywordp.5 (keywordp nil)         nil)
+(deftest keywordp.6 (notnot-mv (keywordp :nil))          t)
+(deftest keywordp.7 (keywordp '(:stream))    nil)
+(deftest keywordp.8 (keywordp "rest")     nil)
+(deftest keywordp.9 (keywordp ":rest")    nil)
+(deftest keywordp.10 (keywordp '&body) nil)
 ;;; This next test was busted.  ::foo is not portable syntax
-;;(deftest keywordp-11 (notnot-mv (keywordp ::foo))       t)
-(deftest keywordp-12 (keywordp t)          nil)
-(deftest keywordp-13 (classify-error (keywordp)) program-error)
-(deftest keywordp-14 (classify-error (keywordp :x :x)) program-error)
+;;(deftest keywordp.11 (notnot-mv (keywordp ::foo))       t)
+(deftest keywordp.12 (keywordp t)          nil)
+
+(deftest keywordp.order.1
+  (let ((i 0))
+    (values (keywordp (progn (incf i) nil)) i))
+  nil 1)
+
+(deftest keywordp.error.1 (classify-error (keywordp)) program-error)
+(deftest keywordp.error.2 (classify-error (keywordp :x :x)) program-error)
+
+(deftest keywordp.error.3
+  (classify-error (keywordp))
+  program-error)
+
+(deftest keywordp.error.4
+  (classify-error (keywordp nil nil))
+  program-error)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; symbol-name
 
-(deftest symbol-name-1
+(deftest symbol-name.1
   (safe-symbol-name '|ABCD|)
   "ABCD")
 
-(deftest symbol-name-2
+(deftest symbol-name.2
   (safe-symbol-name '|1234abcdABCD|)
   "1234abcdABCD")
 
-(deftest symbol-name-3
+(deftest symbol-name.3
   (safe-symbol-name 1)
   type-error)
 
-(deftest symbol-name-4
+(deftest symbol-name.4
   (safe-symbol-name '(a))
   type-error)
 
-(deftest symbol-name-5
+(deftest symbol-name.5
   (safe-symbol-name "ABCDE")
   type-error)
 
-(deftest symbol-name-6
+(deftest symbol-name.6
   (safe-symbol-name 12913.0213)
   type-error)
 
-(deftest symbol-name-7
+(deftest symbol-name.7
   (symbol-name :|abcdefg|)
   "abcdefg")
 
-(deftest symbol-name-8
+(deftest symbol-name.error.1
   (classify-error (symbol-name))
   program-error)
 
-(deftest symbol-name-9
+(deftest symbol-name.error.2
   (classify-error (symbol-name 'a 'b))
   program-error)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; make-symbol
 
-(deftest make-symbol-1
+(deftest make-symbol.1
   (notnot-mv (symbolp (make-symbol "FOO")))
   t)
 
-(deftest make-symbol-2
+(deftest make-symbol.2
   (symbol-package (make-symbol "BAR"))
   nil)
 
-(deftest make-symbol-3
+(deftest make-symbol.3
   (symbol-package (make-symbol "CL::FOO"))
   nil)
 
-(deftest make-symbol-4
+(deftest make-symbol.4
   (symbol-package (make-symbol "CL:FOO"))
   nil)
 
-(deftest make-symbol-5
+(deftest make-symbol.5
   (symbol-name (make-symbol "xyz"))
   "xyz")
 
-(deftest make-symbol-6
+(deftest make-symbol.6
     (eqt (make-symbol "A")
 	(make-symbol "A"))
   nil)
 
-(deftest make-symbol-7
+(deftest make-symbol.7
   (boundp (make-symbol "B"))
   nil)
 
-(deftest make-symbol-8
+(deftest make-symbol.8
   (symbol-plist (make-symbol "C"))
   nil)
 
-(deftest make-symbol-9
+(deftest make-symbol.9
+  (fboundp (make-symbol "D"))
+  nil)
+
+(deftest make-symbol.10
+  (symbol-name (safe-make-symbol ""))
+  "")
+
+(deftest make-symbol.order.1
+  (let ((i 0))
+    (values
+     (symbol-name (make-symbol (progn (incf i) "ABC")))
+     i))
+  "ABC" 1)
+
+(deftest make-symbol.error.1
   (safe-make-symbol nil)
   type-error)
 
-(deftest make-symbol-10
+(deftest make-symbol.error.2
   (safe-make-symbol 'a)
   type-error)
 
-(deftest make-symbol-11
+(deftest make-symbol.error.3
   (safe-make-symbol 1)
   type-error)
 
-(deftest make-symbol-12
+(deftest make-symbol.error.4
   (safe-make-symbol -1)
   type-error)
 
-(deftest make-symbol-13
+(deftest make-symbol.error.5
   (safe-make-symbol 1.213)
   type-error)
 
-(deftest make-symbol-14
+(deftest make-symbol.error.6
   (safe-make-symbol -1312.2)
   type-error)
 
-(deftest make-symbol-15
+(deftest make-symbol.error.7
   (safe-make-symbol #\w)
   type-error)
 
-(deftest make-symbol-16
+(deftest make-symbol.error.8
   (safe-make-symbol '(a))
   type-error)
 
-(deftest make-symbol-17
-  (fboundp (make-symbol "D"))
-  nil)
-
-(deftest make-symbol-18
-    (symbol-name (safe-make-symbol ""))
-  "")
-
-(deftest make-symbol-19
+(deftest make-symbol.error.9
   (classify-error (make-symbol))
   program-error)
 
-(deftest make-symbol-20
+(deftest make-symbol.error.10
   (classify-error (make-symbol "a" "a"))
   program-error)
 
@@ -1296,54 +1323,54 @@
 ;;; gensym
 
 ;;; Gensym returns unique symbols
-(deftest gensym-1
-    (equal (gensym) (gensym))
+(deftest gensym.1
+  (equal (gensym) (gensym))
   nil)
 
 ;;; Gensym returns symbols with distinct print names
-(deftest gensym-2
-    (string= (symbol-name (gensym))
-	     (symbol-name (gensym)))
+(deftest gensym.2
+  (string= (symbol-name (gensym))
+	   (symbol-name (gensym)))
   nil)
 
 ;;; Gensym uses the *gensym-counter* special variable,
 ;;; but does not increment it until after the symbol
 ;;; has been created.
-(deftest gensym-3
+(deftest gensym.3
   (let ((*gensym-counter* 1))
     (declare (special *gensym-counter*))
      (symbol-name (gensym)))
   "G1")
 
 ;;; Gensym uses the string argument instead of the default
-(deftest gensym-4
+(deftest gensym.4
   (let ((*gensym-counter* 1327))
     (declare (special *gensym-counter*))
     (symbol-name (gensym "FOO")))
   "FOO1327")
 
 ;;; The symbol returned by gensym should be unbound
-(deftest gensym-5
-    (boundp (gensym))
+(deftest gensym.5
+  (boundp (gensym))
   nil)
 
 ;;; The symbol returned by gensym should have no function binding
-(deftest gensym-6
-    (fboundp (gensym))
+(deftest gensym.6
+  (fboundp (gensym))
   nil)
 
 ;;; The symbol returned by gensym should have no property list
-(deftest gensym-7
-    (symbol-plist (gensym))
+(deftest gensym.7
+  (symbol-plist (gensym))
   nil)
 
 ;;; The symbol returned by gensym should be uninterned
-(deftest gensym-8
-    (symbol-package (gensym))
+(deftest gensym.8
+  (symbol-package (gensym))
   nil)
 
 ;;; *gensym-counter* is incremented by gensym
-(deftest gensym-9
+(deftest gensym.9
   (let ((*gensym-counter* 12345))
     (declare (special *gensym-counter*))
     (gensym)
@@ -1353,14 +1380,14 @@
 ;;; Gensym works when *gensym-counter* is Really Big
 ;;; (and does not increment the counter until after creating
 ;;; the symbol.)
-(deftest gensym-10
+(deftest gensym.10
   (let ((*gensym-counter* 1234567890123456789012345678901234567890))
     (declare (special *gensym-counter*))
     (symbol-name (gensym)))
   "G1234567890123456789012345678901234567890")
 
 ;;; gensym increments Really Big values of *gensym-counter*
-(deftest gensym-11
+(deftest gensym.11
   (let ((*gensym-counter* 12345678901234567890123456789012345678901234567890))
     (declare (special *gensym-counter*))
     (gensym)
@@ -1368,7 +1395,7 @@
   12345678901234567890123456789012345678901234567891)
 
 ;;; Gensym uses an integer argument instead of the counter
-(deftest gensym-12
+(deftest gensym.12
   (let ((*gensym-counter* 10))
     (declare (special *gensym-counter*))
     (symbol-name (gensym 123)))
@@ -1376,7 +1403,7 @@
 
 ;;; When given an integer argument, gensym does not increment the
 ;;; *gensym-counter*
-(deftest gensym-13
+(deftest gensym.13
   (let ((*gensym-counter* 10))
     (declare (special *gensym-counter*))
     (gensym 123)
@@ -1523,14 +1550,6 @@
   (classify-error (symbolp nil nil))
   program-error)
 
-(deftest keywordp.error.1
-  (classify-error (keywordp))
-  program-error)
-
-(deftest keywordp.error.2
-  (classify-error (keywordp nil nil))
-  program-error)
-
 (deftest symbol-function.error.1
   (classify-error (symbol-function))
   program-error)
@@ -1539,14 +1558,6 @@
   (classify-error (symbol-function 'cons nil))
   program-error)
 
-(deftest symbol-name.error.1
-  (classify-error (symbol-name))
-  program-error)
-
-(deftest symbol-name.error.2
-  (classify-error (symbol-name 'cons nil))
-  program-error)
-
 (deftest symbol-package.error.1
   (classify-error (symbol-package))
   program-error)
diff --git a/ansi-tests/coerce.lsp b/ansi-tests/coerce.lsp
index 783b735c..a2dec720 100644
--- a/ansi-tests/coerce.lsp
+++ b/ansi-tests/coerce.lsp
@@ -130,7 +130,7 @@
   (funcall (coerce '(lambda () 10) 'function))
   10)
 
-(deftest coerce.23
+(deftest coerce.order.1
   (let ((i 0) a b)
     (values
      (coerce (progn (setf a (incf i)) 10)
diff --git a/ansi-tests/compile.lsp b/ansi-tests/compile.lsp
index 0658648c..f3d61f54 100644
--- a/ansi-tests/compile.lsp
+++ b/ansi-tests/compile.lsp
@@ -75,9 +75,17 @@
   t)
 
 (deftest compile.9
+  (let ((i 0) a b)
+    (values
+     (funcall (compile (progn (setf a (incf i)) nil)
+		       (progn (setf b (incf i)) '(lambda () 'z))))
+     i a b))
+  z 2 1 2)
+
+(deftest compile.error.1
   (classify-error (compile))
   program-error)
 
-(deftest compile.10
+(deftest compile.error.2
   (classify-error (compile nil '(lambda () nil) 'garbage))
   program-error)
diff --git a/ansi-tests/compiled-function-p.lsp b/ansi-tests/compiled-function-p.lsp
index 95bf9e9d..f4301822 100644
--- a/ansi-tests/compiled-function-p.lsp
+++ b/ansi-tests/compiled-function-p.lsp
@@ -21,6 +21,13 @@
   (notnot-mv (compiled-function-p (compile nil '(lambda (y x) (cons x y)))))
   t)
 
+(deftest compiled-function-p.order.1
+  (let ((i 0))
+    (values
+     (compiled-function-p (progn (incf i) '(lambda () nil)))
+     i))
+  nil 1)
+
 (deftest compiled-function-p.error.1
   (classify-error (compiled-function-p))
   program-error)
diff --git a/ansi-tests/complement.lsp b/ansi-tests/complement.lsp
index 5194fff8..e387c0c6 100644
--- a/ansi-tests/complement.lsp
+++ b/ansi-tests/complement.lsp
@@ -31,6 +31,15 @@
   (notnot-mv (complement #'identity))
   t)
 
+(deftest complement.order.1
+  (let ((i 0))
+    (let ((fn (complement (progn (incf i) #'null))))
+      (values
+       i
+       (mapcar fn '(a b nil c 1 nil t nil))
+       i)))
+  1 (t t nil t t nil t nil) 1)
+
 (deftest complement.error.1
   (classify-error (complement))
   program-error)
diff --git a/ansi-tests/concatenate.lsp b/ansi-tests/concatenate.lsp
index 31b19a11..de8fefa1 100644
--- a/ansi-tests/concatenate.lsp
+++ b/ansi-tests/concatenate.lsp
@@ -184,7 +184,7 @@
   #*01100
   nil)
 
-(deftest concatenate.31
+(deftest concatenate.order.1
   (let ((i 0) w x y z)
     (values
      (concatenate (progn (setf w (incf i)) 'string)
@@ -194,7 +194,7 @@
      i w x y z))
   "abcdefghi" 4 1 2 3 4)
 
-(deftest concatenate.32
+(deftest concatenate.order.2
   (let ((i 0) x y z)
     (values
      (concatenate 'string
@@ -206,28 +206,28 @@
 
 ;;; Error tests
 
-(deftest concatenate-error.1
+(deftest concatenate.error.1
   (handler-case
    (progn (proclaim '(optimize (safety 3)))
 	  (eval '(concatenate 'sequence '(a b c))))
    (error () :caught))
   :caught)
 
-(deftest concatenate-error.2
+(deftest concatenate.error.2
   (handler-case
       (progn (proclaim '(optimize (safety 3)))
 	     (concatenate 'fixnum '(a b c d e)))
       (error () :caught))
   :caught)
 
-(deftest concatenate-error.3
+(deftest concatenate.error.3
   (classify-error (concatenate '(vector * 3) '(a b c d e)))
   type-error)
 
-(deftest concatenate-error.4
+(deftest concatenate.error.4
   (classify-error (concatenate))
   program-error)
 
-(deftest concatenate-error.5
+(deftest concatenate.error.5
   (classify-error (locally (concatenate '(vector * 3) '(a b c d e)) t))
   type-error)
diff --git a/ansi-tests/cons-test-01.lsp b/ansi-tests/cons-test-01.lsp
index 9d026c3a..e15fdaf2 100644
--- a/ansi-tests/cons-test-01.lsp
+++ b/ansi-tests/cons-test-01.lsp
@@ -149,10 +149,9 @@
   t)
 
 ;;; Order of evaluation of cons arguments
-(deftest cons-order-of-args
+(deftest cons.order.1
   (let ((i 0)) (values (cons (incf i) (incf i)) i))
-  (1 . 2)
-  2)	   
+  (1 . 2) 2)
 
 ;; Lists satisfy consp
 (deftest consp-list
@@ -193,6 +192,11 @@
   (check-type-predicate 'consp 'cons)
   0)
 
+(deftest consp.order.1
+  (let ((i 0))
+    (values (consp (incf i)) i))
+  nil 1)
+
 (deftest consp.error.1
   (classify-error (consp))
   program-error)
@@ -201,6 +205,11 @@
   (classify-error (consp 'a 'b))
   program-error)
 
+(deftest atom.order.1
+  (let ((i 0))
+    (values (atom (progn (incf i) '(a b))) i))
+  nil 1)
+
 (deftest atom.error.1
   (classify-error (atom))
   program-error)
@@ -210,59 +219,59 @@
   program-error)
 
 ;; Tests of car, cdr and compound forms
-(deftest cons-23
+(deftest cons.23
   (car '(a))
   a)
 
-(deftest cons-24
+(deftest cons.24
   (cdr '(a . b))
   b)
 
-(deftest cons-25
+(deftest cons.25
   (caar '((a)))
   a)
 
-(deftest cons-26
+(deftest cons.26
   (cdar '((a . b)))
   b)
 
-(deftest cons-27
+(deftest cons.27
   (cadr '(a b))
   b)
 
-(deftest cons-28
+(deftest cons.28
   (cddr '(a b . c))
   c)
 
-(deftest cons-29
+(deftest cons.29
   (caaar '(((a))))
   a)
 
-(deftest cons-30
+(deftest cons.30
   (cdaar '(((a . b))))
   b)
 
-(deftest cons-31
+(deftest cons.31
   (cadar (cons (cons 'a (cons 'b 'c)) 'd))
   b)
 
-(deftest cons-32
+(deftest cons.32
   (cddar (cons (cons 'a (cons 'b 'c)) 'd))
   c)
 
-(deftest cons-33
+(deftest cons.33
   (caadr (cons 'a (cons (cons 'b 'c) 'd)))
   b)
 
-(deftest cons-34
+(deftest cons.34
   (caddr (cons 'a (cons 'b (cons 'c 'd))))
   c)
 
-(deftest cons-36
+(deftest cons.36
   (cdadr (cons 'a (cons (cons 'b 'c) 'd)))
   c)
 
-(deftest cons-37
+(deftest cons.37
   (cdddr (cons 'a (cons 'b (cons 'c 'd))))
   d)
 
@@ -277,69 +286,69 @@
 		    (cons 'o 'p)))))
 
 
-(deftest cons-38
+(deftest cons.38
   (caaaar *cons-test-4*)
   a)
 
-(deftest cons-39
+(deftest cons.39
   (cdaaar *cons-test-4*)
   b)
 
-(deftest cons-40
+(deftest cons.40
   (cadaar *cons-test-4*)
   c)
 
-(deftest cons-41
+(deftest cons.41
   (cddaar *cons-test-4*)
   d)
 
-(deftest cons-42
+(deftest cons.42
   (caadar *cons-test-4*)
   e)
 
-(deftest cons-43
+(deftest cons.43
   (cdadar *cons-test-4*)
   f)
 
-(deftest cons-44
+(deftest cons.44
   (caddar *cons-test-4*)
   g)
 
-(deftest cons-45
+(deftest cons.45
   (cdddar *cons-test-4*)
   h)
 
 ;;;
 
-(deftest cons-46
+(deftest cons.46
   (caaadr *cons-test-4*)
   i)
 
-(deftest cons-47
+(deftest cons.47
   (cdaadr *cons-test-4*)
   j)
 
-(deftest cons-48
+(deftest cons.48
   (cadadr *cons-test-4*)
   k)
 
-(deftest cons-49
+(deftest cons.49
   (cddadr *cons-test-4*)
   l)
 
-(deftest cons-50
+(deftest cons.50
   (caaddr *cons-test-4*)
   m)
 
-(deftest cons-51
+(deftest cons.51
   (cdaddr *cons-test-4*)
   n)
 
-(deftest cons-52
+(deftest cons.52
   (cadddr *cons-test-4*)
   o)
 
-(deftest cons-53
+(deftest cons.53
   (cddddr *cons-test-4*)
   p)
 
@@ -366,7 +375,7 @@
 	   (eqt (cdr x) 'b))))
   t)
 
-(deftest rplaca.2
+(deftest rplaca.order.1
   (let ((x (cons 'a 'b))
 	(i 0) a b)
     (values
@@ -384,7 +393,7 @@
 	   (eqt (cdr x) 'd))))
   t)
 
-(deftest rplacd.2
+(deftest rplacd.order.1
   (let ((x (cons 'a 'b))
 	(i 0) a b)
     (values
diff --git a/ansi-tests/cons-test-02.lsp b/ansi-tests/cons-test-02.lsp
index bb31637f..117c1aaa 100644
--- a/ansi-tests/cons-test-02.lsp
+++ b/ansi-tests/cons-test-02.lsp
@@ -29,6 +29,13 @@
     (check-cons-copy x y))
   t)
 
+(deftest copy-tree.order.1
+  (let ((i 0))
+    (values
+     (copy-tree (progn (incf i) '(a b c)))
+     i))
+  (a b c) 1)
+
 (deftest copy-tree.error.1
   (classify-error (copy-tree))
   program-error)
@@ -37,6 +44,8 @@
   (classify-error (copy-tree 'a 'b))
   program-error)
 
+;;;
+
 (deftest sublis.1
   (check-sublis '((a b) g (d e 10 g h) 15 . g)
 		'((e . e2) (g . 17)))
@@ -96,7 +105,7 @@
   (2 2 b b))
 
 ;;; Order of argument evaluation
-(deftest sublis.9
+(deftest sublis.order.1
   (let ((i 0) w x y z)
     (values
      (sublis
@@ -110,7 +119,7 @@
   (z b c d)
   4 1 2 3 4)
 
-(deftest sublis.10
+(deftest sublis.order.2
   (let ((i 0) w x y z)
     (values
      (sublis
@@ -237,7 +246,7 @@
   (2 2 b b))
 
 ;;; Order of argument evaluation
-(deftest nsublis.10
+(deftest nsublis.order.1
   (let ((i 0) w x y z)
     (values
      (nsublis
@@ -251,7 +260,7 @@
   (z b c d)
   4 1 2 3 4)
 
-(deftest nsublis.11
+(deftest nsublis.order.2
   (let ((i 0) w x y z)
     (values
      (nsublis
@@ -376,7 +385,7 @@
   (a a c d a a))
 
 ;;; Order of argument evaluation
-(deftest subst.10
+(deftest subst.order.1
   (let ((i 0) v w x y z)
     (values
      (subst (progn (setf v (incf i)) 'b)
@@ -388,7 +397,7 @@
   ((10 b . b) b b c ((b)) z)
   5 1 2 3 4 5)
 
-(deftest subst.11
+(deftest subst.order.2
   (let ((i 0) v w x y z)
     (values
      (subst (progn (setf v (incf i)) 'b)
@@ -641,7 +650,7 @@
   (a a c d a a))
 
 ;;; Order of argument evaluation
-(deftest nsubst.10
+(deftest nsubst.order.1
   (let ((i 0) v w x y z)
     (values
      (nsubst (progn (setf v (incf i)) 'b)
@@ -653,7 +662,7 @@
   ((10 b . b) b b c ((b)) z)
   5 1 2 3 4 5)
 
-(deftest nsubst.11
+(deftest nsubst.order.2
   (let ((i 0) v w x y z)
     (values
      (nsubst (progn (setf v (incf i)) 'b)
diff --git a/ansi-tests/cons-test-03.lsp b/ansi-tests/cons-test-03.lsp
index c444a9c7..7d9a73fc 100644
--- a/ansi-tests/cons-test-03.lsp
+++ b/ansi-tests/cons-test-03.lsp
@@ -10,20 +10,26 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; copy-list
 
-(deftest copy-list-1
-    (check-copy-list '(a b c d))
+(deftest copy-list.1
+  (check-copy-list '(a b c d))
   (a b c d))
 
 ;; Check that copy-list works on dotted lists
 
-(deftest copy-list-2
-    (check-copy-list '(a . b))
+(deftest copy-list.2
+  (check-copy-list '(a . b))
  (a . b))
 
-(deftest copy-list-3
-    (check-copy-list '(a b c . d))
+(deftest copy-list.3
+  (check-copy-list '(a b c . d))
   (a b c . d))
 
+(deftest copy-list.4
+  (let ((i 0))
+    (values (copy-list (progn (incf i) '(a b c)))
+	    i))
+  (a b c) 1)
+
 (deftest copy-list.error.1
   (classify-error (copy-list))
   program-error)
@@ -43,18 +49,18 @@
   (list)
   nil)
 
-(deftest list.3
+(deftest list.order.1
   (let ((i 0))
     (list (incf i) (incf i) (incf i) (incf i)))
   (1 2 3 4))
 
-(deftest list.4
+(deftest list.order.2
   (let ((i 0))
     (list (incf i) (incf i) (incf i) (incf i)
 	  (incf i) (incf i) (incf i) (incf i)))
   (1 2 3 4 5 6 7 8))
 
-(deftest list.5
+(deftest list.order.3
   (let ((i 0))
     (list (incf i) (incf i) (incf i) (incf i)
 	  (incf i) (incf i) (incf i) (incf i)
@@ -74,16 +80,16 @@
   (list* 'a 'b 'c (list 'd 'e 'f))
   (a b c d e f))
 
-(deftest list*-3
+(deftest list*.3
   (list* 1)
   1)
 
-(deftest list*.4
+(deftest list*.order.1
   (let ((i 0))
     (list* (incf i) (incf i) (incf i) (incf i)))
   (1 2 3 . 4))
 
-(deftest list*.5
+(deftest list*.order.2
   (let ((i 0))
     (list* (incf i) (incf i) (incf i) (incf i)
 	   (incf i) (incf i) (incf i) (incf i)
@@ -113,6 +119,11 @@
 	(list-length z))))
   nil)
 
+(deftest list-length.order.1
+  (let ((i 0))
+    (values (list-length (progn (incf i) '(a b c))) i))
+  3 1)
+
 
 ;; Check that list-length produces a type-error
 ;; on arguments that are not proper lists or circular lists
@@ -174,6 +185,11 @@
   (check-type-predicate 'listp 'list)
   0)
 
+(deftest listp.order.1
+  (let ((i 0))
+    (values (listp (incf i)) i))
+  nil 1)
+
 (deftest listp.error.1
   (classify-error (listp))
   program-error)
@@ -213,11 +229,11 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; make-list
 
-(deftest make-list-empty-1
+(deftest make-list-empty.1
   (make-list 0)
   nil)
 
-(deftest make-list-empty-2
+(deftest make-list-empty.2
   (make-list 0 :initial-element 'a)
   nil)
 
@@ -253,7 +269,7 @@
   (make-list 5 :initial-element 'a :initial-element 'b)
   (a a a a a))
 
-(deftest make-list.order
+(deftest make-list.order.1
   (let ((i 0) x y)
     (values
      (make-list (progn (setf x (incf i)) 5)
@@ -263,6 +279,19 @@
   (a a a a a)
   2 1 2)
 
+(deftest make-list.order.2
+  (let ((i 0) x y z)
+    (values
+     (make-list (progn (setf x (incf i)) 5)
+		:initial-element
+		(progn (setf y (incf i)) 'a)
+		:initial-element
+		(progn (setf z (incf i)) 'b))
+     i x y z))
+  (a a a a a)
+  3 1 2 3)
+
+
 (deftest make-list.error.1
   (catch-type-error (make-list -1))
   type-error)
diff --git a/ansi-tests/cons-test-04.lsp b/ansi-tests/cons-test-04.lsp
index e987beec..2846d520 100644
--- a/ansi-tests/cons-test-04.lsp
+++ b/ansi-tests/cons-test-04.lsp
@@ -15,18 +15,18 @@
 
 ;;; See also places.lsp
 
-(deftest push-1
+(deftest push.1
   (let ((x nil))
     (push 'a x))
   (a))
 
-(deftest push-2
+(deftest push.2
   (let ((x 'b))
     (push 'a x)
     (push 'c x))
   (c a . b))
 
-(deftest push-3
+(deftest push.3
   (let ((x (copy-tree '(a))))
     (push x x)
     (and
@@ -34,23 +34,32 @@
      x))
   ((a) a))
 
+(deftest push.order.1
+  (let ((x (list nil)) (i 0) a b)
+    (values
+     (push (progn (setf a (incf i)) 'z)
+	   (car (progn (setf b (incf i)) x)))
+     x
+     i a b))
+  (z) ((z)) 2 1 2)
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; pop
 
-(deftest pop-1
+(deftest pop.1
   (let ((x (copy-tree '(a b c))))
     (let ((y (pop x)))
       (list x y)))
   ((b c) a))
 
-(deftest pop-2
+(deftest pop.2
   (let ((x nil))
     (let ((y (pop x)))
       (list x y)))
   (nil nil))
 
 ;;; Confirm argument is executed just once.
-(deftest pop-3
+(deftest pop.order.1
   (let ((i 0)
 	(a (vector (list 'a 'b 'c))))
     (pop (aref a (progn (incf i) 0)))
@@ -302,7 +311,7 @@
 	  :test-not (complement #'equal) :key nil)
   (aaa "AAA" "aaa" #\a))
 
-(deftest adjoin.19
+(deftest adjoin.order.1
   (let ((i 0) w x y z)
     (values
      (adjoin (progn (setf w (incf i)) 'a)
@@ -313,7 +322,7 @@
   (b c d a e)
   4 1 2 3 4)
 
-(deftest adjoin.20
+(deftest adjoin.order.2
   (let ((i 0) w x y z p)
     (values
      (adjoin (progn (setf w (incf i)) 'a)
diff --git a/ansi-tests/cons-test-05.lsp b/ansi-tests/cons-test-05.lsp
index 28d185ad..1f6b79ee 100644
--- a/ansi-tests/cons-test-05.lsp
+++ b/ansi-tests/cons-test-05.lsp
@@ -156,7 +156,7 @@
   t)
 
 ;;; Test side effects, evaluation order in assignment to NTH
-(deftest nth.3
+(deftest nth.order.1
   (let ((i 0)
 	(x (list 'a 'b 'c 'd))
 	y z)
@@ -168,7 +168,7 @@
      x))
   (a z c d))
 
-(deftest nth.4
+(deftest nth.order.2
   (let ((i 0) x y (z '(a b c d e)))
     (values
      (nth (progn (setf x (incf i)) 1)
diff --git a/ansi-tests/cons-test-06.lsp b/ansi-tests/cons-test-06.lsp
index c0f067e7..0ea94d48 100644
--- a/ansi-tests/cons-test-06.lsp
+++ b/ansi-tests/cons-test-06.lsp
@@ -23,6 +23,13 @@
   (endp '(a))
   nil)
 
+(deftest endp.order.1
+  (let ((i 0))
+    (values
+     (endp (progn (incf i) '(a b c)))
+     i))
+  nil 1)
+
 (deftest endp-symbol-error
   (catch-type-error (endp 'a))
   type-error)
diff --git a/ansi-tests/cons-test-07.lsp b/ansi-tests/cons-test-07.lsp
index 7460e471..ec599146 100644
--- a/ansi-tests/cons-test-07.lsp
+++ b/ansi-tests/cons-test-07.lsp
@@ -61,7 +61,7 @@
 	 'foo)
   (a c e . foo))
 
-(deftest nconc.8
+(deftest nconc.order.1
   (let ((i 0) x y z)
     (values
      (nconc (progn (setf x (incf i)) (copy-list '(a b c)))
@@ -69,7 +69,13 @@
 	    (progn (setf z (incf i)) (copy-list '(g h i))))
      i x y z))
   (a b c d e f g h i) 3 1 2 3)
-	    
+
+(deftest nconc.order.2
+  (let ((i 0))
+    (values
+     (nconc (incf i))
+     i))
+  1 1)	    
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; append
@@ -108,7 +114,7 @@
   (append-6-body)
   0)
 
-(deftest append.7
+(deftest append.order.1
   (let ((i 0) x y z)
     (values
      (append (progn (setf x (incf i)) (copy-list '(a b c)))
@@ -117,6 +123,10 @@
      i x y z))
   (a b c d e f g h i) 3 1 2 3)
 
+(deftest append.order.2
+  (let ((i 0)) (values (append (incf i)) i))
+  1 1)
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; revappend
 
@@ -146,7 +156,7 @@
     (revappend (copy-tree '(a (b c) d)) nil)
   (d (b c) a))
 
-(deftest revappend.5
+(deftest revappend.order.1
   (let ((i 0) x y)
     (values
      (revappend (progn (setf x (incf i)) (copy-list '(a b c)))
@@ -181,7 +191,7 @@
   (nreconc nil 'a)
   a)
 
-(deftest nreconc.3
+(deftest nreconc.order.1
   (let ((i 0) x y)
     (values
      (nreconc (progn (setf x (incf i)) (copy-list '(a b c)))
diff --git a/ansi-tests/cons-test-08.lsp b/ansi-tests/cons-test-08.lsp
index 9c10446c..916a1287 100644
--- a/ansi-tests/cons-test-08.lsp
+++ b/ansi-tests/cons-test-08.lsp
@@ -11,7 +11,7 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; Error checking car, cdr, list-length
 
-(deftest car-1
+(deftest car.1
   (car '(a))
   a)
 
@@ -27,7 +27,12 @@
   (classify-error (locally (car 'a) t))
   type-error)
 
-(deftest cdr-1
+(deftest car.order.1
+  (let ((i 0))
+    (values (car (progn (incf i) '(a b))) i))
+  a 1)
+
+(deftest cdr.1
   (cdr '(a b))
   (b))
 
@@ -35,6 +40,11 @@
   (cdr ())
   nil)
 
+(deftest cdr.order.1
+  (let ((i 0))
+    (values (cdr (progn (incf i) '(a b))) i))
+  (b) 1)
+
 (deftest cdr-symbol-error
   (classify-error (cdr 'a))
   type-error)
@@ -43,7 +53,7 @@
   (classify-error (locally (cdr 'a) t))
   type-error)
 
-(deftest list-length-4
+(deftest list-length.4
   (list-length (copy-tree '(a b c)))
   3)
 
diff --git a/ansi-tests/cons-test-09.lsp b/ansi-tests/cons-test-09.lsp
index 8341a373..d4d0061b 100644
--- a/ansi-tests/cons-test-09.lsp
+++ b/ansi-tests/cons-test-09.lsp
@@ -50,7 +50,7 @@
   (butlast (copy-tree '(a b c . d)) 1)
   (a b))
 
-(deftest butlast.6
+(deftest butlast.order.1
   (let ((i 0) x y)
     (values
      (butlast (progn (setf x (incf i))
@@ -60,6 +60,13 @@
      i x y))
   (a b c) 2 1 2)
 
+(deftest butlast.order.2
+  (let ((i 0))
+    (values
+     (butlast (progn (incf i) '(a b c d)))
+     i))
+  (a b c) 1)
+
 (deftest butlast.error.1
   (classify-error (butlast (copy-tree '(a b c d)) 'a))
   type-error)
@@ -121,7 +128,7 @@
   (nbutlast (list 'a))
   nil)
 
-(deftest nbutlast.7
+(deftest nbutlast.order.1
   (let ((i 0) x y)
     (values
      (nbutlast (progn (setf x (incf i))
@@ -131,6 +138,13 @@
      i x y))
   (a b c) 2 1 2)
 
+(deftest nbutlast.order.2
+  (let ((i 0))
+    (values
+     (nbutlast (progn (incf i) (list 'a 'b 'c 'd)))
+     i))
+  (a b c) 1)
+
 (deftest nbutlast.error.1
   (classify-error (let ((x (list* 'a 'b 'c 'd))) (nbutlast x 'a)))
   type-error)
diff --git a/ansi-tests/cons-test-10.lsp b/ansi-tests/cons-test-10.lsp
index 99e2f790..8779df54 100644
--- a/ansi-tests/cons-test-10.lsp
+++ b/ansi-tests/cons-test-10.lsp
@@ -50,7 +50,7 @@
   (last (cons 'a 'b) 2)
   (a . b))
 
-(deftest last.11
+(deftest last.order.1
   (let ((i 0) x y)
     (values
      (last (progn (setf x (incf i)) (list 'a 'b 'c 'd))
@@ -58,6 +58,11 @@
      i x y))
   (c d) 2 1 2)
 
+(deftest last.order.2
+  (let ((i 0))
+    (values (last (progn (incf i) (list 'a 'b 'c 'd))) i))
+  (d) 1)
+
 (deftest last.error.1
   (classify-error (last (list 'a 'b 'c) -1))
   type-error)
diff --git a/ansi-tests/cons-test-11.lsp b/ansi-tests/cons-test-11.lsp
index ebee5852..40cd2559 100644
--- a/ansi-tests/cons-test-11.lsp
+++ b/ansi-tests/cons-test-11.lsp
@@ -100,7 +100,7 @@
 	    count (eqt c1 c2)))))
   0)
 
-(deftest ldiff.9
+(deftest ldiff.order.1
   (let ((i 0) x y)
     (values
      (ldiff (progn (setf x (incf i))
@@ -108,7 +108,7 @@
 	    (progn (setf y (incf i))
 		   'd))
      i x y))
-  (a b c) 2 1 2)	       
+  (a b c) 2 1 2)       
 
 ;; Error checking
 
@@ -182,7 +182,6 @@
      t))
   t)
 
-
 ;; The next four tests test that tailp handles dotted lists.  See
 ;; TAILP-NIL:T in the X3J13 documentation.
 
@@ -251,7 +250,7 @@
   0)
 |#
     
-(deftest tailp.8
+(deftest tailp.order.1
   (let ((i 0) x y)
     (values
      (notnot
diff --git a/ansi-tests/cons-test-12.lsp b/ansi-tests/cons-test-12.lsp
index 7dc703c2..2c545df7 100644
--- a/ansi-tests/cons-test-12.lsp
+++ b/ansi-tests/cons-test-12.lsp
@@ -74,7 +74,7 @@
   (nthcdr 1 (cons 'a 'b))
   b)
 
-(deftest nthcdr.6
+(deftest nthcdr.order.1
   (let ((i 0) x y)
     (values
      (nthcdr (setf x (incf i))
@@ -89,6 +89,11 @@
   (rest (list 'a 'b 'c))
   (b c))
 
+(deftest rest.order.1
+  (let ((i 0))
+    (values (rest (progn (incf i) '(a b))) i))
+  (b) 1)
+
 (deftest rest.error.1
   (classify-error (rest))
   program-error)
diff --git a/ansi-tests/cons-test-13.lsp b/ansi-tests/cons-test-13.lsp
index 50afa205..d2f65eb7 100644
--- a/ansi-tests/cons-test-13.lsp
+++ b/ansi-tests/cons-test-13.lsp
@@ -145,7 +145,7 @@
 
 ;;; Order of evaluation
 
-(deftest member.20
+(deftest member.order.1
   (let ((i 0) x y)
     (values
      (member (progn (setf x (incf i)) 'c)
@@ -153,7 +153,7 @@
      i x y))
   (c d) 2 1 2)
 
-(deftest member.21
+(deftest member.order.2
   (let ((i 0) x y z p)
     (values
      (member (progn (setf x (incf i)) 'c)
@@ -163,7 +163,7 @@
      i x y z p))
   (c d) 4 1 2 3 4)
 
-(deftest member.22
+(deftest member.order.3
   (let ((i 0) x y)
     (values
      (member (progn (setf x (incf i)) 'c)
@@ -172,7 +172,7 @@
      i x y))
   (c d) 2 1 2)
 
-(deftest member.23
+(deftest member.order.4
   (let ((i 0) x y z p q)
     (values
      (member (progn (setf x (incf i)) 'c)
@@ -183,7 +183,7 @@
      i x y z p q))
   (c d) 5 1 2 3 4 5)
 
-(deftest member.24
+(deftest member.order.5
   (let ((i 0) x y z q)
     (values
      (member (progn (setf x (incf i)) 'c)
diff --git a/ansi-tests/cons-test-14.lsp b/ansi-tests/cons-test-14.lsp
index 7a2ec3c4..b85acb74 100644
--- a/ansi-tests/cons-test-14.lsp
+++ b/ansi-tests/cons-test-14.lsp
@@ -46,7 +46,7 @@
 
 ;;; Order of argument tests
 
-(deftest member-if.6
+(deftest member-if.order.1
   (let ((i 0) x y)
     (values
      (member-if (progn (setf x (incf i))
@@ -56,7 +56,7 @@
      i x y))
   (a b nil c d) 2 1 2)
 
-(deftest member-if.7
+(deftest member-if.order.2
   (let ((i 0) x y z w)
     (values
      (member-if (progn (setf x (incf i))
@@ -140,7 +140,7 @@
 
 ;;; Order of evaluation tests
 
-(deftest member-if-not.6
+(deftest member-if-not.order.1
   (let ((i 0) x y)
     (values
      (member-if-not (progn (setf x (incf i))
@@ -150,7 +150,7 @@
      i x y))
   (a b nil c d) 2 1 2)
 
-(deftest member-if-not.7
+(deftest member-if-not.order.2
   (let ((i 0) x y z w)
     (values
      (member-if-not (progn (setf x (incf i))
diff --git a/ansi-tests/cons-test-15.lsp b/ansi-tests/cons-test-15.lsp
index 4ef9ce2b..9d82f3cf 100644
--- a/ansi-tests/cons-test-15.lsp
+++ b/ansi-tests/cons-test-15.lsp
@@ -576,6 +576,3 @@
 (deftest mapcon.error.4
   (classify-error (locally (mapcon #'identity 1) t))
   type-error)
-
-
-
diff --git a/ansi-tests/cons-test-16.lsp b/ansi-tests/cons-test-16.lsp
index 10420154..0210a2ad 100644
--- a/ansi-tests/cons-test-16.lsp
+++ b/ansi-tests/cons-test-16.lsp
@@ -40,7 +40,7 @@
   (acons #\R :foo :bar)
   ((#\R . :foo) . :bar))
 
-(deftest acons.7
+(deftest acons.order.1
   (let ((i 0) x y z)
     (values
      (acons (progn (setf x (incf i)) 'a)
@@ -206,7 +206,7 @@
 
 ;;; Order of argument evaluation
 
-(deftest assoc.26
+(deftest assoc.order.1
   (let ((i 0) x y)
     (values
      (assoc (progn (setf x (incf i)) 'c)
@@ -214,7 +214,7 @@
      i x y))
   (c . 3) 2 1 2)
 
-(deftest assoc.27
+(deftest assoc.order.2
   (let ((i 0) x y z)
     (values
      (assoc (progn (setf x (incf i)) 'c)
@@ -223,7 +223,7 @@
      i x y z))
   (c . 3) 3 1 2 3)
 
-(deftest assoc.28
+(deftest assoc.order.3
   (let ((i 0) x y)
     (values
      (assoc (progn (setf x (incf i)) 'c)
@@ -232,7 +232,7 @@
      i x y))
   (c . 3) 2 1 2)
 
-(deftest assoc.29
+(deftest assoc.order.4
   (let ((i 0) x y z w)
     (values
      (assoc (progn (setf x (incf i)) 'c)
@@ -337,7 +337,7 @@
 
 ;;; Order of argument evaluation
 
-(deftest assoc-if.5
+(deftest assoc-if.order.1
   (let ((i 0) x y)
     (values
      (assoc-if (progn (setf x (incf i)) #'null)
@@ -346,7 +346,7 @@
      i x y))
   (nil . 17) 2 1 2)
 
-(deftest assoc-if.6
+(deftest assoc-if.order.2
   (let ((i 0) x y z)
     (values
      (assoc-if (progn (setf x (incf i)) #'null)
@@ -453,7 +453,7 @@
 
 ;;; Order of argument evaluation tests
 
-(deftest assoc-if-not.5
+(deftest assoc-if-not.order.1
   (let ((i 0) x y)
     (values
      (assoc-if-not (progn (setf x (incf i)) #'identity)
@@ -462,7 +462,7 @@
      i x y))
   (nil . 17) 2 1 2)
 
-(deftest assoc-if-not.6
+(deftest assoc-if-not.order.2
   (let ((i 0) x y z)
     (values
      (assoc-if-not (progn (setf x (incf i)) #'identity)
diff --git a/ansi-tests/cons-test-17.lsp b/ansi-tests/cons-test-17.lsp
index d764aa42..862e42c6 100644
--- a/ansi-tests/cons-test-17.lsp
+++ b/ansi-tests/cons-test-17.lsp
@@ -193,7 +193,7 @@
 
 ;;; Order of argument evaluation
 
-(deftest rassoc.26
+(deftest rassoc.order.1
   (let ((i 0) x y)
     (values
      (rassoc (progn (setf x (incf i)) 'c)
@@ -201,7 +201,7 @@
      i x y))
   (3 . c) 2 1 2)
 
-(deftest rassoc.27
+(deftest rassoc.order.2
   (let ((i 0) x y z)
     (values
      (rassoc (progn (setf x (incf i)) 'c)
@@ -210,7 +210,7 @@
      i x y z))
   (3 . c) 3 1 2 3)
 
-(deftest rassoc.28
+(deftest rassoc.order.3
   (let ((i 0) x y)
     (values
      (rassoc (progn (setf x (incf i)) 'c)
@@ -219,7 +219,7 @@
      i x y))
   (3 . c) 2 1 2)
 
-(deftest rassoc.29
+(deftest rassoc.order.4
   (let ((i 0) x y z w)
     (values
      (rassoc (progn (setf x (incf i)) 'c)
@@ -324,7 +324,7 @@
 
 ;;; Order of argument evaluation
 
-(deftest rassoc-if.5
+(deftest rassoc-if.order.1
   (let ((i 0) x y)
     (values
      (rassoc-if (progn (setf x (incf i)) #'null)
@@ -333,7 +333,7 @@
      i x y))
   (17) 2 1 2)
 
-(deftest rassoc-if.6
+(deftest rassoc-if.order.2
   (let ((i 0) x y z)
     (values
      (rassoc-if (progn (setf x (incf i)) #'null)
@@ -437,7 +437,7 @@
 
 ;;; Order of argument evaluation
 
-(deftest rassoc-if-not.5
+(deftest rassoc-if-not.order.1
   (let ((i 0) x y)
     (values
      (rassoc-if-not (progn (setf x (incf i)) #'identity)
@@ -446,7 +446,7 @@
      i x y))
   (17) 2 1 2)
 
-(deftest rassoc-if-not.6
+(deftest rassoc-if-not.order.2
   (let ((i 0) x y z)
     (values
      (rassoc-if-not (progn (setf x (incf i)) #'identity)
diff --git a/ansi-tests/cons-test-18.lsp b/ansi-tests/cons-test-18.lsp
index 60cef34a..41180137 100644
--- a/ansi-tests/cons-test-18.lsp
+++ b/ansi-tests/cons-test-18.lsp
@@ -57,7 +57,7 @@
        (values indicator value tail))))
   g h (g h a c))
 
-(deftest get-properties.10
+(deftest get-properties.order.1
   (let ((i 0) x y)
     (values
      (multiple-value-list
@@ -105,7 +105,7 @@
      x))
   b 1)
 
-(deftest getf.6
+(deftest getf.order.1
   (let ((i 0) x y)
     (values
      (getf (progn (setf x (incf i)) '(a b))
@@ -113,7 +113,7 @@
      i x y))
   b 2 1 2)
 		  
-(deftest getf.7
+(deftest getf.order.2
   (let ((i 0) x y z)
     (values
      (getf (progn (setf x (incf i)) '(a b))
@@ -200,7 +200,7 @@
      foo))
   t)
 
-(deftest setf-getf.6
+(deftest setf-getf.order.1
   (let ((p (list (copy-list '(a 1 b 2))))
 	(cnt1 0) (cnt2 0) (cnt3 0))
     (setf (getf (car (progn (incf cnt1) p)) 'c (incf cnt3))
@@ -221,7 +221,7 @@
      t))
   t)
 
-(deftest setf-getf.7
+(deftest setf-getf.order.2
   (let ((p (list (copy-list '(a 1 b 2))))
 	(i 0) x y z w)
     (setf (getf (car (progn (setf x (incf i)) p))
@@ -323,7 +323,7 @@
       (not (eqt (car ptr) 'a)))))
   t 0)
 
-(deftest remf.5
+(deftest remf.order.1
   (let ((i 0) x y
 	(p (make-array 1 :initial-element (copy-list '(a b c d e f)))))
     (values
diff --git a/ansi-tests/cons-test-19.lsp b/ansi-tests/cons-test-19.lsp
index 9037a848..91f1fec2 100644
--- a/ansi-tests/cons-test-19.lsp
+++ b/ansi-tests/cons-test-19.lsp
@@ -237,7 +237,7 @@
 
 ;;; Order of argument evaluation tests
 
-(deftest intersection.19
+(deftest intersection.order.1
   (let ((i 0) x y)
     (values
      (intersection (progn (setf x (incf i)) (list 'a 'b))
@@ -245,7 +245,7 @@
      i x y))
   nil 2 1 2)
 
-(deftest intersection.20
+(deftest intersection.order.2
   (let ((i 0) x y)
     (values
      (intersection (progn (setf x (incf i)) (list 'a 'b))
@@ -254,7 +254,7 @@
      i x y))
   nil 2 1 2)
 
-(deftest intersection.21
+(deftest intersection.order.3
   (let ((i 0) x y z w)
     (values
      (intersection (progn (setf x (incf i)) (list 'a 'b))
@@ -265,7 +265,7 @@
      i x y z w))
   nil 4 1 2 3 4)
 
-(deftest intersection.22
+(deftest intersection.order.4
   (let ((i 0) x y z w)
     (values
      (intersection (progn (setf x (incf i)) (list 'a 'b))
@@ -275,7 +275,7 @@
      i x y z w))
   nil 4 1 2 3 4)
 
-(deftest intersection.23
+(deftest intersection.order.5
   (let ((i 0) x y z w)
     (values
      (intersection (progn (setf x (incf i)) (list 'a 'b))
@@ -566,7 +566,7 @@
 
 ;;; Order of argument evaluation tests
 
-(deftest nintersection.19
+(deftest nintersection.order.1
   (let ((i 0) x y)
     (values
      (nintersection (progn (setf x (incf i)) (list 'a 'b))
@@ -574,7 +574,7 @@
      i x y))
   nil 2 1 2)
 
-(deftest nintersection.20
+(deftest nintersection.order.2
   (let ((i 0) x y)
     (values
      (nintersection (progn (setf x (incf i)) (list 'a 'b))
@@ -583,7 +583,7 @@
      i x y))
   nil 2 1 2)
 
-(deftest nintersection.21
+(deftest nintersection.order.3
   (let ((i 0) x y z w)
     (values
      (nintersection (progn (setf x (incf i)) (list 'a 'b))
@@ -594,7 +594,7 @@
      i x y z w))
   nil 4 1 2 3 4)
 
-(deftest nintersection.22
+(deftest nintersection.order.4
   (let ((i 0) x y z w)
     (values
      (nintersection (progn (setf x (incf i)) (list 'a 'b))
@@ -604,7 +604,7 @@
      i x y z w))
   nil 4 1 2 3 4)
 
-(deftest nintersection.23
+(deftest nintersection.order.5
   (let ((i 0) x y z w)
     (values
      (nintersection (progn (setf x (incf i)) (list 'a 'b))
diff --git a/ansi-tests/cons-test-20.lsp b/ansi-tests/cons-test-20.lsp
index d0a50bde..e61b5e48 100644
--- a/ansi-tests/cons-test-20.lsp
+++ b/ansi-tests/cons-test-20.lsp
@@ -266,7 +266,7 @@
 
 ;;; Order of evaluation tests
 
-(deftest union.32
+(deftest union.order.1
   (let ((i 0) x y)
     (values
      (sort
@@ -277,7 +277,7 @@
   (1 2 3 5 8)
   2 1 2)
 
-(deftest union.33
+(deftest union.order.2
   (let ((i 0) x y z w)
     (values
      (sort
@@ -291,7 +291,7 @@
   4 1 2 3 4)
 
 
-(deftest union.34
+(deftest union.order.3
   (let ((i 0) x y z w)
     (values
      (sort
diff --git a/ansi-tests/cons-test-21.lsp b/ansi-tests/cons-test-21.lsp
index fe1e631b..ef5c39a7 100644
--- a/ansi-tests/cons-test-21.lsp
+++ b/ansi-tests/cons-test-21.lsp
@@ -265,39 +265,39 @@
 
 ;;; Order of evaluation tests
 
-(deftest nunion.32
+(deftest nunion.order.1
   (let ((i 0) x y)
     (values
      (sort
       (nunion (progn (setf x (incf i)) (copy-list '(1 3 5)))
-	     (progn (setf y (incf i)) (copy-list '(2 5 8))))
+	      (progn (setf y (incf i)) (copy-list '(2 5 8))))
       #'<)
      i x y))
   (1 2 3 5 8)
   2 1 2)
 
-(deftest nunion.33
+(deftest nunion.order.2
   (let ((i 0) x y z w)
     (values
      (sort
       (nunion (progn (setf x (incf i)) (copy-list '(1 3 5)))
-	     (progn (setf y (incf i)) (copy-list '(2 5 8)))
-	     :test (progn (setf z (incf i)) #'eql)
-	     :key (progn (setf w (incf i)) #'identity))
+	      (progn (setf y (incf i)) (copy-list '(2 5 8)))
+	      :test (progn (setf z (incf i)) #'eql)
+	      :key (progn (setf w (incf i)) #'identity))
       #'<)
      i x y z w))
   (1 2 3 5 8)
   4 1 2 3 4)
 
 
-(deftest nunion.34
+(deftest nunion.order.3
   (let ((i 0) x y z w)
     (values
      (sort
       (nunion (progn (setf x (incf i)) (copy-list '(1 3 5)))
-	     (progn (setf y (incf i)) (copy-list '(2 5 8)))
-	     :key (progn (setf z (incf i)) #'identity)
-	     :test (progn (setf w (incf i)) #'eql))
+	      (progn (setf y (incf i)) (copy-list '(2 5 8)))
+	      :key (progn (setf z (incf i)) #'identity)
+	      :test (progn (setf w (incf i)) #'eql))
       #'<)
      i x y z w))
   (1 2 3 5 8)
diff --git a/ansi-tests/cons-test-22.lsp b/ansi-tests/cons-test-22.lsp
index 9bf663cd..8ead25af 100644
--- a/ansi-tests/cons-test-22.lsp
+++ b/ansi-tests/cons-test-22.lsp
@@ -151,7 +151,7 @@
 
 ;;; Order of argument evaluation tests
 
-(deftest set-difference.20
+(deftest set-difference.order.1
   (let ((i 0) x y)
     (values
      (set-difference (progn (setf x (incf i)) (list 1 2 3 4))
@@ -159,7 +159,7 @@
      i x y))
   (1) 2 1 2)
 
-(deftest set-difference.21
+(deftest set-difference.order.2
   (let ((i 0) x y z)
     (values
      (set-difference (progn (setf x (incf i)) (list 1 2 3 4))
@@ -169,7 +169,7 @@
      i x y z))
   (4) 3 1 2 3)
 
-(deftest set-difference.22
+(deftest set-difference.order.3
   (let ((i 0) x y z w)
     (values
      (set-difference (progn (setf x (incf i)) (list 1 2 3 4))
@@ -437,7 +437,7 @@
 
 ;;; Order of argument evaluation tests
 
-(deftest nset-difference.20
+(deftest nset-difference.order.1
   (let ((i 0) x y)
     (values
      (nset-difference (progn (setf x (incf i)) (list 1 2 3 4))
@@ -445,7 +445,7 @@
      i x y))
   (1) 2 1 2)
 
-(deftest nset-difference.21
+(deftest nset-difference.order.2
   (let ((i 0) x y z)
     (values
      (nset-difference (progn (setf x (incf i)) (list 1 2 3 4))
@@ -455,7 +455,7 @@
      i x y z))
   (4) 3 1 2 3)
 
-(deftest nset-difference.22
+(deftest nset-difference.order.3
   (let ((i 0) x y z w)
     (values
      (nset-difference (progn (setf x (incf i)) (list 1 2 3 4))
diff --git a/ansi-tests/cons-test-23.lsp b/ansi-tests/cons-test-23.lsp
index 971e3868..be6e92ea 100644
--- a/ansi-tests/cons-test-23.lsp
+++ b/ansi-tests/cons-test-23.lsp
@@ -173,7 +173,7 @@
 
 ;;; Order of argument evaluation tests
 
-(deftest set-exclusive-or.19
+(deftest set-exclusive-or.order.1
   (let ((i 0) x y)
     (values
      (sort
@@ -185,7 +185,7 @@
      i x y))
   (2 4 6 10) 2 1 2)
 
-(deftest set-exclusive-or.20
+(deftest set-exclusive-or.order.2
   (let ((i 0) x y z)
     (values
      (sort
@@ -199,7 +199,7 @@
      i x y z))
   (2 4 6 10) 3 1 2 3)
 
-(deftest set-exclusive-or.21
+(deftest set-exclusive-or.order.3
   (let ((i 0) x y z w)
     (values
      (sort
@@ -214,7 +214,7 @@
      i x y z w))
   (2 4 6 10) 4 1 2 3 4)
 
-(deftest set-exclusive-or.22
+(deftest set-exclusive-or.order.4
   (let ((i 0) x y z w)
     (values
      (sort
@@ -229,7 +229,7 @@
      i x y z w))
   (2 4 6 10) 4 1 2 3 4)
 
-(deftest set-exclusive-or.23
+(deftest set-exclusive-or.order.5
   (let ((i 0) x y z w)
     (values
      (sort
@@ -498,73 +498,73 @@
 
 ;;; Order of argument evaluation tests
 
-(deftest nset-exclusive-or.19
+(deftest nset-exclusive-or.order.1
   (let ((i 0) x y)
     (values
      (sort
       (nset-exclusive-or (progn (setf x (incf i))
-			       (list 1 2 3 4))
-			(progn (setf y (incf i))
-			       (list 1 3 6 10)))
+				(list 1 2 3 4))
+			 (progn (setf y (incf i))
+				(list 1 3 6 10)))
       #'<)
      i x y))
   (2 4 6 10) 2 1 2)
 
-(deftest nset-exclusive-or.20
+(deftest nset-exclusive-or.order.2
   (let ((i 0) x y z)
     (values
      (sort
       (nset-exclusive-or (progn (setf x (incf i))
-			       (list 1 2 3 4))
-			(progn (setf y (incf i))
-			       (list 1 3 6 10))
-			:test (progn (setf z (incf i))
-				     #'eql))
+				(list 1 2 3 4))
+			 (progn (setf y (incf i))
+				(list 1 3 6 10))
+			 :test (progn (setf z (incf i))
+				      #'eql))
       #'<)
      i x y z))
   (2 4 6 10) 3 1 2 3)
 
-(deftest nset-exclusive-or.21
+(deftest nset-exclusive-or.order.3
   (let ((i 0) x y z w)
     (values
      (sort
       (nset-exclusive-or (progn (setf x (incf i))
-			       (list 1 2 3 4))
-			(progn (setf y (incf i))
-			       (list 1 3 6 10))
-			:test (progn (setf z (incf i))
-				     #'eql)
-			:key (progn (setf w (incf i)) nil))
+				(list 1 2 3 4))
+			 (progn (setf y (incf i))
+				(list 1 3 6 10))
+			 :test (progn (setf z (incf i))
+				      #'eql)
+			 :key (progn (setf w (incf i)) nil))
       #'<)
      i x y z w))
   (2 4 6 10) 4 1 2 3 4)
 
-(deftest nset-exclusive-or.22
+(deftest nset-exclusive-or.order.4
   (let ((i 0) x y z w)
     (values
      (sort
       (nset-exclusive-or (progn (setf x (incf i))
-			       (list 1 2 3 4))
-			(progn (setf y (incf i))
-			       (list 1 3 6 10))
-			:key (progn (setf z (incf i)) nil)
-			:test (progn (setf w (incf i))
-				     #'eql))
+				(list 1 2 3 4))
+			 (progn (setf y (incf i))
+				(list 1 3 6 10))
+			 :key (progn (setf z (incf i)) nil)
+			 :test (progn (setf w (incf i))
+				      #'eql))
       #'<)
      i x y z w))
   (2 4 6 10) 4 1 2 3 4)
 
-(deftest nset-exclusive-or.23
+(deftest nset-exclusive-or.order.5
   (let ((i 0) x y z w)
     (values
      (sort
       (nset-exclusive-or (progn (setf x (incf i))
-			       (list 1 2 3 4))
-			(progn (setf y (incf i))
-			       (list 1 3 6 10))
-			:key (progn (setf z (incf i)) nil)
-			:key (progn (setf w (incf i))
-				    (complement #'eql)))
+				(list 1 2 3 4))
+			 (progn (setf y (incf i))
+				(list 1 3 6 10))
+			 :key (progn (setf z (incf i)) nil)
+			 :key (progn (setf w (incf i))
+				     (complement #'eql)))
       #'<)
      i x y z w))
   (2 4 6 10) 4 1 2 3 4)
diff --git a/ansi-tests/cons-test-24.lsp b/ansi-tests/cons-test-24.lsp
index 800c51dc..806aaff4 100644
--- a/ansi-tests/cons-test-24.lsp
+++ b/ansi-tests/cons-test-24.lsp
@@ -128,7 +128,7 @@
 
 ;;; Order of argument evaluation tests
 
-(deftest subsetp.16
+(deftest subsetp.order.1
   (let ((i 0) x y)
     (values
      (notnot (subsetp (progn (setf x (incf i))
@@ -138,7 +138,7 @@
      i x y))
   t 2 1 2)
 
-(deftest subsetp.17
+(deftest subsetp.order.2
   (let ((i 0) x y z w)
     (values
      (notnot (subsetp (progn (setf x (incf i))
@@ -150,7 +150,7 @@
      i x y z w))
   t 4 1 2 3 4)
 
-(deftest subsetp.18
+(deftest subsetp.order.3
   (let ((i 0) x y z w)
     (values
      (notnot (subsetp (progn (setf x (incf i))
@@ -162,8 +162,6 @@
      i x y z w))
   t 4 1 2 3 4)
 
-
-
 ;;; Keyword tests
 
 (deftest subsetp.allow-other-keys.1
diff --git a/ansi-tests/constantly.lsp b/ansi-tests/constantly.lsp
index a68a295c..59d71430 100644
--- a/ansi-tests/constantly.lsp
+++ b/ansi-tests/constantly.lsp
@@ -17,10 +17,21 @@
   (notnot-mv (cl:constantly 1))
   t)
 
+(deftest constantly.3
+  (let ((i 0))
+    (let ((fn (cl:constantly (progn (incf i) 'a))))
+      (values
+       i
+       (mapcar fn '(1 2 3 4))
+       i)))
+  1 (a a a a) 1)
+
 (deftest constantly.error.1
   (classify-error (cl:constantly))
   program-error)
 
+;;; The next test fails in CMUCL, which has non-conformantly extended
+;;; the syntax of constantly.
 (deftest constantly.error.2
   (classify-error (cl:constantly 1 1))
   program-error)
diff --git a/ansi-tests/constantp.lsp b/ansi-tests/constantp.lsp
index 39f650d2..99556a20 100644
--- a/ansi-tests/constantp.lsp
+++ b/ansi-tests/constantp.lsp
@@ -66,6 +66,13 @@
   t)
 
 (deftest constantp.order.1
+  (let ((i 0))
+    (values
+     (notnot (constantp (progn (incf i) 1)))
+     i))
+  t 1)
+
+(deftest constantp.order.2
   (let ((i 0) x y)
     (values
      (notnot (constantp (progn (setf x (incf i)) 1)
diff --git a/ansi-tests/copy-seq.lsp b/ansi-tests/copy-seq.lsp
index 51b1afc5..bb2cd1e1 100644
--- a/ansi-tests/copy-seq.lsp
+++ b/ansi-tests/copy-seq.lsp
@@ -154,6 +154,11 @@
     (equal-array x y))
   t)
 
+(deftest copy-seq.order.1
+  (let ((i 0))
+    (values (copy-seq (progn (incf i) "abc")) i))
+  "abc" 1)
+
 ;;; Error tests
 
 (deftest copy-seq.error.1
diff --git a/ansi-tests/count-if-not.lsp b/ansi-tests/count-if-not.lsp
index 4b1a7d31..2e5603c2 100644
--- a/ansi-tests/count-if-not.lsp
+++ b/ansi-tests/count-if-not.lsp
@@ -420,7 +420,7 @@
 
 ;;; Argument order tests
 
-(deftest count-if-not-order.1
+(deftest count-if-not.order.1
   (let ((i 0) c1 c2 c3 c4 c5 c6)
     (values
      (count-if-not
@@ -434,7 +434,7 @@
      i c1 c2 c3 c4 c5 c6))
   1 6 1 2 3 4 5 6)
 
-(deftest count-if-not-order.2
+(deftest count-if-not.order.2
   (let ((i 0) c1 c2 c3 c4 c5 c6)
     (values
      (count-if-not
diff --git a/ansi-tests/count-if.lsp b/ansi-tests/count-if.lsp
index 074bfe6c..cbc32e87 100644
--- a/ansi-tests/count-if.lsp
+++ b/ansi-tests/count-if.lsp
@@ -419,7 +419,7 @@
 
 ;;; Argument order tests
 
-(deftest count-if-order.1
+(deftest count-if.order.1
   (let ((i 0) c1 c2 c3 c4 c5 c6)
     (values
      (count-if (progn (setf c1 (incf i)) #'null)
@@ -432,7 +432,7 @@
      i c1 c2 c3 c4 c5 c6))
   1 6 1 2 3 4 5 6)
 
-(deftest count-if-order.2
+(deftest count-if.order.2
   (let ((i 0) c1 c2 c3 c4 c5 c6)
     (values
      (count-if (progn (setf c1 (incf i)) #'null)
diff --git a/ansi-tests/count.lsp b/ansi-tests/count.lsp
index c43c79e4..33939db3 100644
--- a/ansi-tests/count.lsp
+++ b/ansi-tests/count.lsp
@@ -488,7 +488,7 @@
 
 ;;; Argument order tests
 
-(deftest count-order.1
+(deftest count.order.1
   (let ((i 0) c1 c2 c3 c4 c5 c6 c7)
     (values
      (count (progn (setf c1 (incf i)) nil)
@@ -502,7 +502,7 @@
      i c1 c2 c3 c4 c5 c6 c7))
   1 7 1 2 3 4 5 6 7)
 
-(deftest count-order.2
+(deftest count.order.2
   (let ((i 0) c1 c2 c3 c4 c5 c6 c7)
     (values
      (count (progn (setf c1 (incf i)) nil)
diff --git a/ansi-tests/elt.lsp b/ansi-tests/elt.lsp
index 22da964c..16698ccf 100644
--- a/ansi-tests/elt.lsp
+++ b/ansi-tests/elt.lsp
@@ -9,30 +9,30 @@
 
 ;; elt on lists
 
-(deftest elt-1
+(deftest elt.1
   (classify-error (elt nil 0))
   type-error)
 
-(deftest elt-1a
+(deftest elt.1a
   (classify-error (elt nil -10))
   type-error)
 
-(deftest elt-1b
+(deftest elt.1b
   (classify-error (locally (elt nil 0) t))
   type-error)
 
-(deftest elt-2
+(deftest elt.2
   (classify-error (elt nil 1000000))
   type-error)
 
-(deftest elt-3 (elt '(a b c d e) 0) a)
-(deftest elt-4 (elt '(a b c d e) 2) c)
-(deftest elt-5 (elt '(a b c d e) 4) e)
-(deftest elt-5a 
+(deftest elt.3 (elt '(a b c d e) 0) a)
+(deftest elt.4 (elt '(a b c d e) 2) c)
+(deftest elt.5 (elt '(a b c d e) 4) e)
+(deftest elt.5a 
   (classify-error (elt '(a b c d e) -4))
   type-error)
 
-(deftest elt-6
+(deftest elt.6
   (let ((x (make-int-list 1000)))
     (notnot-mv
      (every
@@ -40,31 +40,31 @@
       x)))
   t)
 
-(deftest elt-7
+(deftest elt.7
   (let* ((x (list 'a 'b 'c 'd))
 	 (y (setf (elt x 0) 'e)))
     (list x y))
   ((e b c d) e))
 
-(deftest elt-8
+(deftest elt.8
   (let* ((x (list 'a 'b 'c 'd))
 	 (y (setf (elt x 1) 'e)))
     (list x y))
   ((a e c d) e))
 
-(deftest elt-9
+(deftest elt.9
   (let* ((x (list 'a 'b 'c 'd))
 	 (y (setf (elt x 3) 'e)))
     (list x y))
   ((a b c e) e))
 
-(deftest elt-10
+(deftest elt.10
   (classify-error
    (let ((x (list 'a 'b 'c)))
      (setf (elt x 4) 'd)))
   type-error)
 
-(deftest elt-11
+(deftest elt.11
   (let ((x (list 'a 'b 'c 'd 'e)))
     (let ((y (loop for c on x collect c)))
       (setf (elt x 2) 'f)
@@ -74,12 +74,12 @@
 	      (loop for c on x collect c)))))
   t)
 
-(deftest elt-12
+(deftest elt.12
   (let ((x (make-int-list 100000)))
     (elt x 90000))
   90000)
 
-(deftest elt-13
+(deftest elt.13
   (let ((x (make-int-list 100000)))
     (setf (elt x 80000) 'foo)
     (list (elt x 79999)
@@ -87,43 +87,43 @@
 	  (elt x 80001)))
   (79999 foo 80001))
 
-(deftest elt-14
+(deftest elt.14
   (classify-error
    (let ((x (list 'a 'b 'c)))
      (elt x 10)))
   type-error)
 
-(deftest elt-15
+(deftest elt.15
   (classify-error
    (let ((x (list 'a 'b 'c)))
      (elt x 'a)))
   type-error)
 
-(deftest elt-16
+(deftest elt.16
   (classify-error
    (let ((x (list 'a 'b 'c)))
      (elt x 10.0)))
   type-error)
 
-(deftest elt-17
+(deftest elt.17
   (classify-error
    (let ((x (list 'a 'b 'c)))
      (elt x -1)))
   type-error)
 
-(deftest elt-18
+(deftest elt.18
   (classify-error
    (let ((x (list 'a 'b 'c)))
      (elt x -100000000000000000)))
   type-error)
 
-(deftest elt-19
+(deftest elt.19
   (classify-error
    (let ((x (list 'a 'b 'c)))
      (elt x #\w)))
   type-error)
 
-(deftest elt.20
+(deftest elt.order.1
   (let ((i 0) x y)
     (values
      (elt (progn (setf x (incf i)) '(a b c d e))
@@ -131,7 +131,7 @@
      i x y))
   d 2 1 2)
 
-(deftest elt.21
+(deftest elt.order.2
   (let ((i 0) x y z)
     (let ((a (make-array 1 :initial-element (list 'a 'b 'c 'd 'e))))
       (values
@@ -142,64 +142,64 @@
        i x y z)))
   k (a b c k e) 3 1 2 3)
 
-(deftest elt-v-1
+(deftest elt-v.1
   (classify-error
    (elt (make-array '(0)) 0))
   type-error)
 
-;; (deftest elt-v-2 (elt (make-array '(1)) 0) nil)  ;; actually undefined
-(deftest elt-v-3
+;; (deftest elt-v.2 (elt (make-array '(1)) 0) nil)  ;; actually undefined
+(deftest elt-v.3
   (elt (make-array '(5) :initial-contents '(a b c d e)) 0)
   a)
 
-(deftest elt-v-4
+(deftest elt-v.4
   (elt (make-array '(5) :initial-contents '(a b c d e)) 2)
   c)
 
-(deftest elt-v-5
+(deftest elt-v.5
   (elt (make-array '(5) :initial-contents '(a b c d e)) 4)
   e)
 
-(deftest elt-v-6
+(deftest elt-v.6
     (elt-v-6-body)
   t)
 
-(deftest elt-v-7
+(deftest elt-v.7
   (let* ((x (make-array '(4) :initial-contents (list 'a 'b 'c 'd)))
 	 (y (setf (elt x 0) 'e)))
     (list (elt x 0) (elt x 1) (elt x 2) (elt x 3) y))
   (e b c d e))
 
-(deftest elt-v-8
+(deftest elt-v.8
   (let* ((x (make-array '(4) :initial-contents (list 'a 'b 'c 'd)))
 	 (y (setf (elt x 1) 'e)))
     (list (elt x 0) (elt x 1) (elt x 2) (elt x 3) y))
   (a e c d e))
 
-(deftest elt-v-9
+(deftest elt-v.9
   (let* ((x (make-array '(4) :initial-contents (list 'a 'b 'c 'd)))
 	 (y (setf (elt x 3) 'e)))
     (list (elt x 0) (elt x 1) (elt x 2) (elt x 3) y))
   (a b c e e))
 
-(deftest elt-v-10
+(deftest elt-v.10
   (classify-error
    (let ((x (make-array '(3) :initial-contents (list 'a 'b 'c))))
      (setf (elt x 4) 'd)))
   type-error)
 
-(deftest elt-v-11
+(deftest elt-v.11
   (classify-error
    (let ((x (make-array '(3) :initial-contents (list 'a 'b 'c))))
      (setf (elt x -100) 'd)))
   type-error)
 
-(deftest elt-v-12
+(deftest elt-v.12
     (let ((x (make-int-array 100000)))
       (elt x 90000))
   90000)
 
-(deftest elt-v-13
+(deftest elt-v.13
   (let ((x (make-int-array 100000)))
     (setf (elt x 80000) 'foo)
     (list (elt x 79999)
@@ -209,64 +209,64 @@
 
 ;;;  Adjustable arrays
 
-(deftest elt-adj-array-1
+(deftest elt-adj-array.1
   (classify-error (elt (make-adj-array '(0)) 0))
   type-error)
 
-;;; (deftest elt-adj-array-2 (elt (make-adj-array '(1)) 0) nil) ;; actually undefined 
+;;; (deftest elt-adj-array.2 (elt (make-adj-array '(1)) 0) nil) ;; actually undefined 
 
-(deftest elt-adj-array-3
+(deftest elt-adj-array.3
  (elt (make-adj-array '(5) :initial-contents '(a b c d e)) 0)
   a)
 
-(deftest elt-adj-array-4
+(deftest elt-adj-array.4
  (elt (make-adj-array '(5) :initial-contents '(a b c d e)) 2)
   c)
 
-(deftest elt-adj-array-5
+(deftest elt-adj-array.5
  (elt (make-adj-array '(5) :initial-contents '(a b c d e)) 4)
   e)
 
-(deftest elt-adj-array-6
+(deftest elt-adj-array.6
     (elt-adj-array-6-body)
   t)
 
-(deftest elt-adj-array-7
+(deftest elt-adj-array.7
   (let* ((x (make-adj-array '(4) :initial-contents (list 'a 'b 'c 'd)))
 	 (y (setf (elt x 0) 'e)))
     (list (elt x 0) (elt x 1) (elt x 2) (elt x 3) y))
   (e b c d e))
 
-(deftest elt-adj-array-8
+(deftest elt-adj-array.8
   (let* ((x (make-adj-array '(4) :initial-contents (list 'a 'b 'c 'd)))
 	 (y (setf (elt x 1) 'e)))
     (list (elt x 0) (elt x 1) (elt x 2) (elt x 3) y))
   (a e c d e))
 
-(deftest elt-adj-array-9
+(deftest elt-adj-array.9
   (let* ((x (make-adj-array '(4) :initial-contents (list 'a 'b 'c 'd)))
 	 (y (setf (elt x 3) 'e)))
     (list (elt x 0) (elt x 1) (elt x 2) (elt x 3) y))
   (a b c e e))
 
-(deftest elt-adj-array-10
+(deftest elt-adj-array.10
   (classify-error
    (let ((x (make-adj-array '(3) :initial-contents (list 'a 'b 'c))))
      (setf (elt x 4) 'd)))
   type-error)
 
-(deftest elt-adj-array-11
+(deftest elt-adj-array.11
   (classify-error
    (let ((x (make-adj-array '(3) :initial-contents (list 'a 'b 'c))))
      (setf (elt x -100) 'd)))
   type-error)
 
-(deftest elt-adj-array-12
+(deftest elt-adj-array.12
     (let ((x (make-int-array 100000 #'make-adj-array)))
       (elt x 90000))
   90000)
 
-(deftest elt-adj-array-13
+(deftest elt-adj-array.13
     (let ((x (make-int-array 100000 #'make-adj-array)))
     (setf (elt x 80000) 'foo)
     (list (elt x 79999)
@@ -276,27 +276,27 @@
 
 ;; displaced arrays
 
-(deftest elt-displaced-array-1 
+(deftest elt-displaced-array.1 
   (classify-error (elt (make-displaced-array '(0) 100) 0))
   type-error)
 
-(deftest elt-displaced-array-2
+(deftest elt-displaced-array.2
   (elt (make-displaced-array '(1) 100) 0)
   100)
 
-(deftest elt-displaced-array-3
+(deftest elt-displaced-array.3
   (elt (make-displaced-array '(5) 100) 4)
   104)
 
 ;;; Arrays with fill points
 
-(deftest elt-fill-pointer-1
+(deftest elt-fill-pointer.1
   (let ((a (make-array '(5) :initial-contents '(a b c d e)
 		       :fill-pointer 3)))
     (values (elt a 0) (elt a 1) (elt a 2)))
   a b c)
 
-(deftest elt-fill-pointer-2
+(deftest elt-fill-pointer.2
   (let ((a (make-array '(5)
 		       :initial-contents '(0 0 1 0 0)
 		       :element-type 'bit
@@ -304,7 +304,7 @@
     (values (elt a 0) (elt a 1) (elt a 2)))
   0 0 1)
 
-(deftest elt-fill-pointer-3
+(deftest elt-fill-pointer.3
   (classify-error
    (let ((a (make-array '(5)
 			:initial-contents '(0 0 1 0 0)
@@ -312,7 +312,7 @@
      (elt a 4)))
   type-error)
 
-(deftest elt-fill-pointer-4
+(deftest elt-fill-pointer.4
   (classify-error
    (let ((a (make-array '(5)
 			:initial-contents '(0 0 1 0 0)
@@ -321,7 +321,7 @@
      (elt a 4)))
   type-error)
 
-(deftest elt-fill-pointer-5
+(deftest elt-fill-pointer.5
    (let ((a (make-array '(5)
 			:initial-contents '(#\a #\b #\c #\d #\e)
 			:element-type 'character
@@ -329,7 +329,7 @@
      (values (elt a 0) (elt a 1) (elt a 2)))
    #\a #\b #\c)
 
-(deftest elt-fill-pointer-6
+(deftest elt-fill-pointer.6
   (classify-error
    (let ((a (make-array '(5)
 			:initial-contents '(#\a #\b #\c #\d #\e)
@@ -338,7 +338,7 @@
      (elt a 4)))
   type-error)
 
-(deftest elt-fill-pointer-7
+(deftest elt-fill-pointer.7
    (let ((a (make-array '(5)
 			:initial-contents '(#\a #\b #\c #\d #\e)
 			:element-type 'base-char
@@ -346,7 +346,7 @@
      (values (elt a 0) (elt a 1) (elt a 2)))
    #\a #\b #\c)
 
-(deftest elt-fill-pointer-8
+(deftest elt-fill-pointer.8
   (classify-error
    (let ((a (make-array '(5)
 			:initial-contents '(#\a #\b #\c #\d #\e)
diff --git a/ansi-tests/eql.lsp b/ansi-tests/eql.lsp
index d5296562..10318a03 100644
--- a/ansi-tests/eql.lsp
+++ b/ansi-tests/eql.lsp
@@ -51,7 +51,7 @@
   (eqlt #c(1 -2) (- #c(-1 2)))
   t)
 
-(deftest eql.12
+(deftest eql.order.1
   (let ((i 0) x y)
     (values
      (eql (setf x (incf i)) (setf y (incf i)))
diff --git a/ansi-tests/equal.lsp b/ansi-tests/equal.lsp
index 6de2df1f..a2a52444 100644
--- a/ansi-tests/equal.lsp
+++ b/ansi-tests/equal.lsp
@@ -61,7 +61,7 @@
   (equalt (copy-seq #*000110) (copy-seq #*000111))
   nil)
 
-(deftest equal.13
+(deftest equal.order.1
   (let ((i 0) x y)
     (values
      (equal (setf x (incf i)) (setf y (incf i)))
diff --git a/ansi-tests/equalp.lsp b/ansi-tests/equalp.lsp
index cfb0f088..5248fc73 100644
--- a/ansi-tests/equalp.lsp
+++ b/ansi-tests/equalp.lsp
@@ -27,7 +27,7 @@
   (equalpt "abc" "abd")
   nil)
 
-(deftest equalp.5
+(deftest equalp.order.1
   (let ((i 0) x y)
     (values
      (equalp (setf x (incf i)) (setf y (incf i)))
diff --git a/ansi-tests/eval.lsp b/ansi-tests/eval.lsp
index a907a37a..cf16659d 100644
--- a/ansi-tests/eval.lsp
+++ b/ansi-tests/eval.lsp
@@ -31,6 +31,11 @@
   (funcall #'eval 1)
   1)
 
+(deftest eval.order.1
+  (let ((i 0))
+    (values (eval (progn (incf i) 10)) i))
+  10 1)
+
 ;;; Error cases
 
 (deftest eval.error.1
@@ -40,3 +45,8 @@
 (deftest eval.error.2
   (classify-error (eval nil nil))
   program-error)
+
+(deftest eval.error.3
+  (classify-error (eval (list (gensym))))
+  undefined-function)
+
diff --git a/ansi-tests/every.lsp b/ansi-tests/every.lsp
index 5aa79beb..a09c8047 100644
--- a/ansi-tests/every.lsp
+++ b/ansi-tests/every.lsp
@@ -78,7 +78,7 @@
   (notnot-mv (every 'null '(nil nil nil nil)))
   t)
 
-(deftest every.17
+(deftest every.order.1
   (let ((i 0) x y)
     (values
      (every (progn (setf x (incf i)) #'null)
@@ -86,6 +86,15 @@
      i x y))
   nil 2 1 2)
 
+(deftest every.order.2
+  (let ((i 0) x y z)
+    (values
+     (every (progn (setf x (incf i)) #'equal)
+	    (progn (setf y (incf i)) '(nil nil a nil))
+	    (progn (setf z (incf i)) '(nil nil a b)))
+     i x y z))
+  nil 3 1 2 3)
+
 ;;; Error cases
 
 (deftest every.error.1
diff --git a/ansi-tests/fboundp.lsp b/ansi-tests/fboundp.lsp
index da5b49c7..0ec7332d 100644
--- a/ansi-tests/fboundp.lsp
+++ b/ansi-tests/fboundp.lsp
@@ -39,6 +39,11 @@
   (let ((g (gensym))) (fboundp (list 'setf g)))
   nil)
 
+(deftest fboundp.order.1
+  (let ((i 0))
+    (values (notnot (fboundp (progn (incf i) 'car))) i))
+  t 1)
+
 (deftest fboundp.error.1
   (classify-error (fboundp 1))
   type-error)
diff --git a/ansi-tests/fdefinition.lsp b/ansi-tests/fdefinition.lsp
index c49663a7..1cfaa8db 100644
--- a/ansi-tests/fdefinition.lsp
+++ b/ansi-tests/fdefinition.lsp
@@ -74,3 +74,10 @@
   nil
   (b . a)
   t)
+
+(deftest fdefinition.order.1
+  (let ((i 0))
+    (fdefinition (progn (incf i) 'setq))
+    i)
+  1)
+
diff --git a/ansi-tests/fill-pointer.lsp b/ansi-tests/fill-pointer.lsp
index 4bde4c20..2f86e42c 100644
--- a/ansi-tests/fill-pointer.lsp
+++ b/ansi-tests/fill-pointer.lsp
@@ -24,6 +24,26 @@
      a))
   5 6 #(1 2 3 4 5 6))
 
+(deftest fill-pointer.order.1
+  (let ((i 0)
+	(a (make-array '(10) :fill-pointer 5)))
+    (values
+     (fill-pointer (progn (incf i) a))
+     i))
+  5 1)
+
+(deftest fill-pointer.order.2
+  (let ((i 0) x y
+	(a (make-array '(10) :fill-pointer 5
+		       :initial-contents '(1 2 3 4 5 6 7 8 9 10))))
+    (values
+     i
+     (setf (fill-pointer (progn (setf x (incf i)) a))
+	   (progn (setf y (incf i)) 6))
+     a
+     i x y))
+  0 6 #(1 2 3 4 5 6) 2 1 2)
+
 ;;; Error tests
 
 (deftest fill-pointer.error.1
diff --git a/ansi-tests/fill-strings.lsp b/ansi-tests/fill-strings.lsp
index 73446f53..38bdc3c4 100644
--- a/ansi-tests/fill-strings.lsp
+++ b/ansi-tests/fill-strings.lsp
@@ -5,22 +5,22 @@
 
 (in-package :cl-test)
 
-(deftest array-string-fill-1
+(deftest array-string-fill.1
   (array-string-fill-test-fn "abcde" #\Z)
   t "ZZZZZ")
 
-(deftest array-string-fill-2
+(deftest array-string-fill.2
   (array-string-fill-test-fn "abcde" #\Z :start 2)
   t "abZZZ")
 
-(deftest array-string-fill-3
+(deftest array-string-fill.3
   (array-string-fill-test-fn "abcde" #\Z :end 3)
   t "ZZZde")
 
-(deftest array-string-fill-4
+(deftest array-string-fill.4
   (array-string-fill-test-fn "abcde" #\Z :start 1 :end 4)
   t "aZZZe")
 
-(deftest array-string-fill-5
+(deftest array-string-fill.5
   (array-string-fill-test-fn "abcde" #\Z :start 2 :end 3)
   t "abZde")
-- 
GitLab