Update some tests to SchemeUnit 2, and change load-srfis to load new SRFIs since last time

svn: r3773

collects/tests/srfi/40/all-srfi-40-tests.ss

@@ -1,6 +1,6 @@
 (module all-srfi-40-tests mzscheme
   
-  (require (planet "test.ss" ("schematics" "schemeunit.plt" 1 1))
+  (require (planet "test.ss" ("schematics" "schemeunit.plt" 2))
            (lib "40.ss" "srfi"))
   (provide all-srfi-40-tests)
   
@@ -26,63 +26,63 @@
               (finite-stream->list (stream-cdr s)))))
   
   (define all-srfi-40-tests
-    (make-test-suite 
+    (test-suite 
      "All tests for SRFI 40"
-     (make-test-case
+     (test-case
       "stream?"
-      (assert-true
+      (check-true
        (stream? stream-null))
-      (assert-true
+      (check-true
        (stream? (stream-cons 'a stream-null)))
-      (assert-false
+      (check-false
        (stream? 3)))
-     (make-test-case
+     (test-case
       "stream-null?"
-      (assert-true
+      (check-true
        (stream-null? stream-null))
-      (assert-false
+      (check-false
        (stream-null? (stream-cons 'a stream-null)))
-      (assert-false
+      (check-false
        (stream-null? 3)))
-     (make-test-case
+     (test-case
       "stream-pair?"
-      (assert-false
+      (check-false
        (stream-pair? stream-null))
-      (assert-true
+      (check-true
        (stream-pair? (stream-cons 'a stream-null)))
-      (assert-false
+      (check-false
        (stream-pair? 3)))
-     (make-test-case
+     (test-case
       "stream"
-      (assert-true
+      (check-true
        (stream-null? (stream)))
-      (assert-equal? (finite-stream->list (stream 'a (+ 3 4) 'c))
+      (check-equal? (finite-stream->list (stream 'a (+ 3 4) 'c))
                      '(a 7 c)))
-     (make-test-case
+     (test-case
       "stream-unfoldn"
-      (assert-equal? (finite-stream->list (take5 from0))
+      (check-equal? (finite-stream->list (take5 from0))
                      '(0 1 2 3 4)))
-     (make-test-case
+     (test-case
       "stream-for-each"
-      (assert-equal?
+      (check-equal?
        (let ((l '()))
          (stream-for-each (lambda (n) (set! l (cons n l)))
                           (take5 from0))
          l)
        '(4 3 2 1 0)))
-     (make-test-case
+     (test-case
       "stream-map"
-      (assert-equal? (finite-stream->list (take5 (stream-map (lambda (x) (+ x x)) from0)))
+      (check-equal? (finite-stream->list (take5 (stream-map (lambda (x) (+ x x)) from0)))
                      '(0 2 4 6 8))
-      (assert-equal? (finite-stream->list (stream-map + (stream 1 2 3) (stream 4 5 6)))
+      (check-equal? (finite-stream->list (stream-map + (stream 1 2 3) (stream 4 5 6)))
                      '(5 7 9))
-      (assert-equal? (finite-stream->list
+      (check-equal? (finite-stream->list
                       (stream-map (lambda (x) (expt x x))
                                   (stream 1 2 3 4 5)))
                      '(1 4 27 256 3125)))
-     (make-test-case
+     (test-case
       "stream-filter"
-      (assert-true
+      (check-true
        (stream-null? (stream-filter odd? stream-null)))
-      (assert-equal? (finite-stream->list (take5 (stream-filter odd? from0)))
+      (check-equal? (finite-stream->list (take5 (stream-filter odd? from0)))
                      '(1 3 5 7 9))))))

collects/tests/srfi/40/run-tests.ss

@@ -1,5 +1,5 @@
-(require (planet "test.ss" ("schematics" "schemeunit.plt" 1 1)))
+(require (planet "test.ss" ("schematics" "schemeunit.plt" 2)))
-(require (planet "text-ui.ss" ("schematics" "schemeunit.plt" 1 1)))
+(require (planet "text-ui.ss" ("schematics" "schemeunit.plt" 2)))
 (require "all-srfi-40-tests.ss")
 
 (test/text-ui all-srfi-40-tests)

collects/tests/srfi/43/all-srfi-43-tests.ss

@@ -1,6 +1,6 @@
 (module all-srfi-43-tests mzscheme
   
-  (require (planet "test.ss" ("schematics" "schemeunit.plt" 1 1))
+  (require (planet "test.ss" ("schematics" "schemeunit.plt" 2))
            "constructor-tests.ss"
            "predicate-tests.ss"
            "iteration-tests.ss"
@@ -10,7 +10,7 @@
   (provide all-srfi-43-tests)
   
   (define all-srfi-43-tests
-    (make-test-suite 
+    (test-suite 
      "all-tests-tests"
      constructor-tests
      predicate-tests

collects/tests/srfi/43/constructor-tests.ss

@@ -1,42 +1,42 @@
 (module constructor-tests mzscheme
 
-  (require (planet "test.ss" ("schematics" "schemeunit.plt" 1 1)))
+  (require (planet "test.ss" ("schematics" "schemeunit.plt" 2)))
   (require (lib "constructors.ss" "srfi" "43"))
 
   (provide constructor-tests)
 
   (define constructor-tests
-    (make-test-suite
+    (test-suite
      "All tests for constructor"
-     (make-test-case
+     (test-case
       "vector-unfold"
-      (assert-equal?
+      (check-equal?
        (vector-unfold values 10)
        #(0 1 2 3 4 5 6 7 8 9)
        "No seed")
-      (assert-equal?
+      (check-equal?
        (vector-unfold (lambda (i x) (values x (- x 1))) 10 0)
        #(0 -1 -2 -3 -4 -5 -6 -7 -8 -9)
        "Single seed")
-      (assert-equal?
+      (check-equal?
        (vector-unfold (lambda (i a b) (values (/ a b) a b)) 4 5 5)
        #(1 1 1 1)
        "Two seeds"))
 
-     (make-test-case
+     (test-case
       "vector-unfold-right"
-      (assert-equal?
+      (check-equal?
        (vector-unfold-right values 10)
        #(0 1 2 3 4 5 6 7 8 9)
        "No seed")
-      (assert-equal?
+      (check-equal?
        (vector-unfold-right
         (lambda (i x) (values x (- x 1)))
         10
         0)
        #(-9 -8 -7 -6 -5 -4 -3 -2 -1 0)
        "Single seed")
-      (assert-equal?
+      (check-equal?
        (vector-unfold-right
         (lambda (i a b) (values (/ a b) a b))
         4
@@ -45,66 +45,66 @@
        #(1 1 1 1)
        "Two seeds"))
 
-     (make-test-case
+     (test-case
       "vector-copy"
-      (assert-equal?
+      (check-equal?
        (vector-copy '#(a b c d e f g h i))
        #(a b c d e f g h i))
-      (assert-equal?
+      (check-equal?
        (vector-copy '#(a b c d e f g h i) 6)
        #(g h i))
-      (assert-equal?
+      (check-equal?
        (vector-copy '#(a b c d e f g h i) 3 6)
        #(d e f))
-      (assert-equal?
+      (check-equal?
        (vector-copy '#(a b c d e f g h i) 6 12 'x)
        #(g h i x x x)))
 
-     (make-test-case
+     (test-case
       "vector-reverse-copy"
-      (assert-equal?
+      (check-equal?
        (vector-reverse-copy '#(5 4 3 2 1 0) 1 5)
        #(1 2 3 4))
-      (assert-equal?
+      (check-equal?
        (vector-reverse-copy '#(5 4 3 2 1 0) 2)
        #(0 1 2 3))
-      (assert-equal?
+      (check-equal?
        (vector-reverse-copy '#(5 4 3 2 1 0))
        #(0 1 2 3 4 5)))
 
-     (make-test-case
+     (test-case
       "vector-append"
-      (assert-equal?
+      (check-equal?
        (vector-append '#(x) '#(y))
        #(x y))
-      (assert-equal?
+      (check-equal?
        (vector-append '#(a) '#(b c d))
        #(a b c d))
-      (assert-equal?
+      (check-equal?
        (vector-append '#(a #(b)) '#(#(c)))
        #(a #(b) #(c)))
-      (assert-equal?
+      (check-equal?
        (vector-append '#(1 2) '#(3) '#(4 5 6 7))
        #(1 2 3 4 5 6 7))
-      (assert-equal?
+      (check-equal?
        (vector-append)
        #()))
 
-     (make-test-case
+     (test-case
       "vector-concatenate"
-      (assert-equal?
+      (check-equal?
        (vector-concatenate '(#(x) #(y)))
        #(x y))
-      (assert-equal?
+      (check-equal?
        (vector-concatenate '(#(a) #(b c d)))
        #(a b c d))
-      (assert-equal?
+      (check-equal?
        (vector-concatenate '(#(a #(b)) #(#(c))))
        #(a #(b) #(c)))
-      (assert-equal?
+      (check-equal?
        (vector-concatenate '(#(1 2) #(3) #(4 5 6 7)))
        #(1 2 3 4 5 6 7))
-      (assert-equal?
+      (check-equal?
        (vector-concatenate '())
        #()))
      ))

collects/tests/srfi/43/conversion-tests.ss

@@ -1,44 +1,44 @@
 (module conversion-tests mzscheme
   
-  (require (planet "test.ss" ("schematics" "schemeunit.plt" 1 1)))
+  (require (planet "test.ss" ("schematics" "schemeunit.plt" 2)))
   (require (all-except (lib "conversion.ss" "srfi" "43") vector->list)
            (rename (lib "conversion.ss" "srfi" "43") s:vector->list vector->list))
   
   (provide conversion-tests)
   
   (define conversion-tests
-    (make-test-suite
+    (test-suite
      "All tests for conversion"
-     (make-test-case
+     (test-case
       "vector->list"
-      (assert-equal?
+      (check-equal?
        (s:vector->list '#(1 2 3 4))
        '(1 2 3 4))
-      (assert-equal?
+      (check-equal?
        (s:vector->list '#(1 2 3 4) 4)
        '())
-      (assert-equal?
+      (check-equal?
        (s:vector->list '#(1 2 3 4) 1 3)
        '(2 3)))
      
-     (make-test-case
+     (test-case
       "reverse-vector->list"
-      (assert-equal?
+      (check-equal?
        (reverse-vector->list '#(1 2 3 4))
        '(4 3 2 1))
-      (assert-equal?
+      (check-equal?
        (reverse-vector->list '#(1 2 3 4) 4)
        '())
-      (assert-equal?
+      (check-equal?
        (reverse-vector->list '#(1 2 3 4) 1 3)
        '(3 2)))
      
-     (make-test-case
+     (test-case
       "reverse-list->vector"
-      (assert-equal?
+      (check-equal?
        (reverse-list->vector '(1 2 3 4))
        '#(4 3 2 1))
-      (assert-equal?
+      (check-equal?
        (reverse-list->vector '())
        '#()))
      ))

collects/tests/srfi/43/iteration-tests.ss

@@ -1,31 +1,31 @@
 (module iteration-tests mzscheme
   
-  (require (planet "test.ss" ("schematics" "schemeunit.plt" 1 1)))
+  (require (planet "test.ss" ("schematics" "schemeunit.plt" 2)))
   (require (lib "iteration.ss" "srfi" "43")
            (lib "constructors.ss" "srfi" "43"))
   
   (provide iteration-tests)
   
   (define iteration-tests
-    (make-test-suite
+    (test-suite
      "All tests for iteration"
-     (make-test-case
+     (test-case
       "vector-fold"
-      (assert =
+      (check =
               (vector-fold (lambda (index len str) (max (string-length str) len))
                            0 '#("abcde" "1234" "bar"))
               5)
-      (assert-equal?
+      (check-equal?
        (vector-fold (lambda (index tail elt) (cons elt tail))
                     '() '#(1 2 3 4 5))
        '(5 4 3 2 1)
        "reverse-vector->list")
-      (assert =
+      (check =
               (vector-fold (lambda (index counter n)
                              (if (even? n) (+ counter 1) counter))
                            0 '#(1 2 3 4 5))
               2)
-      (assert-equal?
+      (check-equal?
        (vector-fold (lambda (index tail elt1 elt2)
                       (cons (list elt1 elt2) tail))
                     '()
@@ -34,14 +34,14 @@
        '((4 d) (3 c) (2 b) (1 a))
        "two vectors"))
      
-     (make-test-case
+     (test-case
       "vector-fold-right"
-      (assert-equal?
+      (check-equal?
        (vector-fold-right (lambda (index tail elt) (cons elt tail))
                           '() '#(a b c d))
        '(a b c d)
        "vector->list")
-      (assert-equal?
+      (check-equal?
        (vector-fold-right (lambda (index tail elt1 elt2)
                             (cons (list elt1 elt2) tail))
                           '()
@@ -50,48 +50,48 @@
        '((1 a) (2 b) (3 c) (4 d))
        "two vectors"))
      
-     (make-test-case
+     (test-case
       "vector-map"
-      (assert-equal?
+      (check-equal?
        (vector-map (lambda (i x) (* x x))
                    '#(1 2 3 4))
        '#(1 4 9 16))
-      (assert-equal?
+      (check-equal?
        (vector-map (lambda (i x y) (* x y))
                    (vector-unfold (lambda (i x) (values x (+ x 1))) 5 1)
                    (vector-unfold (lambda (i x) (values x (- x 1))) 5 5))
        '#(5 8 9 8 5))
-      (assert-equal?
+      (check-equal?
        (vector-map (lambda (i elt) (+ i elt)) '#(1 2 3 4))
        '#(1 3 5 7)))
      
-     (make-test-case
+     (test-case
       "vector-map!"
       (let ((vec '#(1 2 3 4)))
-        (assert-equal?
+        (check-equal?
          (begin (vector-map! (lambda (i x) (* x x))
                              vec)
                 vec)
          '#(1 4 9 16)))
       (let ((vec1 (vector-unfold (lambda (i x) (values x (+ x 1))) 5 1))
             (vec2 (vector-unfold (lambda (i x) (values x (- x 1))) 5 5)))
-        (assert-equal?
+        (check-equal?
          (begin (vector-map! (lambda (i x y) (* x y))
                              vec1 vec2)
                 vec1)
          '#(5 8 9 8 5)))
       (let ((vec '#(1 2 3 4)))
-        (assert-equal?
+        (check-equal?
          (begin (vector-map! (lambda (i elt) (+ i elt))
                              vec)
                 vec)
          '#(1 3 5 7))))
      
-     (make-test-case
+     (test-case
       "vector-for-each"
       (let ((vec1 '#(1 2 3 4))
             (vec2 (make-vector 4)))
-        (assert-equal?
+        (check-equal?
          (begin (vector-for-each (lambda (i elt)
                                    (vector-set! vec2 i (+ i elt)))
                                  vec1)
@@ -100,19 +100,19 @@
       (let ((vec1 (vector-unfold (lambda (i x) (values x (+ x 1))) 5 1))
             (vec2 (vector-unfold (lambda (i x) (values x (- x 1))) 5 5))
             (vec3 (make-vector 5)))
-        (assert-equal?
+        (check-equal?
          (begin (vector-for-each (lambda (i x y)
                                    (vector-set! vec3 i (* x y)))
                                  vec1 vec2)
                 vec3)
          '#(5 8 9 8 5))))
      
-     (make-test-case
+     (test-case
       "vector-count"
-      (assert =
+      (check =
               (vector-count (lambda (i elt) (even? elt)) '#(3 1 4 1 5 9 2 5 6))
               3)
-      (assert =
+      (check =
               (vector-count (lambda (i x y) (< x y)) '#(1 3 6 9) '#(2 4 6 8 10 12))
               2))
      ))

collects/tests/srfi/43/mutator-tests.ss

@@ -1,101 +1,101 @@
 (module mutator-tests mzscheme
   
-  (require (planet "test.ss" ("schematics" "schemeunit.plt" 1 1)))
+  (require (planet "test.ss" ("schematics" "schemeunit.plt" 2)))
   (require (all-except (lib "mutators.ss" "srfi" "43") vector-fill!)
            (rename (lib "mutators.ss" "srfi" "43") s:vector-fill! vector-fill!))
   
   (provide mutator-tests)
   
   (define mutator-tests
-    (make-test-suite
+    (test-suite
      "All tests for mutator"
-     (make-test-case
+     (test-case
       "vector-swap!"
       (let ((vec '#(a b c d e)))
-        (assert-equal?
+        (check-equal?
          (begin (vector-swap! vec 1 3)
                 vec)
          '#(a d c b e)))
       (let ((vec '#(0 1 2)))
-        (assert-equal?
+        (check-equal?
          (begin (vector-swap! vec 1 1)
                 vec)
          '#(0 1 2))))
      
-     (make-test-case
+     (test-case
       "vector-fill!"
       (let ((vec '#(1 2 3 4 5)))
-        (assert-equal?
+        (check-equal?
          (begin (s:vector-fill! vec 0)
                 vec)
          '#(0 0 0 0 0)))
       (let ((vec '#(1 2 3 4 5)))
-        (assert-equal?
+        (check-equal?
          (begin (s:vector-fill! vec 0 1)
                 vec)
          '#(1 0 0 0 0)))
       (let ((vec '#(1 2 3 4 5)))
-        (assert-equal?
+        (check-equal?
          (begin (s:vector-fill! vec 0 1 4)
                 vec)
          '#(1 0 0 0 5))))
      
-     (make-test-case
+     (test-case
       "vector-reverse!"
       (let ((vec '#(1 2 3 4 5)))
-        (assert-equal?
+        (check-equal?
          (begin (vector-reverse! vec)
                 vec)
          '#(5 4 3 2 1)))
       (let ((vec '#(1 2 3 4 5)))
-        (assert-equal?
+        (check-equal?
          (begin (vector-reverse! vec 1)
                 vec)
          '#(1 5 4 3 2)))
       (let ((vec '#(1 2 3 4 5)))
-        (assert-equal?
+        (check-equal?
          (begin (vector-reverse! vec 1 4)
                 vec)
          '#(1 4 3 2 5))))
      
-     (make-test-case
+     (test-case
       "vector-copy!"
       (let ((source '#(1 2 3 4 5))
             (target '#(0 0 0 0 0)))
-        (assert-equal?
+        (check-equal?
          (begin (vector-copy! target 0 source)
                 target)
          source))
       (let ((source '#(1 2 3 4 5))
             (target '#(0 0 0 0 0)))
-        (assert-equal?
+        (check-equal?
          (begin (vector-copy! target 1 source 1)
                 target)
          '#(0 2 3 4 5)))
       (let ((source '#(1 2 3 4 5))
             (target '#(0 0 0 0 0)))
-        (assert-equal?
+        (check-equal?
          (begin (vector-copy! target 1 source 1 4)
                 target)
          '#(0 2 3 4 0))))
      
-     (make-test-case
+     (test-case
       "vector-reverse-copy!"
       (let ((source '#(1 2 3 4 5))
             (target '#(0 0 0 0 0)))
-        (assert-equal?
+        (check-equal?
          (begin (vector-reverse-copy! target 0 source)
                 target)
          '#(5 4 3 2 1)))
       (let ((source '#(1 2 3 4 5))
             (target '#(0 0 0 0 0)))
-        (assert-equal?
+        (check-equal?
          (begin (vector-reverse-copy! target 1 source 1)
                 target)
          '#(0 5 4 3 2)))
       (let ((source '#(1 2 3 4 5))
             (target '#(0 0 0 0 0)))
-        (assert-equal?
+        (check-equal?
          (begin (vector-reverse-copy! target 1 source 1 4)
                 target)
          '#(0 4 3 2 0))))

collects/tests/srfi/43/predicate-tests.ss

@@ -1,41 +1,41 @@
 (module predicate-tests mzscheme
 
-  (require (planet "test.ss" ("schematics" "schemeunit.plt" 1 1)))
+  (require (planet "test.ss" ("schematics" "schemeunit.plt" 2)))
   (require (lib "predicates.ss" "srfi" "43"))
 
   (provide predicate-tests)
 
   (define predicate-tests
-    (make-test-suite
+    (test-suite
      "All tests for predicate"
-     (make-test-case
+     (test-case
       "vector-empty?"
-      (assert-false
+      (check-false
        (vector-empty? '#(a)))
-      (assert-false
+      (check-false
        (vector-empty? '#(())))
-      (assert-false
+      (check-false
        (vector-empty? '#(#())))
-      (assert-true
+      (check-true
        (vector-empty? '#())))
 
-     (make-test-case
+     (test-case
       "vector="
-      (assert-true
+      (check-true
        (vector= eq? '#(a b c d) '#(a b c d)))
-      (assert-false
+      (check-false
        (vector= eq? '#(a b c d) '#(a b d c)))
-      (assert-false
+      (check-false
        (vector= = '#(1 2 3 4 5) '#(1 2 3 4)))
-      (assert-true
+      (check-true
        (vector= = '#(1 2 3 4) '#(1 2 3 4) '#(1 2 3 4)))
-      (assert-true
+      (check-true
        (vector= eq?))
-      (assert-true
+      (check-true
        (vector= eq? '#(a)))
-      (assert-false
+      (check-false
        (vector= eq? '#(a b c d) '#(a b c d) '#(a b d c)))
-      (assert-false
+      (check-false
        (vector= eq? '#(a b c d e) '#(a b c d) '#(a b c d))))
      ))
   )

collects/tests/srfi/43/run-tests.ss

@@ -1,5 +1,5 @@
-(require (planet "test.ss" ("schematics" "schemeunit.plt" 1 1)))
+(require (planet "test.ss" ("schematics" "schemeunit.plt" 2)))
-(require (planet "text-ui.ss" ("schematics" "schemeunit.plt" 1 1)))
+(require (planet "text-ui.ss" ("schematics" "schemeunit.plt" 2)))
 (require "all-srfi-43-tests.ss")
 
 (test/text-ui all-srfi-43-tests)

collects/tests/srfi/43/searching-tests.ss

@@ -1,105 +1,105 @@
 (module searching-tests mzscheme
   
-  (require (planet "test.ss" ("schematics" "schemeunit.plt" 1 1)))
+  (require (planet "test.ss" ("schematics" "schemeunit.plt" 2)))
   (require (lib "searching.ss" "srfi" "43"))
   
   (provide searching-tests)
   
   (define searching-tests
-    (make-test-suite
+    (test-suite
      "All tests for searching"
-     (make-test-case
+     (test-case
       "vector-index"
-      (assert =
+      (check =
               (vector-index even? '#(3 1 4 1 5 9))
               2)
-      (assert =
+      (check =
               (vector-index < '#(3 1 4 1 5 9 2 5 6) '#(2 7 1 8 2))
               1)
-      (assert-false
+      (check-false
        (vector-index = '#(3 1 4 1 5 9 2 5 6) '#(2 7 1 8 2))))
      
-     (make-test-case
+     (test-case
       "vector-index-right"
-      (assert =
+      (check =
               (vector-index-right even? '#(3 1 4 1 5 9))
               2)
-      (assert =
+      (check =
               (vector-index-right < '#(3 1 4 1 5 9 2 5 6) '#(2 7 1 8 2))
               3)
-      (assert-false
+      (check-false
        (vector-index-right = '#(3 1 4 1 5 9 2 5 6) '#(2 7 1 8 2))))
      
-     (make-test-case
+     (test-case
       "vector-skip"
-      (assert =
+      (check =
               (vector-skip odd? '#(3 1 4 1 5 9))
               2)
-      (assert =
+      (check =
               (vector-skip > '#(3 1 4 1 5 9 2 5 6) '#(2 7 1 8 2))
               1)
-      (assert-false
+      (check-false
        (vector-skip = '#(2 7 1 8 2 8) '#(2 7 1 8 2))))
      
-     (make-test-case
+     (test-case
       "vector-skip-right"
-      (assert =
+      (check =
               (vector-skip-right odd? '#(3 1 4 1 5 9))
               2)
-      (assert =
+      (check =
               (vector-skip-right > '#(3 1 4 1 5 9 2 5 6) '#(2 7 1 8 2))
               3)
-      (assert-false
+      (check-false
        (vector-skip-right = '#(2 7 1 8 2 8) '#(2 7 1 8 2))))
      
-     (make-test-case
+     (test-case
       "vector-binary-search"
-      (assert =
+      (check =
               (vector-binary-search '#(0 3 4 6 8 9) 0 -)
               0)
-      (assert =
+      (check =
               (vector-binary-search '#(0 3 4 6 8 9) 3 -)
               1)
-      (assert =
+      (check =
               (vector-binary-search '#(0 3 4 6 8 9) 4 -)
               2)
-      (assert =
+      (check =
               (vector-binary-search '#(0 3 4 6 8 9) 6 -)
               3)
-      (assert =
+      (check =
               (vector-binary-search '#(0 3 4 6 8 9) 8 -)
               4)
-      (assert =
+      (check =
               (vector-binary-search '#(0 3 4 6 8 9) 9 -)
               5)
-      (assert-false
+      (check-false
        (vector-binary-search '#(0 3 4 6 8 9) 5 -))
-      (assert-false
+      (check-false
        (vector-binary-search '#(0 3 4 6 8 9) -2 -))
-      (assert-false
+      (check-false
        (vector-binary-search '#(0 3 4 6 8 9) 11 -))
-      (assert-false
+      (check-false
        (vector-binary-search '#(0 3 4 6 8 9) 1 -)))
      
-     (make-test-case
+     (test-case
       "vector-any"
-      (assert-false
+      (check-false
        (vector-any zero? '#(1 2 3 4)))
-      (assert-true
+      (check-true
        (vector-any zero? '#(2 0 1)))
-      (assert =
+      (check =
               (vector-any / '#(1 1) '#(1 0))
               1)
-      (assert-false
+      (check-false
        (vector-any (lambda x #t) '#())))
      
-     (make-test-case
+     (test-case
       "vector-every"
-      (assert-false
+      (check-false
        (vector-every zero? '#(0 0 7)))
-      (assert-true
+      (check-true
        (vector-every (lambda x #f) '#()))
-      (assert =
+      (check =
               (vector-every - '#(1 1) '#(1 0))
               1))
      ))

collects/tests/srfi/load-srfis.ss

@@ -28,8 +28,10 @@
 (require (lib "57.ss" "srfi"))
 (require (lib "59.ss" "srfi"))
 (require (lib "60.ss" "srfi"))
+(require (lib "66.ss" "srfi"))
 (require (lib "67.ss" "srfi"))
 (require (lib "69.ss" "srfi"))
+(require (lib "74.ss" "srfi"))
 
 (require (lib "list.ss" "srfi" "1"))
 (require (lib "time.ss" "srfi" "19"))
@@ -56,5 +58,7 @@
 (require (lib "records.ss" "srfi" "57"))
 (require (lib "vicinity.ss" "srfi" "59"))
 (require (lib "60.ss" "srfi" "60"))
+(require (lib "66.ss" "srfi" "66"))
 (require (lib "compare.ss" "srfi" "67"))
 (require (lib "hash.ss" "srfi" "69"))
+(require (lib "74.ss" "srfi" "74"))