diff --git a/ansi-tests/TODO b/ansi-tests/TODO
index cce4952899ee2fcd48baf28c0fa3fa4fe92672d7..cbd9438dec423b7e762c3d7cab5346e3b0249eaa 100644
--- a/ansi-tests/TODO
+++ b/ansi-tests/TODO
@@ -100,6 +100,9 @@ Got:      0
 41. Add tests for MOD, REM
 
 42. Add randomized tests for BIT-* functions (requested by piso on #lisp)
+  (partially done; tests on simple bit vectors going to a new bit vector
+   have been added; should add in-place versions and operations on non-simple
+   bit-vectors and non-vector arrays)
 
 43. Add tests for structs that defining subtypes using :include doesn't change
     the parent type(s).  (This came up in ABCL.)
diff --git a/ansi-tests/bit-and.lsp b/ansi-tests/bit-and.lsp
index 2f1c23e3d07655a180c2f839e56f9777d1ca761d..b6fa18e92014faf8fd3d87a2e52aabd73c168d3c 100644
--- a/ansi-tests/bit-and.lsp
+++ b/ansi-tests/bit-and.lsp
@@ -5,6 +5,8 @@
 
 (in-package :cl-test)
 
+(compile-and-load "bit-aux.lsp")
+
 (deftest bit-and.1
   (let* ((s1 (make-array nil :initial-element 0 :element-type 'bit))
 	 (s2 (make-array nil :initial-element 0 :element-type 'bit)))
@@ -230,6 +232,12 @@
 
 (def-fold-test bit-and.fold.1 (bit-and #*01101 #*01011))
 
+;;; Randomized tests
+
+(deftest bit-and.random.1
+  (bit-random-test-fn #'bit-and #'logand)
+  nil)
+
 ;;; Error tests
 
 (deftest bit-and.error.1
diff --git a/ansi-tests/bit-andc1.lsp b/ansi-tests/bit-andc1.lsp
index 22eae68b4cd90ed77a11c26a73db3db0078bae16..83cc5970ccb268b7c5742d32825bbb98dab938f7 100644
--- a/ansi-tests/bit-andc1.lsp
+++ b/ansi-tests/bit-andc1.lsp
@@ -5,6 +5,8 @@
 
 (in-package :cl-test)
 
+(compile-and-load "bit-aux.lsp")
+
 (deftest bit-andc1.1
   (let* ((s1 (make-array nil :initial-element 0 :element-type 'bit))
 	 (s2 (make-array nil :initial-element 0 :element-type 'bit)))
@@ -230,6 +232,12 @@
 
 (def-fold-test bit-andc1.fold.1 (bit-andc1 #*10010 #*01011))
 
+;;; Random tests
+
+(deftest bit-andc1.random.1
+  (bit-random-test-fn #'bit-andc1 #'logandc1)
+  nil)
+
 ;;; Error tests
 
 (deftest bit-andc1.error.1
diff --git a/ansi-tests/bit-andc2.lsp b/ansi-tests/bit-andc2.lsp
index c439b4287d57f5398f78e70350551e328b65aa2c..f4cf0fad7a29096566c1cfa77760d604ecac7adf 100644
--- a/ansi-tests/bit-andc2.lsp
+++ b/ansi-tests/bit-andc2.lsp
@@ -5,6 +5,8 @@
 
 (in-package :cl-test)
 
+(compile-and-load "bit-aux.lsp")
+
 (deftest bit-andc2.1
   (let* ((s1 (make-array nil :initial-element 0 :element-type 'bit))
 	 (s2 (make-array nil :initial-element 0 :element-type 'bit)))
@@ -230,6 +232,12 @@
 
 (def-fold-test bit-andc2.fold.1 (bit-andc2 #*01101 #*10100))
 
+;;; Random tests
+
+(deftest bit-andc2.random.1
+  (bit-random-test-fn #'bit-andc2 #'logandc2)
+  nil)
+
 ;;; Error tests
 
 (deftest bit-andc2.error.1
diff --git a/ansi-tests/bit-aux.lsp b/ansi-tests/bit-aux.lsp
new file mode 100644
index 0000000000000000000000000000000000000000..72c3e78af571c67131a5870679f48dc8eeb679ca
--- /dev/null
+++ b/ansi-tests/bit-aux.lsp
@@ -0,0 +1,22 @@
+;-*- Mode:     Lisp -*-
+;;;; Author:   Paul Dietz
+;;;; Created:  Sun Jul 24 19:25:39 2005
+;;;; Contains: Aux file for BIT-* tests
+
+(in-package :cl-test)
+
+(defun bit-random-test-fn (bit-fn log-fn &key (reps 5000) (maxlen 100))
+  (assert (typep maxlen '(integer (0))))
+  (assert (typep reps 'unsigned-byte))
+  (loop for len = (random maxlen)
+	for twos = (make-list len :initial-element 2)
+	for v1 = (map 'bit-vector #'random twos)
+	for v2 = (map 'bit-vector #'random twos)
+	for result = (funcall bit-fn v1 v2)
+	repeat reps
+	unless (and (= (length result) len)
+		    (every #'(lambda (result-bit v1-bit v2-bit)
+			       (= result-bit (logand 1 (funcall log-fn v1-bit v2-bit))))
+			   result v1 v2))
+	collect (list len v1 v2 result)))
+
diff --git a/ansi-tests/bit-eqv.lsp b/ansi-tests/bit-eqv.lsp
index 28e7461910761ac37f3d431f9ac4ddb37d799d88..edfbc66dfa5c15f9e567c9d57c8d5a39bdf9e162 100644
--- a/ansi-tests/bit-eqv.lsp
+++ b/ansi-tests/bit-eqv.lsp
@@ -6,6 +6,8 @@
 
 (in-package :cl-test)
 
+(compile-and-load "bit-aux.lsp")
+
 (deftest bit-eqv.1
   (let* ((s1 (make-array nil :initial-element 0 :element-type 'bit))
 	 (s2 (make-array nil :initial-element 0 :element-type 'bit)))
@@ -231,6 +233,12 @@
 
 (def-fold-test bit-eqv.fold.1 (bit-eqv #*01101 #*10100))
 
+;;; Random tests
+
+(deftest bit-eqv.random.1
+  (bit-random-test-fn #'bit-eqv #'logeqv)
+  nil)
+
 ;;; Error tests
 
 (deftest bit-eqv.error.1
diff --git a/ansi-tests/bit-ior.lsp b/ansi-tests/bit-ior.lsp
index 966058f097a5dad037eb734aa9e4f7ae1626506c..0cd34a6aa1d402bb25da927d9e43907d71039ab4 100644
--- a/ansi-tests/bit-ior.lsp
+++ b/ansi-tests/bit-ior.lsp
@@ -5,6 +5,8 @@
 
 (in-package :cl-test)
 
+(compile-and-load "bit-aux.lsp")
+
 (deftest bit-ior.1
   (let* ((s1 (make-array nil :initial-element 0 :element-type 'bit))
 	 (s2 (make-array nil :initial-element 0 :element-type 'bit)))
@@ -230,6 +232,12 @@
 
 (def-fold-test bit-ior.fold.1 (bit-ior #*00101 #*10100))
 
+;;; Random tests
+
+(deftest bit-ior.random.1
+  (bit-random-test-fn #'bit-ior #'logior)
+  nil)
+
 ;;; Error tests
 
 (deftest bit-ior.error.1
diff --git a/ansi-tests/bit-nand.lsp b/ansi-tests/bit-nand.lsp
index cb31e2097fec96e2d2075788b88d6fa7e6bafdcc..9a288888151a9a6c7bc3462ced99797778da24ff 100644
--- a/ansi-tests/bit-nand.lsp
+++ b/ansi-tests/bit-nand.lsp
@@ -5,6 +5,8 @@
 
 (in-package :cl-test)
 
+(compile-and-load "bit-aux.lsp")
+
 (deftest bit-nand.1
   (let* ((s1 (make-array nil :initial-element 0 :element-type 'bit))
 	 (s2 (make-array nil :initial-element 0 :element-type 'bit)))
@@ -230,6 +232,12 @@
 
 (def-fold-test bit-nand.fold.1 (bit-nand #*00101 #*10100))
 
+;;; Random tests
+
+(deftest bit-nand.random.1
+  (bit-random-test-fn #'bit-nand #'lognand)
+  nil)
+
 ;;; Error tests
 
 (deftest bit-nand.error.1
diff --git a/ansi-tests/bit-nor.lsp b/ansi-tests/bit-nor.lsp
index e42957c8a389e804b66584b6107ee0d01d74cdfc..8c4fa26b1465857ddf78958e05146b500f10425b 100644
--- a/ansi-tests/bit-nor.lsp
+++ b/ansi-tests/bit-nor.lsp
@@ -5,6 +5,8 @@
 
 (in-package :cl-test)
 
+(compile-and-load "bit-aux.lsp")
+
 (deftest bit-nor.1
   (let* ((s1 (make-array nil :initial-element 0 :element-type 'bit))
 	 (s2 (make-array nil :initial-element 0 :element-type 'bit)))
@@ -230,6 +232,12 @@
 
 (def-fold-test bit-nor.fold.1 (bit-nor #*00101 #*10100))
 
+;;; Random tests
+
+(deftest bit-nor.random.1
+  (bit-random-test-fn #'bit-nor #'lognor)
+  nil)
+
 ;;; Error tests
 
 (deftest bit-nor.error.1
diff --git a/ansi-tests/bit-orc1.lsp b/ansi-tests/bit-orc1.lsp
index 49a344a5bdedc9b79c1744378e7783518ac64002..2d704544fd188720680aff98453f0021a3f98a5b 100644
--- a/ansi-tests/bit-orc1.lsp
+++ b/ansi-tests/bit-orc1.lsp
@@ -5,6 +5,8 @@
 
 (in-package :cl-test)
 
+(compile-and-load "bit-aux.lsp")
+
 (deftest bit-orc1.1
   (let* ((s1 (make-array nil :initial-element 0 :element-type 'bit))
 	 (s2 (make-array nil :initial-element 0 :element-type 'bit)))
@@ -234,6 +236,12 @@
     (values (%f) (let ((bv (%f))) (setf (elt bv 0) 0) bv) (%f)))
   #*10101 #*00101 #*10101)
 
+;;; Random tests
+
+(deftest bit-orc1.random.1
+  (bit-random-test-fn #'bit-orc1 #'logorc1)
+  nil)
+
 ;;; Error tests
 
 (deftest bit-orc1.error.1
diff --git a/ansi-tests/bit-orc2.lsp b/ansi-tests/bit-orc2.lsp
index f85a5423cb7b1936bad72d1cab36f2133170667c..f051265274bcfcfe1439bcae010220adf665c762 100644
--- a/ansi-tests/bit-orc2.lsp
+++ b/ansi-tests/bit-orc2.lsp
@@ -5,6 +5,8 @@
 
 (in-package :cl-test)
 
+(compile-and-load "bit-aux.lsp")
+
 (deftest bit-orc2.1
   (let* ((s1 (make-array nil :initial-element 0 :element-type 'bit))
 	 (s2 (make-array nil :initial-element 0 :element-type 'bit)))
@@ -234,6 +236,12 @@
     (values (%f) (let ((bv (%f))) (setf (elt bv 0) 0) bv) (%f)))
   #*10101 #*00101 #*10101)
 
+;;; Random tests
+
+(deftest bit-orc2.random.1
+  (bit-random-test-fn #'bit-orc2 #'logorc2)
+  nil)
+
 ;;; Error tests
 
 (deftest bit-orc2.error.1
diff --git a/ansi-tests/bit-xor.lsp b/ansi-tests/bit-xor.lsp
index 61b449814445d8effd7a93dabd0ef18075dcece9..0526a0df3ed566249e9d29789260a519c576181e 100644
--- a/ansi-tests/bit-xor.lsp
+++ b/ansi-tests/bit-xor.lsp
@@ -5,6 +5,8 @@
 
 (in-package :cl-test)
 
+(compile-and-load "bit-aux.lsp")
+
 (deftest bit-xor.1
   (let* ((s1 (make-array nil :initial-element 0 :element-type 'bit))
 	 (s2 (make-array nil :initial-element 0 :element-type 'bit)))
@@ -230,6 +232,12 @@
 
 (def-fold-test bit-xor.fold.1 (bit-xor #*00101 #*10100))
 
+;;; Random tests
+
+(deftest bit-xor.random.1
+  (bit-random-test-fn #'bit-xor #'logxor)
+  nil)
+
 ;;; Error tests
 
 (deftest bit-xor.error.1