clean up sequence & generator tests

collects/tests/racket/fixnum.rktl

@@ -224,12 +224,12 @@
 
 ;; in-flvector tests, copied from for.rktl
 
-(test-generator [(1 2 3)] (in-fxvector (fxvector 1 2 3)))
+(test-sequence [(1 2 3)] (in-fxvector (fxvector 1 2 3)))
-(test-generator [(2 3 4)] (in-fxvector (fxvector 1 2 3 4) 1))
+(test-sequence [(2 3 4)] (in-fxvector (fxvector 1 2 3 4) 1))
-(test-generator [(2 3 4)] (in-fxvector (fxvector 1 2 3 4 5) 1 4))
+(test-sequence [(2 3 4)] (in-fxvector (fxvector 1 2 3 4 5) 1 4))
-(test-generator [(2 4 6)] (in-fxvector (fxvector 1 2 3 4 5 6 7 8) 1 7 2))
+(test-sequence [(2 4 6)] (in-fxvector (fxvector 1 2 3 4 5 6 7 8) 1 7 2))
-(test-generator [(8 6 4)] (in-fxvector (fxvector 1 2 3 4 5 6 7 8) 7 1 -2))
+(test-sequence [(8 6 4)] (in-fxvector (fxvector 1 2 3 4 5 6 7 8) 7 1 -2))
-(test-generator [(2 4 6)] (in-fxvector (fxvector 1 2 3 4 5 6 7 8) 1 6 2))
+(test-sequence [(2 4 6)] (in-fxvector (fxvector 1 2 3 4 5 6 7 8) 1 6 2))
-(test-generator [(8 6 4)] (in-fxvector (fxvector 1 2 3 4 5 6 7 8) 7 2 -2))
+(test-sequence [(8 6 4)] (in-fxvector (fxvector 1 2 3 4 5 6 7 8) 7 2 -2))
 
 (report-errs)

collects/tests/racket/flonum.rktl

@@ -77,13 +77,13 @@
 
 ;; in-flvector tests, copied from for.rktl
 
-(test-generator [(1.0 2.0 3.0)] (in-flvector (flvector 1.0 2.0 3.0)))
+(test-sequence [(1.0 2.0 3.0)] (in-flvector (flvector 1.0 2.0 3.0)))
-(test-generator [(2.0 3.0 4.0)] (in-flvector (flvector 1.0 2.0 3.0 4.0) 1))
+(test-sequence [(2.0 3.0 4.0)] (in-flvector (flvector 1.0 2.0 3.0 4.0) 1))
-(test-generator [(2.0 3.0 4.0)] (in-flvector (flvector 1.0 2.0 3.0 4.0 5.0) 1 4))
+(test-sequence [(2.0 3.0 4.0)] (in-flvector (flvector 1.0 2.0 3.0 4.0 5.0) 1 4))
-(test-generator [(2.0 4.0 6.0)] (in-flvector (flvector 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0) 1 7 2))
+(test-sequence [(2.0 4.0 6.0)] (in-flvector (flvector 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0) 1 7 2))
-(test-generator [(8.0 6.0 4.0)] (in-flvector (flvector 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0) 7 1 -2))
+(test-sequence [(8.0 6.0 4.0)] (in-flvector (flvector 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0) 7 1 -2))
-(test-generator [(2.0 4.0 6.0)] (in-flvector (flvector 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0) 1 6 2))
+(test-sequence [(2.0 4.0 6.0)] (in-flvector (flvector 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0) 1 6 2))
-(test-generator [(8.0 6.0 4.0)] (in-flvector (flvector 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0) 7 2 -2))
+(test-sequence [(8.0 6.0 4.0)] (in-flvector (flvector 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0) 7 2 -2))
 
 
 

collects/tests/racket/for-util.rkt

@@ -2,12 +2,12 @@
 
 (require (for-syntax racket/base))
 
-(provide test-multi-generator
+(provide test-multi-sequence
-         test-generator)
+         test-sequence)
 
 ;; Utilities used by various tests of sequences
 
