blob: ff0e3cce826a9eb89e35a13dc698d2c9ca4f6b2a (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
|
;;; Commentary:
;; Tests (srfi srfi-41 util).
;; Currently only tests stream-paginate.
;;; Code:
(define-module (test srfi-41-util)
:use-module (srfi srfi-64)
:use-module (srfi srfi-88)
: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"
'((0 1 2) (3 4 5) (6 7 8) (9))
(let ((strm (stream-paginate (stream 0 1 2 3 4 5 6 7 8 9) 3)))
(map stream->list (stream->list strm))))
(test-equal "slice of infinite"
'(1000 1001 1002 1003 1004 1005 1006 1007 1008 1009)
(let ((strm (stream-paginate (stream-from 0))))
(stream->list (stream-ref strm 100))))
(define unique-symbol (gensym))
(test-equal "time out on infinite 'empty' stream"
unique-symbol
;; defined outside time limit since creation should always
;; succeed. Only reference is expected to fail.
(let ((strm (stream-paginate
;; easy way to get stream which never finds
;; any elements.
(stream-filter negative? (stream-from 0)))))
(call-with-time-limit
0.1
(lambda () (stream-car strm))
(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)))))
(test-skip "time limited stream")
(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))))
|
