diff --git a/ansi-tests/ansi-aux.lsp b/ansi-tests/ansi-aux.lsp
index d8db6a4cde0f3d9a1a7c270d333694d094107d90..1faf65db6d3a33e1eca0b1031eab2a6c9750fab5 100644
--- a/ansi-tests/ansi-aux.lsp
+++ b/ansi-tests/ansi-aux.lsp
@@ -9,19 +9,33 @@
 (declaim (optimize (safety 3)))
 
 (defun eqt (x y)
-  "Function like EQ, but guaranteed to return T for true."
+  "Like EQ, but guaranteed to return T for true."
   (if (eq x y) t nil))
 
+(defun eqlt (x y)
+  "Like EQL, but guaranteed to return T for true."
+  (if (eql x y) t nil))
+
+(defun equalt (x y)
+  "Like EQUAL, but guaranteed to return T for true."
+  (if (equal x y) t nil))
+
+(defun equalpt (x y)
+  "Like EQUALP, but guaranteed to return T for true."
+  (if (equalp x y) t nil))
+
+(defun =t (x &rest args)
+  "Like =, but guaranteed to return T for true."
+  (if (apply #'= x args) t nil))
+
 (defun notnot (x) (not (not x)))
 
 (defun make-int-list (n)
-  (loop for i from 0 to (1- n) collect i))
+  (loop for i from 0 below n collect i))
 
 (defun make-int-array (n &optional (fn #'make-array))
   (let ((a (funcall fn n)))
-    (loop
-	for i from 0 to (1- n) do
-	  (setf (aref a i) i))
+    (loop for i from 0 below n do (setf (aref a i) i))
     a))
 
 (defun equal-array (a1 a2)
@@ -33,12 +47,12 @@
 	      (if (= (array-rank a1) 1)
 		  (let ((as (first ad)))
 		    (loop
-		     for i from 0 to (1- as)
+		     for i from 0 below as
 		     always (equal (aref a1 i) (aref a2 i))))
 		(let ((as (array-total-size a1)))
 		  (and (= as (array-total-size a2))
 		       (loop
-			for i from 0 to (1- as)
+			for i from 0 below as
 			always (equal (row-major-aref a1 i)
 				      (row-major-aref a2 i))))))))))
 
diff --git a/ansi-tests/eql.lsp b/ansi-tests/eql.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..2a79e3e24889f25143796b0a4d46f52dbe55e75e
--- /dev/null
+++ b/ansi-tests/eql.lsp
@@ -0,0 +1,54 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Thu Oct 17 19:36:33 2002
+;;;; Contains: Tests of EQL
+
+(in-package :cl-test)
+
+;;; EQLT is defined in ansi-aux.lsp
+;;; It calls EQL, returning NIL when the result is false and T when it
+;;; is true.
+
+(deftest eql.1
+  (loop for x in *universe* always (eql x x))
+  t)
+
+(deftest eql.2
+  (eqlt 2 (1+ 1))
+  t)
+
+(deftest eql.3
+  (let ((x "abc"))
+    (eql x (copy-seq x)))
+  nil)
+
+(deftest eql.4
+  (eqlt #\a #\a)
+  t)
+
+(deftest eql.5
+  (eqlt 12345678901234567890 12345678901234567890)
+  t)
+
+(deftest eql.7
+  (eql 12.0 12)
+  nil)
+
+(deftest eql.8
+  (eqlt #c(1 -2) #c(1 -2))
+  t)
+
+(deftest eql.9
+  (let ((x "abc") (y "abc"))
+    (if (eq x y) (eqlt x y) (not (eql x y))))
+  t)
+
+(deftest eql.10
+  (eql (list 'a) (list 'b))
+  nil)
+
+(deftest eql.11
+  (eqlt #c(1 -2) (- #c(-1 2)))
+  t)
+
+;;; There are many other uses of EQL in other files.
diff --git a/ansi-tests/gclload2.lsp b/ansi-tests/gclload2.lsp
index 645c2811ec23511c5a4b8fa97a409e50372888be..77a9c52b20fd8060575b82898610b3e44e1d3e55 100644
--- a/ansi-tests/gclload2.lsp
+++ b/ansi-tests/gclload2.lsp
@@ -19,6 +19,7 @@
 (load "defparameter.lsp")
 (load "defvar.lsp")
 (load "destructuring-bind.lsp")
+(load "eql.lsp")
 (load "fboundp.lsp")
 (load "flet.lsp")
 (load "fmakunbound.lsp")