AtlatestRepositorysigil-quic

sigil-quic / tree / testtest-stream-sequence.sgl

1(import (sigil test)
2 (sigil process)
3 (sigil crypto)
4 (sigil quic connection)
5 (sigil quic stream)
6 (sigil quic bytes)
7 (sigil quic wire)
8 (sigil quic error)
9 (sigil quic frame)
10 (sigil quic stream state))
12(define (sequence-test-state role window maximum)
13 (let ((state (make-stream-state role receive-window: window maximum-streams: maximum)))
14 (stream-state-set-peer! state window window maximum)
15 state))
17(define (sequence-test-data id bytes . fin)
18 (make-quic-frame (if (and (pair? fin) (car fin)) 15 14)
19 (list (cons 'stream-id id) (cons 'offset 0) (cons 'data bytes))))
21(define (sequence-test-finish! state incoming outgoing)
22 (when (eq? (stream-state-role state) 'client)
23 (stream-state-write! state outgoing #t))
24 (stream-state-input! state (sequence-test-data (stream-state-id state) incoming #t))
25 (stream-state-read! state)
26 (when (eq? (stream-state-role state) 'server)
27 (stream-state-write! state outgoing #t)))
29(define (sequence-test-error code operation)
30 (let ((caught (guard (exn (else exn)) (operation) #f)))
31 (assert-true (quic-error? caught))
32 (assert-equal code (quic-error-code caught))))
34(define (sequence-test-control expected actual)
35 (assert-equal
36 (if (equal? (getenv "QUIC_SEQUENCE_RED") "1") (flip-byte expected 0) expected)
37 actual))
39(test-group "QUIC bounded sequential stream state"
40 (test "sequence-control: retiring receive final size replenishes cumulative connection credit"
41 (let ((state (sequence-test-state 'server 4 3)))
42 (sequence-test-finish! state #u8(1 2 3) #u8(7))
43 (sequence-test-control #u8(16 7 18 2)
44 (encode-frames (stream-state-advance! state) 'application 'server))
45 (assert-equal 4 (stream-state-id state))))
46 (test "sequence-control: successor uses stream four with fresh byte offset zero"
47 (let ((state (sequence-test-state 'client 8 3)))
48 (sequence-test-finish! state #u8(9) #u8(1 2))
49 (stream-state-advance! state)
50 (sequence-test-control #u8(15 4 0 2 3 4)
51 (encode-frame (stream-state-write! state #u8(3 4) #t)))))
52 (test "default one-stream budget never grants a successor"
53 (let ((state (make-stream-state 'server receive-window: 4)))
54 (stream-state-set-peer! state 4 4 1)
55 (sequence-test-finish! state #u8(1) #u8(2))
56 (assert-false (stream-state-advance! state))
57 (assert-equal 0 (stream-state-id state))))
58 (test "advancement needs received EOF fully consumed and local FIN"
59 (let ((state (sequence-test-state 'server 8 3)))
60 (stream-state-input! state (sequence-test-data 0 #u8(1 2) #t))
61 (assert-false (stream-state-advance! state))
62 (stream-state-write! state #u8() #t)
63 (assert-false (stream-state-advance! state))
64 (stream-state-read! state maximum: 1)
65 (assert-false (stream-state-advance! state))
66 (stream-state-read! state)
67 (assert-true (pair? (stream-state-advance! state)))
68 (assert-false (stream-state-advance! state))))
69 (test "successors cannot reuse the previous stream's consumed send credit"
70 (let ((state (sequence-test-state 'client 8 3)))
71 (sequence-test-finish! state #u8() #u8(1 2 3 4 5 6))
72 (stream-state-advance! state)
73 (assert-equal 2 (stream-state-available state))
74 (assert-false (stream-state-write! state #u8(7 8 9) #t))
75 (stream-state-input! state (make-quic-frame 16 (list (cons 'maximum 10))))
76 (assert-equal 4 (stream-state-available state))))
77 (test "successor resets stream-specific credit to the authenticated initial value"
78 (let ((state (sequence-test-state 'client 8 3)))
79 (stream-state-write! state #u8() #f)
80 (stream-state-input! state (make-quic-frame 17 (list (cons 'stream-id 0) (cons 'maximum 20))))
81 (stream-state-input! state (make-quic-frame 16 (list (cons 'maximum 40))))
82 (sequence-test-finish! state #u8() #u8())
83 (stream-state-advance! state)
84 (assert-equal 8 (stream-state-available state))))
85 (test "successor local opening waits for the peer's absolute MAX_STREAMS grant"
86 (let ((state (make-stream-state 'client receive-window: 4 maximum-streams: 3)))
87 (stream-state-set-peer! state 8 4 1)
88 (sequence-test-finish! state #u8() #u8())
89 (stream-state-advance! state)
90 (assert-false (stream-state-write! state #u8() #t))
91 (stream-state-input! state (make-quic-frame 18 (list (cons 'maximum 2))))
92 (assert-true (quic-frame? (stream-state-write! state #u8() #t)))))
93 (test "retired replay cannot open the successor or deliver duplicate bytes"
94 (let ((state (sequence-test-state 'server 8 3)))
95 (sequence-test-finish! state #u8(1 2 3) #u8())
96 (stream-state-advance! state)
97 (stream-state-input! state (sequence-test-data 0 #u8(1 2 3) #t))
98 (assert-equal #u8() (stream-state-read! state))
99 (assert-false (stream-state-opened? state))
100 (assert-false (stream-state-write! state #u8(4) #f))
101 (stream-state-input! state (sequence-test-data 4 #u8(5) #t))
102 (assert-equal #u8(5) (stream-state-read! state))))
103 (test "retired STREAM and RESET still enforce immutable final size"
104 (let ((state (sequence-test-state 'server 8 3)))
105 (sequence-test-finish! state #u8(1 2 3) #u8())
106 (stream-state-advance! state)
107 (sequence-test-error 6 (lambda () (stream-state-input! state (sequence-test-data 0 #u8(1 2) #t))))
108 (sequence-test-error 6 (lambda () (stream-state-input! state (sequence-test-data 0 #u8(1 2 3 4)))))
109 (sequence-test-error 6 (lambda () (stream-state-input! state
110 (make-quic-frame 4 (list (cons 'stream-id 0) (cons 'error 0) (cons 'final-size 4))))))
111 (assert-equal '() (stream-state-input! state
112 (make-quic-frame 4 (list (cons 'stream-id 0) (cons 'error 0) (cons 'final-size 3)))))))
113 (test "retired STOP and stream credit cannot reset or enlarge the successor"
114 (let ((state (sequence-test-state 'client 8 3)))
115 (sequence-test-finish! state #u8() #u8())
116 (stream-state-advance! state)
117 (stream-state-input! state (make-quic-frame 5 (list (cons 'stream-id 0) (cons 'error 42))))
118 (stream-state-input! state (make-quic-frame 17 (list (cons 'stream-id 0) (cons 'maximum 99))))
119 (assert-false (stream-state-send-closed? state))
120 (assert-false (stream-state-take-cancel! state))
121 (assert-equal 8 (stream-state-available state))))
122 (test "future peer streams stay forbidden until the old stream is retired"
123 (let ((state (sequence-test-state 'server 8 3)))
124 (sequence-test-error 4 (lambda () (stream-state-input! state (sequence-test-data 4 #u8()))))
125 (sequence-test-finish! state #u8() #u8())
126 (stream-state-advance! state)
127 (sequence-test-error 4 (lambda () (stream-state-input! state (sequence-test-data 8 #u8()))))))
128 (test "three sequential streams stop at stream eight with bounded tombstones"
129 (let ((state (sequence-test-state 'server 8 3)))
130 (sequence-test-finish! state #u8(1 2 3) #u8())
131 (stream-state-advance! state)
132 (sequence-test-finish! state #u8(4 5) #u8())
133 (let ((credits (stream-state-advance! state)))
134 (assert-equal 13 (frame-ref (car credits) 'maximum))
135 (assert-equal 3 (frame-ref (cadr credits) 'maximum)))
136 (sequence-test-finish! state #u8(6) #u8())
137 (assert-false (stream-state-advance! state))
138 (assert-equal 8 (stream-state-id state))
139 (sequence-test-error 6 (lambda () (stream-state-input! state (sequence-test-data 0 #u8() #t))))
140 (sequence-test-error 6 (lambda () (stream-state-input! state (sequence-test-data 4 #u8() #t))))))
141 (test "new stream sliding credit includes retired final sizes"
142 (let ((state (sequence-test-state 'server 4 3)))
143 (sequence-test-finish! state #u8(1 2 3) #u8())
144 (stream-state-advance! state)
145 (stream-state-input! state (sequence-test-data 4 #u8(4 5)))
146 (assert-equal #u8(4 5) (stream-state-read! state))
147 (let ((credits (stream-state-credit-frames! state)))
148 (assert-equal 9 (frame-ref (car credits) 'maximum))
149 (assert-equal 6 (frame-ref (cadr credits) 'maximum))
150 (assert-equal 4 (frame-ref (cadr credits) 'stream-id)))
151 (sequence-test-error 3 (lambda () (stream-state-input! state (sequence-test-data 4 (make-bytevector 7 0)))))))
152 (test "reset stream cannot advance and constructor bounds stream count"
153 (let ((state (sequence-test-state 'server 8 3)))
154 (stream-state-input! state (sequence-test-data 0 #u8(1) #t))
155 (stream-state-read! state)
156 (stream-state-reset! state 0)
157 (assert-false (stream-state-advance! state)))
158 (assert-error (make-stream-state 'server maximum-streams: 0))
159 (assert-error (make-stream-state 'server maximum-streams: 17))))
161(define (sequence-test-pair window maximum)
162 (let* ((key (ecdsa-p256-generate-keypair)) (original #u8(1 2 3 4 5 6 7 8))
163 (client-id #u8(11 12 13 14 15 16 17 18))
164 (client (make-quic-client (list #u8(113 49)) "example.test"
165 (stream-transport-parameters 'client receive-window: window)
166 (lambda (certificates name)
167 (and (equal? certificates (list #u8(48 1 0))) (cdr key)))
168 local-id: client-id destination-id: original))
169 (server (make-quic-server (list #u8(113 49))
170 (stream-transport-parameters 'server receive-window: window)
171 (list #u8(48 1 0)) (car key) original client-id))
172 (client-stream (make-quic-stream client maximum-streams: maximum))
173 (server-stream (make-quic-stream server maximum-streams: maximum)))
174 (quic-start! client 0)
175 (vector client server client-stream server-stream)))
177(define (sequence-test-deliver! pair side now)
178 (for-each (lambda (packet) (quic-receive! (vector-ref pair (- 1 side)) packet now))
179 (quic-take-datagrams! (vector-ref pair side) now)))
181(define (sequence-test-pump! pair now)
182 (do ((i 0 (+ i 1))) ((= i 6))
183 (sequence-test-deliver! pair 0 now)
184 (sequence-test-deliver! pair 1 now)))
186(define (sequence-test-exchange! pair request response)
187 (let ((client (vector-ref pair 2)) (server (vector-ref pair 3))
188 (sent 0) (received #u8()))
189 (do ((round 0 (+ round 1))) ((= round 20))
190 (unless (quic-stream-send-closed? client)
191 (set! sent (+ sent (quic-stream-write! client (bytevector-copy request sent) fin?: #t))))
192 (sequence-test-pump! pair 0)
193 (set! received (bytes-append received (quic-stream-read! server)))
194 (sequence-test-pump! pair 0))
195 (assert-equal request received)
196 (assert-true (quic-stream-eof? server))
197 (set! sent 0)
198 (set! received #u8())
199 (do ((round 0 (+ round 1))) ((= round 20))
200 (unless (quic-stream-send-closed? server)
201 (set! sent (+ sent (quic-stream-write! server (bytevector-copy response sent) fin?: #t))))
202 (sequence-test-pump! pair 0)
203 (set! received (bytes-append received (quic-stream-read! client)))
204 (sequence-test-pump! pair 0))
205 (assert-equal response received)
206 (assert-true (quic-stream-eof? client))
207 (assert-false (quic-stream-outstanding? (vector-ref pair 0) (quic-stream-id client)))
208 (assert-false (quic-stream-outstanding? (vector-ref pair 1) (quic-stream-id server)))))
210(test-group "QUIC protected sequential stream adapter"
211 (test "three bounded streams transfer beyond their windows over one handshake"
212 (let ((pair (sequence-test-pair 4 3)))
213 (sequence-test-pump! pair 0)
214 (for-each
215 (lambda (id)
216 (assert-equal id (quic-stream-id (vector-ref pair 2)))
217 (assert-equal id (quic-stream-id (vector-ref pair 3)))
218 (sequence-test-exchange! pair #u8(1 2 3 4 5 6) #u8(7 8 9 10 11 12 13))
219 (if (< id 8)
220 (begin
221 (assert-true (quic-stream-advance! (vector-ref pair 3)))
222 (assert-true (quic-stream-advance! (vector-ref pair 2)))
223 (sequence-test-pump! pair 0))
224 (begin
225 (assert-false (quic-stream-advance! (vector-ref pair 2)))
226 (assert-false (quic-stream-advance! (vector-ref pair 3))))))
227 '(0 4 8))
228 (assert-true (quic-confirmed? (vector-ref pair 0)))
229 (assert-true (quic-confirmed? (vector-ref pair 1)))
230 (assert-false (quic-failure (vector-ref pair 0)))
231 (assert-false (quic-failure (vector-ref pair 1)))))
232 (test "outgoing response FIN must be acknowledged before advancing"
233 (let ((pair (sequence-test-pair 8 3)))
234 (sequence-test-pump! pair 0)
235 (quic-stream-write! (vector-ref pair 2) #u8(1) fin?: #t)
236 (sequence-test-pump! pair 0)
237 (quic-stream-read! (vector-ref pair 3))
238 (quic-stream-write! (vector-ref pair 3) #u8(2) fin?: #t)
239 (assert-false (quic-stream-advance! (vector-ref pair 3)))
240 (sequence-test-deliver! pair 1 0)
241 (assert-equal #u8(2) (quic-stream-read! (vector-ref pair 2)))
242 (assert-false (quic-stream-advance! (vector-ref pair 3)))
243 (assert-equal 0 (quic-stream-id (vector-ref pair 3)))
244 (sequence-test-deliver! pair 0 0)
245 (assert-true (quic-stream-advance! (vector-ref pair 3)))
246 (assert-equal 4 (quic-stream-id (vector-ref pair 3)))))
247 (test "lost response FIN holds the stream until PTO delivery and ACK"
248 (let ((pair (sequence-test-pair 8 3)))
249 (sequence-test-pump! pair 0)
250 (quic-stream-write! (vector-ref pair 2) #u8(1) fin?: #t)
251 (sequence-test-pump! pair 0)
252 (quic-stream-read! (vector-ref pair 3))
253 (quic-stream-write! (vector-ref pair 3) #u8(2) fin?: #t)
254 (assert-true (pair? (quic-take-datagrams! (vector-ref pair 1) 0)))
255 (assert-false (quic-stream-advance! (vector-ref pair 3)))
256 (assert-false (quic-stream-advance! (vector-ref pair 2)))
257 (quic-tick! (vector-ref pair 1) 1000)
258 (sequence-test-deliver! pair 1 1000)
259 (assert-equal #u8(2) (quic-stream-read! (vector-ref pair 2)))
260 (assert-false (quic-stream-advance! (vector-ref pair 3)))
261 (sequence-test-pump! pair 1000)
262 (assert-true (quic-stream-advance! (vector-ref pair 3)))))
263 (test "client successor cannot send until server grants the next stream count"
264 (let ((pair (sequence-test-pair 8 3)))
265 (sequence-test-pump! pair 0)
266 (sequence-test-exchange! pair #u8(1) #u8(2))
267 (assert-true (quic-stream-advance! (vector-ref pair 2)))
268 (assert-equal 0 (quic-stream-write! (vector-ref pair 2) #u8(3) fin?: #t))
269 (assert-false (quic-stream-send-closed? (vector-ref pair 2)))
270 (assert-true (quic-stream-advance! (vector-ref pair 3)))
271 (sequence-test-pump! pair 0)
272 (assert-equal 1 (quic-stream-write! (vector-ref pair 2) #u8(3) fin?: #t))))
273 (test "successor STOP cancels its queued and lost data by its own stream ID"
274 (let ((pair (sequence-test-pair 2000 3)))
275 (sequence-test-pump! pair 0)
276 (sequence-test-exchange! pair #u8(1) #u8(2))
277 (quic-stream-advance! (vector-ref pair 2))
278 (quic-stream-advance! (vector-ref pair 3))
279 (sequence-test-pump! pair 0)
280 (quic-stream-write! (vector-ref pair 2) #u8(3))
281 (sequence-test-pump! pair 0)
282 (quic-stream-write! (vector-ref pair 2) (make-bytevector 900 4))
283 (assert-true (pair? (quic-take-datagrams! (vector-ref pair 0) 0)))
284 (quic-stream-write! (vector-ref pair 2) #u8(5))
285 (assert-true (quic-stream-outstanding? (vector-ref pair 0) 4))
286 (assert-true (quic-stream-stop! (vector-ref pair 3) 42))
287 (sequence-test-deliver! pair 1 0)
288 (assert-false (quic-stream-outstanding? (vector-ref pair 0) 4))
289 (sequence-test-pump! pair 0)
290 (assert-equal 42 (quic-stream-reset-code (vector-ref pair 3)))
291 (assert-false (quic-stream-advance! (vector-ref pair 2)))
292 (quic-tick! (vector-ref pair 0) 1000)
293 (sequence-test-pump! pair 1000)
294 (assert-false (quic-stream-outstanding? (vector-ref pair 0) 4))
295 (assert-false (quic-failure (vector-ref pair 0)))))
296 (test "authenticated retired final-size violation closes the successor connection"
297 (let ((pair (sequence-test-pair 8 3)))
298 (sequence-test-pump! pair 0)
299 (sequence-test-exchange! pair #u8(1) #u8(2))
300 (quic-stream-advance! (vector-ref pair 3))
301 (quic-send-frame! (vector-ref pair 0) (sequence-test-data 0 #u8(1 9) #t))
302 (sequence-test-deliver! pair 0 0)
303 (assert-true (quic-closed? (vector-ref pair 1)))
304 (assert-equal 6 (quic-error-code (quic-failure (vector-ref pair 1))))
305 (assert-error (quic-stream-advance! (vector-ref pair 3))))))