1 files changed, 50 insertions, 8 deletions
diff --git a/tests/test/srfi-41-util.scm b/tests/test/srfi-41-util.scm
index 176fb38e..12eccac5 100644
--- a/tests/test/srfi-41-util.scm
+++ b/tests/test/srfi-41-util.scm
@@ -6,14 +6,8 @@
 (define-module (test srfi-41-util)
   :use-module (srfi srfi-64)
   :use-module (srfi srfi-88)
-  :use-module ((srfi srfi-41 util) :select (stream-paginate))
-  :use-module ((srfi srfi-41)
-               :select (stream->list
-                        stream-ref
-                        stream-from
-                        stream-filter
-                        stream-car
-                        stream))
+  :use-module (srfi srfi-41 util)
+  :use-module (srfi srfi-41)
   :use-module ((ice-9 sandbox) :select (call-with-time-limit)))
 
 (test-equal "Finite stream"
@@ -42,3 +36,51 @@
      (lambda _ unique-symbol))))
 
 
+
+
+(test-equal "stream insert"
+  '(1 4 5 7 8)
+  (stream->list (stream-insert < 5 (stream 1 4 7 8))))
+
+
+(test-equal "Filter sorted stream"
+  '(4 6 8)
+  (stream->list (filter-sorted-stream even? (stream 1 3 4 6 8 9 11))))
+
+(test-equal "Filter sorted stream (which actually is unsorted)"
+  '(4 6 8)
+  (stream->list (filter-sorted-stream even? (stream 1 3 4 6 8 9 11 12))))
+
+;; TODO filter-sorted-stream*
+
+(test-equal
+    "Get stream interval"
+    '(5 6 7 8 9)
+    (stream->list (get-stream-interval (lambda (x) (< 4 x))
+                                       (lambda (x) (< x 10))
+                                       (stream 1 2 3 4 5 6 7 8 9 10 11 12))))
+
+
+
+(test-equal "stream find" 2 (stream-find even? (stream-from 1)))
+
+
+(test-equal
+    "repeating naturals"
+    '(1 1 1 2 2 2 3 3 3 4)
+    (stream->list 10 (repeating-naturals 1 3)))
+
+
+;; sleep will return early if a singal arrives, this just resumes sleeping until
+;; the wanted time is hit.
+;; Might sleep longer since sleep always returns a whole number of seconds remaining
+(define (true-sleep n)
+  (let loop ((remaining n))
+    (unless (zero? remaining)
+      (loop (sleep remaining)))))
+
+(let ((strm (stream-map (lambda (x) (when (zero? (modulo x 4)) (true-sleep 1)) x) (stream-from 1))))
+  (let ((strm (stream-timeslice-limit strm 0.1)))
+    (test-equal "time limited stream"
+      '(1 2 3)
+      (stream->list strm))))