-(define-syntax (test-multi-generator stx)
+(define-syntax (test-multi-sequence stx)
   (syntax-case stx ()
     [(_ [(v ...) ...] gen)
      (with-syntax ([(id ...) (generate-temporaries #'((v ...) ...))]
@@ -32,7 +32,7 @@
                          (car (member (list id ...) `((v2 ...) ...)))))
            (void)))]))
 
-(define-syntax test-generator
+(define-syntax test-sequence
   (syntax-rules ()
     [(_ [seq] gen) ; we assume that seq has at least 2 elements, and all are unique
      (begin
@@ -97,6 +97,6 @@
                          (for/and ([(e idx) g]) (set! count (add1 count)) (equal? idx (sub1 count)))))
          (void))
        ;; Run multi-value tests:
-       (test-multi-generator [seq] gen))]
+       (test-multi-sequence [seq] gen))]
     [(_ seqs gen)
-     (test-multi-generator seqs gen)]))
+     (test-multi-sequence seqs gen)]))

collects/tests/racket/for.rktl

@@ -3,96 +3,95 @@
 
 (Section 'for)
 
-(require scheme/generator
+(require racket/mpair
-         racket/mpair
          "for-util.rkt")
 
-(test-generator [(0 1 2)] (in-range 3))
+(test-sequence [(0 1 2)] (in-range 3))
-(test-generator [(3 4 5)] (in-range 3 6))
+(test-sequence [(3 4 5)] (in-range 3 6))
-(test-generator [(7 6 5)] (in-range 7 4 -1))
+(test-sequence [(7 6 5)] (in-range 7 4 -1))
 
-(test-generator [(a b c)] '(a b c))
+(test-sequence [(a b c)] '(a b c))
-(test-generator [(a b c)] (in-list '(a b c)))
+(test-sequence [(a b c)] (in-list '(a b c)))
-(test-generator [(a b c)] (mlist 'a 'b 'c))
+(test-sequence [(a b c)] (mlist 'a 'b 'c))
-(test-generator [(a b c)] (in-mlist (mlist 'a 'b 'c)))
+(test-sequence [(a b c)] (in-mlist (mlist 'a 'b 'c)))
-(test-generator [(a b c)] #(a b c))
+(test-sequence [(a b c)] #(a b c))
-(test-generator [(a b c)] (in-vector #(a b c)))
+(test-sequence [(a b c)] (in-vector #(a b c)))
-(test-generator [(a b c)] (in-vector (chaperone-vector #(a b c) (lambda (vec i val) val) (lambda (vec i val) val))))
+(test-sequence [(a b c)] (in-vector (chaperone-vector #(a b c) (lambda (vec i val) val) (lambda (vec i val) val))))
-(test-generator [(b c d)] (in-vector #(a b c d) 1))
+(test-sequence [(b c d)] (in-vector #(a b c d) 1))
-(test-generator [(b c d)] (in-vector #(a b c d e) 1 4))
+(test-sequence [(b c d)] (in-vector #(a b c d e) 1 4))
-(test-generator [(b d f)] (in-vector #(a b c d e f g h) 1 7 2))
+(test-sequence [(b d f)] (in-vector #(a b c d e f g h) 1 7 2))
-(test-generator [(h f d)] (in-vector #(a b c d e f g h) 7 1 -2))
+(test-sequence [(h f d)] (in-vector #(a b c d e f g h) 7 1 -2))
-(test-generator [(b d f)] (in-vector #(a b c d e f g h) 1 6 2))
+(test-sequence [(b d f)] (in-vector #(a b c d e f g h) 1 6 2))
-(test-generator [(h f d)] (in-vector #(a b c d e f g h) 7 2 -2))
+(test-sequence [(h f d)] (in-vector #(a b c d e f g h) 7 2 -2))
-(test-generator [(c b a)] (in-vector #(a b c) 2 -1 -1))
+(test-sequence [(c b a)] (in-vector #(a b c) 2 -1 -1))
 ;; Test indices out of bounds
 (err/rt-test (for/list ([x (in-vector #(a b c d) 0 6 2)]) x) exn:fail:contract?)
 (err/rt-test (for/list ([x (in-vector #(a b c d) 6 0 -2)]) x) exn:fail:contract?)
-(test-generator [(#\a #\b #\c)] "abc")
+(test-sequence [(#\a #\b #\c)] "abc")
-(test-generator [(#\a #\u3bb #\c)] "a\u03BBc")
+(test-sequence [(#\a #\u3bb #\c)] "a\u03BBc")
-(test-generator [(#\a #\b #\c)] (in-string "abc"))
+(test-sequence [(#\a #\b #\c)] (in-string "abc"))
-(test-generator [(#\a #\u3bb #\c)] (in-string "a\u03BBc"))
+(test-sequence [(#\a #\u3bb #\c)] (in-string "a\u03BBc"))
-(test-generator [(#\a #\b #\c)] (in-string "zzabc" 2))
+(test-sequence [(#\a #\b #\c)] (in-string "zzabc" 2))
-(test-generator [(#\a #\b #\c)] (in-string "zzabc" 2 #f))
+(test-sequence [(#\a #\b #\c)] (in-string "zzabc" 2 #f))
-(test-generator [(#\a #\b #\c)] (in-string "zzabcqq" 2 5))
+(test-sequence [(#\a #\b #\c)] (in-string "zzabcqq" 2 5))
-(test-generator [(#\a #\b #\c)] (in-string "zzaxbyc" 2 #f 2))
+(test-sequence [(#\a #\b #\c)] (in-string "zzaxbyc" 2 #f 2))
-(test-generator [(#\a #\b #\c)] (in-string "zzaxbycy" 2 #f 2))
+(test-sequence [(#\a #\b #\c)] (in-string "zzaxbycy" 2 #f 2))
-(test-generator [(65 66 67)] #"ABC")
+(test-sequence [(65 66 67)] #"ABC")
-(test-generator [(65 66 67)] (in-bytes #"ABC"))
+(test-sequence [(65 66 67)] (in-bytes #"ABC"))
-(test-generator [(65 66 67)] (in-bytes #"ZZABC" 2))
+(test-sequence [(65 66 67)] (in-bytes #"ZZABC" 2))
-(test-generator [(65 66 67)] (in-bytes #"ZZABC" 2 #f))
+(test-sequence [(65 66 67)] (in-bytes #"ZZABC" 2 #f))
-(test-generator [(65 66 67)] (in-bytes #"ZZABCQQ" 2 5))
+(test-sequence [(65 66 67)] (in-bytes #"ZZABCQQ" 2 5))
-(test-generator [(65 66 67)] (in-bytes #"ZZAXBYC" 2 #f 2))
+(test-sequence [(65 66 67)] (in-bytes #"ZZAXBYC" 2 #f 2))
-(test-generator [(65 66 67)] (in-bytes #"ZZAXBYCY" 2 #f 2))
+(test-sequence [(65 66 67)] (in-bytes #"ZZAXBYCY" 2 #f 2))
-(test-generator [(#\a #\b #\c)] (in-input-port-chars (open-input-string "abc")))
+(test-sequence [(#\a #\b #\c)] (in-input-port-chars (open-input-string "abc")))
-(test-generator [(65 66 67)] (open-input-bytes #"ABC"))
+(test-sequence [(65 66 67)] (open-input-bytes #"ABC"))
-(test-generator [(65 66 67)] (in-input-port-bytes (open-input-bytes #"ABC")))
+(test-sequence [(65 66 67)] (in-input-port-bytes (open-input-bytes #"ABC")))
 
-(test-generator [(1 2 3)] (in-port read (open-input-string "1 2 3")))
+(test-sequence [(1 2 3)] (in-port read (open-input-string "1 2 3")))
-(test-generator [((123) 4)] (in-port read (open-input-string "(123) 4")))
+(test-sequence [((123) 4)] (in-port read (open-input-string "(123) 4")))
-(test-generator [(65 66 67)] (in-port read-byte (open-input-string "ABC")))
+(test-sequence [(65 66 67)] (in-port read-byte (open-input-string "ABC")))
 
-(test-generator [("abc" "def")] (in-lines (open-input-string "abc\ndef")))
+(test-sequence [("abc" "def")] (in-lines (open-input-string "abc\ndef")))
-(test-generator [(#"abc" #"def")] (in-bytes-lines (open-input-string "abc\ndef")))
+(test-sequence [(#"abc" #"def")] (in-bytes-lines (open-input-string "abc\ndef")))
 
-(test-generator [(0 1 2 3 4 5)] (in-sequences (in-range 6)))
+(test-sequence [(0 1 2 3 4 5)] (in-sequences (in-range 6)))
-(test-generator [(0 1 2 3 4 5)] (in-sequences (in-range 4) '(4 5)))
+(test-sequence [(0 1 2 3 4 5)] (in-sequences (in-range 4) '(4 5)))
-(test-generator [(0 1 2 3 4 5)] (in-sequences (in-range 6) '()))
+(test-sequence [(0 1 2 3 4 5)] (in-sequences (in-range 6) '()))
-(test-generator [(0 1 2 3 4 5)] (in-sequences '() (in-range 4) '() '(4 5)))
+(test-sequence [(0 1 2 3 4 5)] (in-sequences '() (in-range 4) '() '(4 5)))
-(test-generator [(0 1 2 3 4 5)] (in-sequences (in-range 0 2) (in-range 2 4) (in-range 4 6)))
+(test-sequence [(0 1 2 3 4 5)] (in-sequences (in-range 0 2) (in-range 2 4) (in-range 4 6)))
-(test-generator [(0 1 2 3 4 5)] (in-sequences (in-range 0 2)
+(test-sequence [(0 1 2 3 4 5)] (in-sequences (in-range 0 2)
                                               (in-sequences (in-range 2 4) (in-range 4 6))))
-(test-generator [(0 1 2 3 #\a #\b #\c) (10 11 12 13 #\A #\B #\C)]
+(test-sequence [(0 1 2 3 #\a #\b #\c) (10 11 12 13 #\A #\B #\C)]
                 (in-sequences (in-parallel (in-range 0 4) (in-range 10 14))
                               (in-parallel "abc" "ABC")))
 
 ;; use in-parallel to get a finite number of items
-(test-generator [(0 1 2 3 0 1 2 3) (0 1 2 3 4 5 6 7)]
+(test-sequence [(0 1 2 3 0 1 2 3) (0 1 2 3 4 5 6 7)]
                 (in-parallel (in-cycle (in-range 0 4)) (in-range 0 8)))
-(test-generator [(0 1 2 3 4 5 6 7) (0 1 2 0 1 2 0 1)]
+(test-sequence [(0 1 2 3 4 5 6 7) (0 1 2 0 1 2 0 1)]
                 (in-parallel (in-range 0 8) (in-cycle (in-range 0 3))))
-(test-generator [(0 1 2 3 2 1 0 1) (0 1 2 3 4 5 6 7)]
+(test-sequence [(0 1 2 3 2 1 0 1) (0 1 2 3 4 5 6 7)]
                 (in-parallel (in-cycle (in-range 0 4) (in-range 2 0 -1)) (in-range 0 8)))
 
-(test-generator [(0 1 2) (a b c)] (in-parallel (in-range 3) (in-list '(a b c))))
+(test-sequence [(0 1 2) (a b c)] (in-parallel (in-range 3) (in-list '(a b c))))
-(test-generator [(0 1 2) (a b c)] (in-parallel (in-range 10) (in-list '(a b c))))
+(test-sequence [(0 1 2) (a b c)] (in-parallel (in-range 10) (in-list '(a b c))))
-(test-generator [(0 1 2) (a b c)] (in-parallel (in-range 3) (in-list '(a b c d))))
+(test-sequence [(0 1 2) (a b c)] (in-parallel (in-range 3) (in-list '(a b c d))))
-(test-generator [(0 1 2) (a b c)] (in-parallel (in-range 3) '(a b c)))
+(test-sequence [(0 1 2) (a b c)] (in-parallel (in-range 3) '(a b c)))
 
-(test-generator [(a b c)] (stop-after (in-list '(a b c d e)) (lambda (x) (equal? x 'c))))
+(test-sequence [(a b c)] (stop-after (in-list '(a b c d e)) (lambda (x) (equal? x 'c))))
-(test-generator [(a b c)] (stop-before (in-list '(a b c d e)) (lambda (x) (equal? x 'd))))
+(test-sequence [(a b c)] (stop-before (in-list '(a b c d e)) (lambda (x) (equal? x 'd))))
-(test-generator [(3 4 5)] (stop-before (in-naturals 3) (lambda (x) (= x 6))))
+(test-sequence [(3 4 5)] (stop-before (in-naturals 3) (lambda (x) (= x 6))))
 
-(test-generator [(a b c) (0 1 2)] (in-indexed '(a b c)))
+(test-sequence [(a b c) (0 1 2)] (in-indexed '(a b c)))
 
-(test-generator [(1 2 3 4 5)]
+(test-sequence [(1 2 3 4 5)]
   (parameterize ([current-input-port (open-input-string "1 2 3\n4 5")])
     (for/list ([i (in-producer read eof)]) i)))
-(test-generator [(1 2 3 4 5)]
+(test-sequence [(1 2 3 4 5)]
   (for/list ([i (in-producer read eof (open-input-string "1 2 3\n4 5"))]) i))
-(test-generator [("1 2 3" "4 5")]
+(test-sequence [("1 2 3" "4 5")]
   (for/list ([i (in-producer read-line eof-object? (open-input-string "1 2 3\n4 5"))]) i))
-(test-generator [((1 2) (3 4) (5 ,eof))]
+(test-sequence [((1 2) (3 4) (5 ,eof))]
   (for/list ([(i j)
               (in-producer (lambda (p) (values (read p) (read p)))
                            (lambda (x y) (and (eof-object? x) (eof-object? y)))
@@ -182,85 +181,6 @@
   (test 13 next)
   (test #f more?))
 
-(test-generator [(0 1 2)] (in-generator (yield 0) (yield 1) (yield 2)))
-(let ([g (lambda () (in-generator (yield 0) (yield 1) (yield 2)))])
-  (test-generator [(0 1 2)] (g)))
-(test '((1 0) (2 1) (3 2)) 'indexed-generator
-      (for/list ([(x i) (in-indexed (in-generator (yield 1) (yield 2) (yield 3)))])
-        (list x i)))
-
-;; test multiple values for in-generator
-(test '[(1 2) (3 4)] 'for*-generator
-      (for*/list ([(n after)
-              (in-generator
-                (yield 1 2)
-                (yield 3 4))])
-            (list n after)))
-
-;; test 0-ary yields
-(test '(0 1 2) 'no-bind-in-generator
-   (for/list ([() (in-generator (yield) (yield) (yield))]
-              [i (in-naturals)])
-     i))
-
-(let ([helper (lambda (i)
-                (yield (add1 i)))])
-  (test '(1 2 3) 'parameterized-yield
-        (for/list ([x (in-generator (helper 0) (helper 1) (helper 2))])
-                  x)))
-
-(let ([g (lambda () (generator () (yield 1) (yield 2) (yield 3)))])
-  (let ([g (g)]) (test '(1 2 3) list (g) (g) (g)))
-  (let ([g (g)]) (test '(1 2 3 10 10) list (g) (g) (g) (g 10) (g)))
-  (let ([g (generator () (yield (yield (yield 1))))])
-    (test '(1 2 3 4 4 4) list (g) (g 2) (g 3) (g 4) (g) (g)))
-  (let ([g (g)])
-    (test '(fresh 1 suspended 2 suspended 3 suspended last done)
-          list (generator-state g) (g)
-               (generator-state g) (g)
-               (generator-state g) (g)
-               (generator-state g) (g 'last)
-               (generator-state g)))
-  (letrec ([g (generator () (yield (generator-state g))
-                            (yield (generator-state g)))])
-    (test '(fresh running suspended running suspended last done)
-          list (generator-state g) (g)
-               (generator-state g) (g)
-               (generator-state g) (g 'last)
-               (generator-state g))))
-
-(let* ([helper (lambda (pred num)
-                 (for ([i (in-range 0 3)]) (yield (pred (+ i num)))))]
-       [g1 (generator () (helper odd? 1) (yield 'odd))]
-       [g2 (generator () (helper even? 1) (yield 'even))])
-  (test '(#t #f #f #t #t #f odd even) 'yield-helper
-        (list (g1) (g2) (g1) (g2) (g1) (g2) (g1) (g2))))
-
-(test '(1 2 3)
-      'sequence->generator-1
-      (let ([maker (sequence->generator '(1 2 3))])
-        (list (maker) (maker) (maker))))
-
-(test '(1 2 3)
-      'sequence->generator-2
-      (let ([maker (sequence->generator (in-list '(1 2 3)))])
-        (list (maker) (maker) (maker))))
-
-(test '(0 1 2 3 4)
-      'sequence->generator-3
-      (let ([maker (sequence->generator (in-range 0 5))])
-        (list (maker) (maker) (maker) (maker) (maker))))
-
-(test '(0 1 2 3 4)
-      'sequence->generator-4
-      (let ([maker (sequence->generator (in-naturals))])
-        (list (maker) (maker) (maker) (maker) (maker))))
-
-(test '(1 2 3 1 2 3)
-      'sequence->repeated-generator
-      (let ([maker (sequence->repeated-generator '(1 2 3))])
-        (list (maker) (maker) (maker)
-              (maker) (maker) (maker))))
 
 ;; New operators
 (require racket/stream)

collects/tests/racket/generator.rktl

@@ -3,12 +3,93 @@
 
 (Section 'generator)
 
-(require racket/generator)
+(require racket/generator
+         "for-util.rkt")
 
 (test #f generator? 5)
 (test #f generator? void)
 (test #f generator? error)
 
+(test-sequence [(0 1 2)] (in-generator (yield 0) (yield 1) (yield 2)))
+(let ([g (lambda () (in-generator (yield 0) (yield 1) (yield 2)))])
+  (test-sequence [(0 1 2)] (g)))
+(test '((1 0) (2 1) (3 2)) 'indexed-generator
+      (for/list ([(x i) (in-indexed (in-generator (yield 1) (yield 2) (yield 3)))])
+        (list x i)))
+
+;; test multiple values for in-generator
+(test '[(1 2) (3 4)] 'for*-generator
+      (for*/list ([(n after)
+              (in-generator
+                (yield 1 2)
+                (yield 3 4))])
+            (list n after)))
+
+;; test 0-ary yields
+(test '(0 1 2) 'no-bind-in-generator
+   (for/list ([() (in-generator (yield) (yield) (yield))]
+              [i (in-naturals)])
+     i))
+
+(let ([helper (lambda (i)
+                (yield (add1 i)))])
+  (test '(1 2 3) 'parameterized-yield
+        (for/list ([x (in-generator (helper 0) (helper 1) (helper 2))])
+                  x)))
+
+(let ([g (lambda () (generator () (yield 1) (yield 2) (yield 3)))])
+  (let ([g (g)]) (test '(1 2 3) list (g) (g) (g)))
+  (let ([g (g)]) (test '(1 2 3 10 10) list (g) (g) (g) (g 10) (g)))
+  (let ([g (generator () (yield (yield (yield 1))))])
+    (test '(1 2 3 4 4 4) list (g) (g 2) (g 3) (g 4) (g) (g)))
+  (let ([g (g)])
+    (test '(fresh 1 suspended 2 suspended 3 suspended last done)
+          list (generator-state g) (g)
+               (generator-state g) (g)
+               (generator-state g) (g)
+               (generator-state g) (g 'last)
+               (generator-state g)))
+  (letrec ([g (generator () (yield (generator-state g))
+                            (yield (generator-state g)))])
+    (test '(fresh running suspended running suspended last done)
+          list (generator-state g) (g)
+               (generator-state g) (g)
+               (generator-state g) (g 'last)
+               (generator-state g))))
+
+(let* ([helper (lambda (pred num)
+                 (for ([i (in-range 0 3)]) (yield (pred (+ i num)))))]
+       [g1 (generator () (helper odd? 1) (yield 'odd))]
+       [g2 (generator () (helper even? 1) (yield 'even))])
+  (test '(#t #f #f #t #t #f odd even) 'yield-helper
+        (list (g1) (g2) (g1) (g2) (g1) (g2) (g1) (g2))))
+
+(test '(1 2 3)
+      'sequence->generator-1
+      (let ([maker (sequence->generator '(1 2 3))])
+        (list (maker) (maker) (maker))))
+
+(test '(1 2 3)
+      'sequence->generator-2
+      (let ([maker (sequence->generator (in-list '(1 2 3)))])
+        (list (maker) (maker) (maker))))
+
+(test '(0 1 2 3 4)
+      'sequence->generator-3
+      (let ([maker (sequence->generator (in-range 0 5))])
+        (list (maker) (maker) (maker) (maker) (maker))))
+
+(test '(0 1 2 3 4)
+      'sequence->generator-4
+      (let ([maker (sequence->generator (in-naturals))])
+        (list (maker) (maker) (maker) (maker) (maker))))
+
+(test '(1 2 3 1 2 3)
+      'sequence->repeated-generator
+      (let ([maker (sequence->repeated-generator '(1 2 3))])
+        (list (maker) (maker) (maker)
+              (maker) (maker) (maker))))
+
 (let ([g (generator () 
                     (test 'next 'yield (yield 0))
                     (yield 1)