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-equal36
(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! state110
(make-quic-frame 4 (list (cons 'stream-id 0) (cons 'error 0) (cons 'final-size 4))))))111
(assert-equal '() (stream-state-input! state112
(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-each215
(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
(begin221
(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
(begin225
(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))))))