more set=? tests

2 files changed, 20 insertions, 7 deletions

diff --git a/mcgoron/weight-balanced-trees/srfi/113/sets.scm b/mcgoron/weight-balanced-trees/srfi/113/sets.scm
index b3d6b13..ea15436 100644
--- a/mcgoron/weight-balanced-trees/srfi/113/sets.scm
+++ b/mcgoron/weight-balanced-trees/srfi/113/sets.scm
@@ -357,7 +357,6 @@
 ;;; ;;;;;;;;;;;;
 
 (define (set-adjoin-all set elements)
-  ;; TODO: replace with version that only crawls the tree once.
   (let ((cmp (set-element-comparator set)))
     (raw-set
      cmp
@@ -371,7 +370,6 @@
            elements))))
 
 (define (set-replace-all set elements)
-  ;; TODO: replace with version that only crawls the tree once.
   (let ((cmp (set-element-comparator set)))
     (fold (lambda (new set)
             (update cmp
diff --git a/tests/srfi-113-sets.scm b/tests/srfi-113-sets.scm
index 90c3212..1b9700e 100644
--- a/tests/srfi-113-sets.scm
+++ b/tests/srfi-113-sets.scm
@@ -20,8 +20,8 @@
 (define test-set-find #f)
 (define test-set-disjoint #f)
 (define test-set-every #f)
-(define test-set-delete #t)
-(define test-set= #f)
+(define test-set-delete #f)
+(define test-set= #t)
 (define test-set-intersection #f)
 
 (define cmp (make-default-comparator))
@@ -422,16 +422,31 @@
   (test-group "set with one element deleted is not set="
     (define (not-set=? set)
       (let ((set* (set-delete set (find-some-element set))))
-        (not (set=? set set*))))
+        (and (not (set=? set set*))
+             (not (set=? set* set)))))
     (test-property not-set=? (list (filter-non-empty-sets
                                     (random-sets)))))
   (test-group "two unique sets are not set="
     (define (unique-not-set= set1 set2)
       (if (and (set-empty? set1) (set-empty? set2))
           #t
-          (not (set=? set1 set2))))
+          (and (not (set=? set1 set2))
+               (not (set=? set2 set1)))))
     (test-property (call/split unique-not-set=)
-                   (list (split-unique-sets)))))
+                   (list (split-unique-sets))))
+  (test-group "deleting an element from a set makes it not set="
+    (define (delete-not-set= set)
+      (let ((deleted (set-delete set (find-some-element set))))
+        (and (not (set=? set deleted))
+             (not (set=? deleted set)))))
+    (test-property delete-not-set= (list (filter-non-empty-sets
+                                          (random-sets)))))
+  (test-group "adding an element to a set makes it not set="
+    (define (adjoin-not-set= set)
+      (let ((set+ (set-adjoin set (cons #f #f))))
+        (and (not (set=? set set+))
+             (not (set=? set+ set)))))
+    (test-property adjoin-not-set= (list (random-sets)))))
 
 ;;; ;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; Set-intersection