CHICKEN bug? Definition of `%insert` in the test for `internal` was

interfering with the import definition for the srfi-113 test.

1 files changed, 17 insertions, 18 deletions

diff --git a/tests/internal.scm b/tests/internal.scm
index fc61f6e..e299fc9 100644
--- a/tests/internal.scm
+++ b/tests/internal.scm
@@ -397,15 +397,14 @@
 ;;; Update
 ;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(define %insert insert)
-(define (insert elem set)
-  (%insert number-comparator
-           set
-           elem))
+(define (%insert elem set)
+  (insert number-comparator
+          set
+          elem))
 
 (test-group "update of unordered list is balanced"
   (define (insert-unordered lst)
-    (let ((set (fold insert '() lst)))
+    (let ((set (fold %insert '() lst)))
       (balanced? set)))
   (test-property insert-unordered
                  (list (list-generator-of
@@ -413,7 +412,7 @@
 
 (test-group "update of unordered list is subset of list"
   (define (subset-of-list lst)
-    (let ((set (fold insert '() lst)))
+    (let ((set (fold %insert '() lst)))
       (when (verbose)
         (dynamic-property-set! 'lst lst)
         (dynamic-property-set! 'set (node->in-order-list set)))
@@ -425,7 +424,7 @@
 
 (test-group "list is subset of update of unordered list"
   (define (list-is-subset-of lst)
-    (let ((set (fold insert '() lst)))
+    (let ((set (fold %insert '() lst)))
       (node-every (cut memq <> lst) set)))
   (test-property list-is-subset-of
                  (list (list-generator-of
@@ -437,8 +436,8 @@
 
 (define (call/difference procedure)
   (lambda (lst1 lst2)
-    (let* ((set1 (fold insert '() lst1))
-           (set2 (fold insert '() lst2))
+    (let* ((set1 (fold %insert '() lst1))
+           (set2 (fold %insert '() lst2))
            (diff (difference number-comparator set1 set2))
            (deleted (fold (lambda (elem set)
                             (when (verbose)
@@ -451,7 +450,7 @@
 
 (test-group "delete of elements unordered list is balanced"
   (define (delete-balanced? lst1 lst2)
-    (let* ((set (fold insert '() lst1))
+    (let* ((set (fold %insert '() lst1))
            (deleted (fold (lambda (elem set)
                             (delete number-comparator set elem))
                           set
@@ -488,8 +487,8 @@
 
 (test-group "lset subset of xor"
   (define (lset-subset-of-xor lst1 lst2)
-    (let* ((node1 (fold insert '() lst1))
-           (node2 (fold insert '() lst2))
+    (let* ((node1 (fold %insert '() lst1))
+           (node2 (fold %insert '() lst2))
            (set-xor (xor number-comparator node1 node2))
            (list-xor (lset-xor = lst1 lst2)))
       (every (cut search number-comparator <> set-xor) list-xor)))
@@ -499,8 +498,8 @@
 
 (test-group "xor subset of lset"
   (define (xor-subset-of-lset lst1 lst2)
-    (let* ((node1 (fold insert '() lst1))
-           (node2 (fold insert '() lst2))
+    (let* ((node1 (fold %insert '() lst1))
+           (node2 (fold %insert '() lst2))
            (set-xor (xor number-comparator node1 node2))
            (list-xor (lset-xor = lst1 lst2)))
       (node-every (cut member <> list-xor) set-xor)))
@@ -514,7 +513,7 @@
 
 (test-group "node->generator"
   (define (node->generator-works lst)
-    (let* ((node (fold insert '() lst))
+    (let* ((node (fold %insert '() lst))
            (result-lst
             (generator->list (node->generator node))))
       (lset= = lst result-lst)))
@@ -532,7 +531,7 @@
 
 (test-group "node->in-order-generator"
   (define (node->in-order-generator-works lst)
-    (let* ((node (fold insert '() lst))
+    (let* ((node (fold %insert '() lst))
            (result-lst (generator->list
                         (node->in-order-generator node))))
       (and (lset= = lst result-lst)
@@ -542,7 +541,7 @@
 
 (test-group "node->reverse-order-generator"
   (define (node->reverse-order-generator-works lst)
-    (let* ((node (fold insert '() lst))
+    (let* ((node (fold %insert '() lst))
            (result-lst (generator->list
                         (node->reverse-order-generator node))))
       (and (lset= = lst result-lst)