AtlatestRepositorysigil-quic

sigil-quic / tree / testtest-stream.sgl

1(import (sigil test)
2 (sigil process)
3 (sigil crypto)
4 (sigil quic bytes)
5 (sigil quic wire)
6 (sigil quic error)
7 (sigil quic frame)
8 (sigil quic connection)
9 (sigil quic stream)
10 (sigil quic stream state))
12(define (stream-test-data offset bytes fin? . ids)
13 (make-quic-frame (if fin? 15 14)
14 (list (cons 'stream-id (if (pair? ids) (car ids) 0)) (cons 'offset offset) (cons 'data bytes))))
16(define (stream-test-ready role window)
17 (let ((state (make-stream-state role receive-window: window)))
18 (stream-state-set-peer! state window window 1)
19 state))
21(define (stream-test-error code operation)
22 (let ((caught (guard (exn (else exn)) (operation) #f)))
23 (assert-true (quic-error? caught))
24 (assert-equal code (quic-error-code caught))))
26(define (stream-test-control expected actual)
27 (assert-equal (if (equal? (getenv "QUIC_STREAM_RED") "1") (flip-byte expected 0) expected) actual))
29(define (stream-test-pair window)
30 (let* ((key (ecdsa-p256-generate-keypair))
31 (original #u8(1 2 3 4 5 6 7 8))
32 (client-id #u8(11 12 13 14 15 16 17 18))
33 (server-id #u8(21 22 23 24 25 26 27 28))
34 (client (make-quic-client (list #u8(113 49)) "example.test"
35 (stream-transport-parameters 'client receive-window: window)
36 (lambda (certificates name) (and (equal? certificates (list #u8(48 1 0))) (cdr key)))
37 local-id: client-id destination-id: original))
38 (server (make-quic-server (list #u8(113 49))
39 (stream-transport-parameters 'server receive-window: window)
40 (list #u8(48 1 0)) (car key) original client-id local-id: server-id))
41 (client-stream (make-quic-stream client))
42 (server-stream (make-quic-stream server)))
43 (quic-start! client 0)
44 (vector client server client-stream server-stream)))
46(define (stream-test-deliver! pair side now)
47 (for-each (lambda (packet) (quic-receive! (vector-ref pair (- 1 side)) packet now))
48 (quic-take-datagrams! (vector-ref pair side) now)))
50(define (stream-test-pump! pair now)
51 (do ((i 0 (+ i 1))) ((= i 6))
52 (stream-test-deliver! pair 0 now)
53 (stream-test-deliver! pair 1 now)))
55(test-group "QUIC bounded stream state"
56 (test "stream-control: FIN frame has explicit offset and length"
57 (let* ((state (stream-test-ready 'client 4)) (frame (stream-state-write! state #u8(1 2 3) #t)))
58 (stream-test-control #u8(15 0 0 3 1 2 3) (encode-frame frame))))
59 (test "stream-control: consumed bytes replenish both absolute credits"
60 (let ((state (stream-test-ready 'server 4)))
61 (stream-state-input! state (stream-test-data 0 #u8(1 2) #f))
62 (assert-equal #u8(1 2) (stream-state-read! state))
63 (stream-test-control #u8(16 6 17 0 6)
64 (encode-frames (stream-state-credit-frames! state) 'application 'server))))
65 (test "stream and connection send credit are independent and monotonic"
66 (let ((state (make-stream-state 'client receive-window: 4)))
67 (stream-state-set-peer! state 3 2 1)
68 (assert-equal 2 (stream-state-available state))
69 (assert-false (stream-state-write! state #u8(1 2 3) #f))
70 (stream-state-write! state #u8() #f)
71 (stream-state-input! state (make-quic-frame 17 (list (cons 'stream-id 0) (cons 'maximum 4))))
72 (assert-equal 3 (stream-state-available state))))
73 (test "zero peer stream count prevents even an empty FIN"
74 (let ((state (make-stream-state 'client receive-window: 4)))
75 (stream-state-set-peer! state 0 0 0)
76 (assert-false (stream-state-write! state #u8() #t))
77 (stream-state-input! state (make-quic-frame 18 (list (cons 'maximum 1))))
78 (assert-true (quic-frame? (stream-state-write! state #u8() #t)))
79 (assert-true (stream-state-send-closed? state))))
80 (test "server cannot write until stream zero is opened by its peer"
81 (let ((state (stream-test-ready 'server 4)))
82 (assert-false (stream-state-write! state #u8(1) #f))
83 (stream-state-input! state (stream-test-data 0 #u8() #f))
84 (assert-true (quic-frame? (stream-state-write! state #u8(1) #f)))))
85 (test "reversed data and FIN deliver one ordered byte stream"
86 (let ((state (stream-test-ready 'server 8)))
87 (stream-state-input! state (stream-test-data 3 #u8(4 5) #t))
88 (assert-false (stream-state-eof? state))
89 (assert-equal #u8() (stream-state-read! state))
90 (stream-state-input! state (stream-test-data 0 #u8(1 2 3) #f))
91 (assert-equal #u8(1 2) (stream-state-read! state maximum: 2))
92 (assert-false (stream-state-eof? state))
93 (assert-equal #u8(3 4 5) (stream-state-read! state))
94 (assert-true (stream-state-eof? state))))
95 (test "matching overlap and replay of delivered bytes never duplicate output"
96 (let ((state (stream-test-ready 'server 8)))
97 (stream-state-input! state (stream-test-data 0 #u8(1 2) #f))
98 (stream-state-input! state (stream-test-data 1 #u8(2 3) #f))
99 (assert-equal #u8(1 2 3) (stream-state-read! state))
100 (stream-state-input! state (stream-test-data 0 #u8(1 2 3) #f))
101 (assert-equal #u8() (stream-state-read! state))))
102 (test "inconsistent buffered overlap is PROTOCOL_VIOLATION"
103 (let ((state (stream-test-ready 'server 8)))
104 (stream-state-input! state (stream-test-data 2 #u8(1 2) #f))
105 (stream-test-error 10 (lambda () (stream-state-input! state (stream-test-data 3 #u8(9) #f))))))
106 (test "highest offset and empty FIN both consume receive credit"
107 (let ((state (stream-test-ready 'server 4)))
108 (stream-test-error 3 (lambda () (stream-state-input! state (stream-test-data 5 #u8() #t))))))
109 (test "data beyond advertised receive credit is FLOW_CONTROL_ERROR"
110 (let ((state (stream-test-ready 'server 4)))
111 (stream-test-error 3 (lambda () (stream-state-input! state (stream-test-data 3 #u8(1 2) #f))))))
112 (test "changing FIN final size is FINAL_SIZE_ERROR"
113 (let ((state (stream-test-ready 'server 8)))
114 (stream-state-input! state (stream-test-data 3 #u8() #t))
115 (stream-test-error 6 (lambda () (stream-state-input! state (stream-test-data 4 #u8() #t))))))
116 (test "FIN below previously received highest offset is FINAL_SIZE_ERROR"
117 (let ((state (stream-test-ready 'server 8)))
118 (stream-state-input! state (stream-test-data 4 #u8(1) #f))
119 (stream-test-error 6 (lambda () (stream-state-input! state (stream-test-data 3 #u8() #t))))))
120 (test "RESET final size must agree with FIN and highest offset"
121 (let ((state (stream-test-ready 'server 8)))
122 (stream-state-input! state (stream-test-data 2 #u8(1 2) #t))
123 (stream-test-error 6
124 (lambda () (stream-state-input! state (make-quic-frame 4
125 (list (cons 'stream-id 0) (cons 'error 7) (cons 'final-size 3))))))))
126 (test "RESET code zero is observable and clears buffered data"
127 (let ((state (stream-test-ready 'server 8)))
128 (stream-state-input! state (stream-test-data 2 #u8(1 2) #f))
129 (stream-state-input! state (make-quic-frame 4
130 (list (cons 'stream-id 0) (cons 'error 0) (cons 'final-size 4))))
131 (assert-equal 0 (stream-state-reset-code state))
132 (assert-error (stream-state-read! state))
133 (stream-test-error 6 (lambda () (stream-state-input! state (stream-test-data 5 #u8(1) #f))))))
134 (test "STOP_SENDING resets once with committed offset and matching error"
135 (let ((state (stream-test-ready 'client 8)))
136 (stream-state-write! state #u8(1 2 3) #f)
137 (let ((frames (stream-state-input! state (make-quic-frame 5 (list (cons 'stream-id 0) (cons 'error 42))))))
138 (assert-equal 4 (quic-frame-type (car frames)))
139 (assert-equal 3 (frame-ref (car frames) 'final-size))
140 (assert-equal 42 (frame-ref (car frames) 'error)))
141 (assert-true (stream-state-take-cancel! state))
142 (assert-false (stream-state-take-cancel! state))
143 (assert-equal '() (stream-state-input! state (make-quic-frame 5 (list (cons 'stream-id 0) (cons 'error 42)))))
144 (assert-error (stream-state-write! state #u8(4) #f))))
145 (test "peer cannot reference an unopened client stream"
146 (let ((state (stream-test-ready 'client 8)))
147 (stream-test-error 5 (lambda () (stream-state-input! state (stream-test-data 0 #u8(1) #f))))))
148 (test "extra peer bidi and uni streams exceed the advertised stream limit"
149 (for-each
150 (lambda (id)
151 (let ((state (stream-test-ready 'server 8)))
152 (stream-test-error 4 (lambda () (stream-state-input! state (stream-test-data 0 #u8() #f id))))))
153 '(2 4 6)))
154 (test "server-initiated stream is forbidden by the client's zero limit"
155 (let ((state (stream-test-ready 'client 8)))
156 (stream-test-error 4 (lambda () (stream-state-input! state (stream-test-data 0 #u8() #f 1))))))
157 (test "MAX_DATA and MAX_STREAM_DATA ignore decreasing credit"
158 (let ((state (stream-test-ready 'client 8)))
159 (stream-state-write! state #u8() #f)
160 (stream-state-input! state (make-quic-frame 16 (list (cons 'maximum 4))))
161 (stream-state-input! state (make-quic-frame 17 (list (cons 'stream-id 0) (cons 'maximum 5))))
162 (assert-equal 8 (stream-state-available state))
163 (stream-state-input! state (make-quic-frame 16 (list (cons 'maximum 12))))
164 (stream-state-input! state (make-quic-frame 17 (list (cons 'stream-id 0) (cons 'maximum 10))))
165 (assert-equal 10 (stream-state-available state))))
166 (test "close is idempotent and prevents further buffer access"
167 (let ((state (stream-test-ready 'server 8)))
168 (stream-state-close! state)
169 (stream-state-close! state)
170 (assert-true (stream-state-closed? state))
171 (assert-error (stream-state-read! state))
172 (assert-error (stream-state-input! state (stream-test-data 0 #u8(1) #f))))))
174(test-group "QUIC protected bidirectional stream"
175 (test "request and response transfer through independent stream directions"
176 (let ((pair (stream-test-pair 32)))
177 (stream-test-pump! pair 0)
178 (assert-equal 3 (quic-stream-write! (vector-ref pair 2) #u8(1 2 3) fin?: #t))
179 (stream-test-pump! pair 0)
180 (assert-equal #u8(1 2 3) (quic-stream-read! (vector-ref pair 3)))
181 (assert-true (quic-stream-eof? (vector-ref pair 3)))
182 (assert-equal 2 (quic-stream-write! (vector-ref pair 3) #u8(4 5) fin?: #t))
183 (stream-test-pump! pair 0)
184 (assert-equal #u8(4 5) (quic-stream-read! (vector-ref pair 2)))
185 (assert-true (quic-stream-eof? (vector-ref pair 2)))
186 (assert-false (quic-failure (vector-ref pair 0)))
187 (assert-false (quic-failure (vector-ref pair 1)))))
188 (test "transfer exceeding receive capacity progresses only as bytes are consumed"
189 (let ((pair (stream-test-pair 32)) (payload (make-bytevector 100 0))
190 (sent 0) (request #u8()) (response #u8()))
191 (do ((i 0 (+ i 1))) ((= i 100)) (bytevector-u8-set! payload i i))
192 (stream-test-pump! pair 0)
193 (do ((round 0 (+ round 1))) ((= round 12))
194 (unless (quic-stream-send-closed? (vector-ref pair 2))
195 (set! sent (+ sent (quic-stream-write! (vector-ref pair 2) (bytevector-copy payload sent) fin?: #t))))
196 (stream-test-pump! pair 0)
197 (let ((bytes (quic-stream-read! (vector-ref pair 3))))
198 (set! request (bytes-append request bytes))
199 (when (or (> (bytevector-length bytes) 0)
200 (and (quic-stream-eof? (vector-ref pair 3))
201 (not (quic-stream-send-closed? (vector-ref pair 3)))))
202 (assert-equal (bytevector-length bytes)
203 (quic-stream-write! (vector-ref pair 3) bytes fin?: (quic-stream-eof? (vector-ref pair 3))))))
204 (stream-test-pump! pair 0)
205 (set! response (bytes-append response (quic-stream-read! (vector-ref pair 2))))
206 (stream-test-pump! pair 0))
207 (assert-equal 100 sent)
208 (assert-equal payload request)
209 (assert-equal payload response)
210 (assert-true (quic-stream-eof? (vector-ref pair 2)))
211 (assert-true (quic-stream-eof? (vector-ref pair 3)))))
212 (test "STOP_SENDING cancels both queued and lost in-flight STREAM data"
213 (let ((pair (stream-test-pair 1000)))
214 (stream-test-pump! pair 0)
215 (quic-stream-write! (vector-ref pair 2) #u8(1))
216 (stream-test-pump! pair 0)
217 (quic-stream-write! (vector-ref pair 2) (make-bytevector 900 7))
218 (assert-true (pair? (quic-take-datagrams! (vector-ref pair 0) 0)))
219 (quic-stream-write! (vector-ref pair 2) #u8(8 9))
220 (assert-true (quic-stream-outstanding? (vector-ref pair 0) 0))
221 (assert-true (quic-stream-stop! (vector-ref pair 3) 42))
222 (stream-test-deliver! pair 1 0)
223 (assert-false (quic-stream-outstanding? (vector-ref pair 0) 0))
224 (stream-test-pump! pair 0)
225 (assert-equal 42 (quic-stream-reset-code (vector-ref pair 3)))
226 (assert-error (quic-stream-write! (vector-ref pair 2) #u8(3)))
227 (quic-tick! (vector-ref pair 0) 1000)
228 (stream-test-pump! pair 1000)
229 (assert-false (quic-stream-outstanding? (vector-ref pair 0) 0))
230 (assert-false (quic-failure (vector-ref pair 0)))))
231 (test "authenticated stream flow violation closes connection with code three"
232 (let ((pair (stream-test-pair 32)))
233 (stream-test-pump! pair 0)
234 (quic-send-frame! (vector-ref pair 0) (stream-test-data 32 #u8(1) #f))
235 (stream-test-deliver! pair 0 0)
236 (assert-true (quic-closed? (vector-ref pair 1)))
237 (assert-equal 3 (quic-error-code (quic-failure (vector-ref pair 1))))
238 (assert-error (quic-stream-read! (vector-ref pair 3)))))
239 (test "adapter rejects parameters advertising more receive storage than it owns"
240 (let ((client (make-quic-client (list #u8(113 49)) "example.test" '()
241 (lambda (certificates name) #f))))
242 (assert-error (make-quic-stream client))))
243 (test "local parameter copies cannot mutate the encoded handshake parameters"
244 (let* ((pair (stream-test-pair 32)) (client (vector-ref pair 0))
245 (parameters (quic-local-parameters client)))
246 (bytevector-u8-set! (cdr (assoc 4 parameters)) 0 0)
247 (assert-equal #u8(32) (cdr (assoc 4 (quic-local-parameters client))))))
248 (test "connection timeout closes the attached stream and clears its receiver"
249 (let ((pair (stream-test-pair 32)))
250 (assert-error (quic-stream-write! (vector-ref pair 2) #u8(1)))
251 (quic-tick! (vector-ref pair 0) 10000)
252 (assert-true (quic-closed? (vector-ref pair 0)))
253 (assert-error (quic-stream-read! (vector-ref pair 2))))))