From ec2781e55d023bad9d343fa4700806585863cf56 Mon Sep 17 00:00:00 2001
From: "Paul M. Rodriguez" <pmr@ruricolist.com>
Date: Thu, 27 Apr 2023 16:30:03 -0500
Subject: [PATCH] Remove for-all* from tests per #149

---
 tests/lists.lisp     | 22 ++++++++++---------
 tests/sequences.lisp | 51 +++++++++++++++++++++++---------------------
 2 files changed, 39 insertions(+), 34 deletions(-)

diff --git a/tests/lists.lisp b/tests/lists.lisp
index ddf686ff..0d8578c3 100644
--- a/tests/lists.lisp
+++ b/tests/lists.lisp
@@ -245,16 +245,18 @@
              (stable-set-difference '(1 2 3 4) '(2))))
   (is (equal '(4 3 1)
              (stable-set-difference '(4 3 2 1) '(2))))
-  (for-all* ((list1 (lambda ()
-                      (coerce (range 100) 'list)))
-             (list2 (lambda ()
-                      (shuffle
-                       (filter-map (lambda (x)
-                                     (whichever x nil))
-                                   list1)))))
-    (let ((sdiff (stable-set-difference list1 list2)))
-      (is (set-equal sdiff (set-difference list1 list2)))
-      (is (every #'< sdiff (rest sdiff))))))
+  (for-all ((list1.list2
+             (lambda ()
+               (let* ((v1 (range 100))
+                      (v2 (shuffle (map-into (make-array (length v1))
+                                             (op (whichever _ nil))
+                                             v1))))
+                 (cons (coerce v1 'list)
+                       (coerce v2 'list))))))
+    (destructuring-bind (list1 . list2) list1.list2
+      (let ((sdiff (stable-set-difference list1 list2)))
+        (is (set-equal sdiff (set-difference list1 list2)))
+        (is (every #'< sdiff (rest sdiff)))))))
 
 (test with-member-test/simple-expansion ()
   "Test expansion of with-member-test when speed is not the priority."
diff --git a/tests/sequences.lisp b/tests/sequences.lisp
index 75cf29e8..bd28efd1 100644
--- a/tests/sequences.lisp
+++ b/tests/sequences.lisp
@@ -171,30 +171,33 @@
              (length> . >)
              (length<= . <=)
              (length>= . >=))))
-    (for-all* ((len (lambda () (random-in-range 2 10)))
-               (seq-lens
-                (lambda ()
-                  (loop repeat len collect (random 10))))
-               (seq-types
-                (lambda ()
-                  (loop repeat len collect (random-elt '(list vector integer))))))
-      (let ((seqs
-              (loop for type in seq-types
-                    for len in seq-lens
-                    collect (ecase type
-                              (list (make-list len))
-                              (vector (make-array (list len)))
-                              (integer len)))))
-        (flet ((len (x)
-                 (etypecase x
-                   (list (length x))
-                   (vector (length x))
-                   (integer x))))
-          (dolist (equiv equivs)
-            (let ((length-fn (car equiv))
-                  (num-fn (cdr equiv)))
-              (is (eql (apply length-fn seqs)
-                       (apply num-fn (mapcar #'len seqs)))))))))))
+    (for-all
+        ((data
+          (lambda ()
+            (let* ((len (random-in-range 2 10))
+                   (seq-lens
+                     (loop repeat len collect (random 10)))
+                   (seq-types
+                     (loop repeat len collect (random-elt '(list vector integer)))))
+              (list len seq-lens seq-types)))))
+      (destructuring-bind (len seq-lens seq-types) data
+        (let ((seqs
+                (loop for type in seq-types
+                      for len in seq-lens
+                      collect (ecase type
+                                (list (make-list len))
+                                (vector (make-array (list len)))
+                                (integer len)))))
+          (flet ((len (x)
+                   (etypecase x
+                     (list (length x))
+                     (vector (length x))
+                     (integer x))))
+            (dolist (equiv equivs)
+              (let ((length-fn (car equiv))
+                    (num-fn (cdr equiv)))
+                (is (eql (apply length-fn seqs)
+                         (apply num-fn (mapcar #'len seqs))))))))))))
 
 (test slice
   (is (equal "in" (slice "string" -3 -1)))