Debian Codegraph @

third_party/rust/neqo-http3/src/features/extended_connect/tests/webtransport/streams.rs

raw
1 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
2 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
3 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
4 // option. This file may not be copied, modified, or distributed
5 // except according to those terms.
6
7 use neqo_transport::StreamType;
8
9 use crate::{
10 features::extended_connect::{tests::webtransport::WtTest, SessionCloseReason},
11 Error,
12 };
13
14 #[test]
15 fn wt_client_stream_uni() {
16 const BUF_CLIENT: &[u8] = &[0; 10];
17
18 let mut wt = WtTest::new();
19 let wt_session = wt.create_wt_session();
20 let wt_stream = wt.create_wt_stream_client(wt_session.stream_id(), StreamType::UniDi);
21 let send_stats = wt.send_stream_stats(wt_stream).unwrap();
22 assert_eq!(send_stats.bytes_written(), 0);
23 assert_eq!(send_stats.bytes_sent(), 0);
24 assert_eq!(send_stats.bytes_acked(), 0);
25
26 wt.send_data_client(wt_stream, BUF_CLIENT);
27 wt.receive_data_server(wt_stream, true, BUF_CLIENT, false);
28 let send_stats = wt.send_stream_stats(wt_stream).unwrap();
29 assert_eq!(send_stats.bytes_written(), BUF_CLIENT.len() as u64);
30 assert_eq!(send_stats.bytes_sent(), BUF_CLIENT.len() as u64);
31 assert_eq!(send_stats.bytes_acked(), BUF_CLIENT.len() as u64);
32
33 // Send data again to test if the stats has the expected values.
34 wt.send_data_client(wt_stream, BUF_CLIENT);
35 wt.receive_data_server(wt_stream, false, BUF_CLIENT, false);
36 let send_stats = wt.send_stream_stats(wt_stream).unwrap();
37 assert_eq!(send_stats.bytes_written(), (BUF_CLIENT.len() * 2) as u64);
38 assert_eq!(send_stats.bytes_sent(), (BUF_CLIENT.len() * 2) as u64);
39 assert_eq!(send_stats.bytes_acked(), (BUF_CLIENT.len() * 2) as u64);
40
41 let recv_stats = wt.recv_stream_stats(wt_stream);
42 assert_eq!(recv_stats.unwrap_err(), Error::InvalidStreamId);
43 }
44
45 #[test]
46 fn wt_client_stream_bidi() {
47 const BUF_CLIENT: &[u8] = &[0; 10];
48 const BUF_SERVER: &[u8] = &[1; 20];
49
50 let mut wt = WtTest::new();
51 let wt_session = wt.create_wt_session();
52 let wt_client_stream = wt.create_wt_stream_client(wt_session.stream_id(), StreamType::BiDi);
53 wt.send_data_client(wt_client_stream, BUF_CLIENT);
54 let wt_server_stream = wt.receive_data_server(wt_client_stream, true, BUF_CLIENT, false);
55 wt.send_data_server(&wt_server_stream, BUF_SERVER);
56 wt.receive_data_client(wt_client_stream, false, BUF_SERVER, false);
57 let send_stats = wt.send_stream_stats(wt_client_stream).unwrap();
58 assert_eq!(send_stats.bytes_written(), BUF_CLIENT.len() as u64);
59 assert_eq!(send_stats.bytes_sent(), BUF_CLIENT.len() as u64);
60 assert_eq!(send_stats.bytes_acked(), BUF_CLIENT.len() as u64);
61
62 let recv_stats = wt.recv_stream_stats(wt_client_stream).unwrap();
63 assert_eq!(recv_stats.bytes_received(), BUF_SERVER.len() as u64);
64 assert_eq!(recv_stats.bytes_read(), BUF_SERVER.len() as u64);
65 }
66
67 #[test]
68 fn wt_server_stream_uni() {
69 const BUF_SERVER: &[u8] = &[2; 30];
70
71 let mut wt = WtTest::new();
72 let wt_session = wt.create_wt_session();
73 let wt_server_stream = WtTest::create_wt_stream_server(&wt_session, StreamType::UniDi);
74 wt.send_data_server(&wt_server_stream, BUF_SERVER);
75 wt.receive_data_client(wt_server_stream.stream_id(), true, BUF_SERVER, false);
76 let send_stats = wt.send_stream_stats(wt_server_stream.stream_id());
77 assert_eq!(send_stats.unwrap_err(), Error::InvalidStreamId);
78
79 let recv_stats = wt.recv_stream_stats(wt_server_stream.stream_id()).unwrap();
80 assert_eq!(recv_stats.bytes_received(), BUF_SERVER.len() as u64);
81 assert_eq!(recv_stats.bytes_read(), BUF_SERVER.len() as u64);
82 }
83
84 #[test]
85 fn wt_server_stream_bidi() {
86 const BUF_CLIENT: &[u8] = &[0; 10];
87 const BUF_SERVER: &[u8] = &[1; 20];
88
89 let mut wt = WtTest::new();
90 let wt_session = wt.create_wt_session();
91 let wt_server_stream = WtTest::create_wt_stream_server(&wt_session, StreamType::BiDi);
92 wt.send_data_server(&wt_server_stream, BUF_SERVER);
93 wt.receive_data_client(wt_server_stream.stream_id(), true, BUF_SERVER, false);
94 wt.send_data_client(wt_server_stream.stream_id(), BUF_CLIENT);
95 drop(wt.receive_data_server(wt_server_stream.stream_id(), false, BUF_CLIENT, false));
96 let stats = wt.send_stream_stats(wt_server_stream.stream_id()).unwrap();
97 assert_eq!(stats.bytes_written(), BUF_CLIENT.len() as u64);
98 assert_eq!(stats.bytes_sent(), BUF_CLIENT.len() as u64);
99 assert_eq!(stats.bytes_acked(), BUF_CLIENT.len() as u64);
100
101 let recv_stats = wt.recv_stream_stats(wt_server_stream.stream_id()).unwrap();
102 assert_eq!(recv_stats.bytes_received(), BUF_SERVER.len() as u64);
103 assert_eq!(recv_stats.bytes_read(), BUF_SERVER.len() as u64);
104 }
105
106 #[test]
107 fn wt_client_stream_uni_close() {
108 const BUF_CLIENT: &[u8] = &[0; 10];
109
110 let mut wt = WtTest::new();
111 let wt_session = wt.create_wt_session();
112 let wt_stream = wt.create_wt_stream_client(wt_session.stream_id(), StreamType::UniDi);
113 wt.send_data_client(wt_stream, BUF_CLIENT);
114 wt.close_stream_sending_client(wt_stream);
115 wt.receive_data_server(wt_stream, true, BUF_CLIENT, true);
116 }
117
118 #[test]
119 fn wt_client_stream_bidi_close() {
120 const BUF_CLIENT: &[u8] = &[0; 10];
121 const BUF_SERVER: &[u8] = &[1; 20];
122
123 let mut wt = WtTest::new();
124 let wt_session = wt.create_wt_session();
125 let wt_client_stream = wt.create_wt_stream_client(wt_session.stream_id(), StreamType::BiDi);
126
127 wt.send_data_client(wt_client_stream, BUF_CLIENT);
128 wt.close_stream_sending_client(wt_client_stream);
129
130 let wt_server_stream = wt.receive_data_server(wt_client_stream, true, BUF_CLIENT, true);
131
132 wt.send_data_server(&wt_server_stream, BUF_SERVER);
133 wt.close_stream_sending_server(&wt_server_stream);
134 wt.receive_data_client(wt_client_stream, false, BUF_SERVER, true);
135 }
136
137 #[test]
138 fn wt_server_stream_uni_closed() {
139 const BUF_SERVER: &[u8] = &[2; 30];
140
141 let mut wt = WtTest::new();
142 let wt_session = wt.create_wt_session();
143 let wt_server_stream = WtTest::create_wt_stream_server(&wt_session, StreamType::UniDi);
144 wt.send_data_server(&wt_server_stream, BUF_SERVER);
145 wt.close_stream_sending_server(&wt_server_stream);
146 wt.receive_data_client(wt_server_stream.stream_id(), true, BUF_SERVER, true);
147 }
148
149 #[test]
150 fn wt_server_stream_bidi_close() {
151 const BUF_CLIENT: &[u8] = &[0; 10];
152 const BUF_SERVER: &[u8] = &[1; 20];
153
154 let mut wt = WtTest::new();
155 let wt_session = wt.create_wt_session();
156 let wt_server_stream = WtTest::create_wt_stream_server(&wt_session, StreamType::BiDi);
157 wt.send_data_server(&wt_server_stream, BUF_SERVER);
158 wt.close_stream_sending_server(&wt_server_stream);
159 wt.receive_data_client(wt_server_stream.stream_id(), true, BUF_SERVER, true);
160 wt.send_data_client(wt_server_stream.stream_id(), BUF_CLIENT);
161 wt.close_stream_sending_client(wt_server_stream.stream_id());
162 drop(wt.receive_data_server(wt_server_stream.stream_id(), false, BUF_CLIENT, true));
163 }
164
165 #[test]
166 fn wt_client_stream_uni_reset() {
167 const BUF_CLIENT: &[u8] = &[0; 10];
168
169 let mut wt = WtTest::new();
170 let wt_session = wt.create_wt_session();
171 let wt_stream = wt.create_wt_stream_client(wt_session.stream_id(), StreamType::UniDi);
172 wt.send_data_client(wt_stream, BUF_CLIENT);
173 drop(wt.receive_data_server(wt_stream, true, BUF_CLIENT, false));
174 wt.reset_stream_client(wt_stream);
175 wt.receive_reset_server(wt_stream, Error::HttpNoError.code());
176 }
177
178 #[test]
179 fn wt_server_stream_uni_reset() {
180 const BUF_SERVER: &[u8] = &[2; 30];
181
182 let mut wt = WtTest::new();
183 let wt_session = wt.create_wt_session();
184 let wt_server_stream = WtTest::create_wt_stream_server(&wt_session, StreamType::UniDi);
185 wt.send_data_server(&wt_server_stream, BUF_SERVER);
186 wt.receive_data_client(wt_server_stream.stream_id(), true, BUF_SERVER, false);
187 wt.reset_stream_server(&wt_server_stream);
188 wt.receive_reset_client(wt_server_stream.stream_id());
189 }
190
191 #[test]
192 fn wt_client_stream_bidi_reset() {
193 const BUF_CLIENT: &[u8] = &[0; 10];
194
195 let mut wt = WtTest::new();
196 let wt_session = wt.create_wt_session();
197 let wt_client_stream = wt.create_wt_stream_client(wt_session.stream_id(), StreamType::BiDi);
198
199 wt.send_data_client(wt_client_stream, BUF_CLIENT);
200 let wt_server_stream = wt.receive_data_server(wt_client_stream, true, BUF_CLIENT, false);
201
202 wt.reset_stream_client(wt_client_stream);
203 wt.receive_reset_server(wt_server_stream.stream_id(), Error::HttpNoError.code());
204
205 wt.reset_stream_server(&wt_server_stream);
206 wt.receive_reset_client(wt_client_stream);
207 }
208
209 #[test]
210 fn wt_server_stream_bidi_reset() {
211 const BUF_SERVER: &[u8] = &[1; 20];
212
213 let mut wt = WtTest::new();
214 let wt_session = wt.create_wt_session();
215 let wt_server_stream = WtTest::create_wt_stream_server(&wt_session, StreamType::BiDi);
216 wt.send_data_server(&wt_server_stream, BUF_SERVER);
217 wt.receive_data_client(wt_server_stream.stream_id(), true, BUF_SERVER, false);
218
219 wt.reset_stream_client(wt_server_stream.stream_id());
220 wt.receive_reset_server(wt_server_stream.stream_id(), Error::HttpNoError.code());
221
222 wt.reset_stream_server(&wt_server_stream);
223 wt.receive_reset_client(wt_server_stream.stream_id());
224 }
225
226 #[test]
227 fn wt_client_stream_uni_stop_sending() {
228 const BUF_CLIENT: &[u8] = &[0; 10];
229
230 let mut wt = WtTest::new();
231 let wt_session = wt.create_wt_session();
232 let wt_stream = wt.create_wt_stream_client(wt_session.stream_id(), StreamType::UniDi);
233 wt.send_data_client(wt_stream, BUF_CLIENT);
234 let wt_server_stream = wt.receive_data_server(wt_stream, true, BUF_CLIENT, false);
235 wt.stream_stop_sending_server(&wt_server_stream);
236 wt.receive_stop_sending_client(wt_stream);
237 }
238
239 #[test]
240 fn wt_server_stream_uni_stop_sending() {
241 const BUF_SERVER: &[u8] = &[2; 30];
242
243 let mut wt = WtTest::new();
244 let wt_session = wt.create_wt_session();
245 let wt_server_stream = WtTest::create_wt_stream_server(&wt_session, StreamType::UniDi);
246 wt.send_data_server(&wt_server_stream, BUF_SERVER);
247 wt.receive_data_client(wt_server_stream.stream_id(), true, BUF_SERVER, false);
248 wt.stream_stop_sending_client(wt_server_stream.stream_id());
249 wt.receive_stop_sending_server(wt_server_stream.stream_id(), Error::HttpNoError.code());
250 }
251
252 #[test]
253 fn wt_client_stream_bidi_stop_sending() {
254 const BUF_CLIENT: &[u8] = &[0; 10];
255
256 let mut wt = WtTest::new();
257 let wt_session = wt.create_wt_session();
258
259 let wt_client_stream = wt.create_wt_stream_client(wt_session.stream_id(), StreamType::BiDi);
260
261 wt.send_data_client(wt_client_stream, BUF_CLIENT);
262
263 let wt_server_stream = wt.receive_data_server(wt_client_stream, true, BUF_CLIENT, false);
264
265 wt.stream_stop_sending_client(wt_client_stream);
266
267 wt.receive_stop_sending_server(wt_server_stream.stream_id(), Error::HttpNoError.code());
268 wt.stream_stop_sending_server(&wt_server_stream);
269 wt.receive_stop_sending_client(wt_server_stream.stream_id());
270 }
271
272 #[test]
273 fn wt_server_stream_bidi_stop_sending() {
274 const BUF_SERVER: &[u8] = &[1; 20];
275
276 let mut wt = WtTest::new();
277 let wt_session = wt.create_wt_session();
278 let wt_server_stream = WtTest::create_wt_stream_server(&wt_session, StreamType::BiDi);
279
280 wt.send_data_server(&wt_server_stream, BUF_SERVER);
281 wt.receive_data_client(wt_server_stream.stream_id(), true, BUF_SERVER, false);
282 wt.stream_stop_sending_client(wt_server_stream.stream_id());
283 wt.receive_stop_sending_server(wt_server_stream.stream_id(), Error::HttpNoError.code());
284 wt.stream_stop_sending_server(&wt_server_stream);
285 wt.receive_stop_sending_client(wt_server_stream.stream_id());
286 }
287
288 // For the following tests the client cancels a session. The streams are in different states:
289 // 1) Both sides of a bidirectional client stream are opened.
290 // 2) A client unidirectional stream is opened.
291 // 3) A client unidirectional stream has been closed and both sides consumed the closing info.
292 // 4) A client unidirectional stream has been closed, but only the server has consumed the closing
293 // info.
294 // 5) A client unidirectional stream has been closed, but only the client has consum the closing
295 // info.
296 // 6) Both sides of a bidirectional server stream are opened.
297 // 7) A server unidirectional stream is opened.
298 // 8) A server unidirectional stream has been closed and both sides consumed the closing info.
299 // 9) A server unidirectional stream has been closed, but only the server has consumed the closing
300 // info.
301 // 10) A server unidirectional stream has been closed, but only the client has consumed the closing
302 // info.
303 // 11) Both sides of a bidirectional stream have been closed and consumed by both sides.
304 // 12) Both sides of a bidirectional stream have been closed, but not consumed by both sides.
305 // 13) Multiples open streams
306
307 #[test]
308 fn wt_client_session_close_1() {
309 const BUF: &[u8] = &[0; 10];
310
311 let mut wt = WtTest::new();
312 let wt_session = wt.create_wt_session();
313
314 let bidi_from_client = wt.create_wt_stream_client(wt_session.stream_id(), StreamType::BiDi);
315 wt.send_data_client(bidi_from_client, BUF);
316 drop(wt.receive_data_server(bidi_from_client, true, BUF, false));
317
318 wt.cancel_session_client(wt_session.stream_id());
319
320 wt.check_events_after_closing_session_server(
321 &[bidi_from_client],
322 Some(Error::HttpRequestCancelled.code()),
323 &[bidi_from_client],
324 Some(Error::HttpRequestCancelled.code()),
325 Some(&(
326 wt_session.stream_id(),
327 SessionCloseReason::Error(Error::HttpNoError.code()),
328 )),
329 );
330
331 wt.check_events_after_closing_session_client(
332 &[bidi_from_client],
333 Some(Error::HttpRequestCancelled.code()),
334 &[bidi_from_client],
335 Some(Error::HttpRequestCancelled.code()),
336 false,
337 None,
338 );
339 }
340
341 #[test]
342 fn wt_client_session_close_2() {
343 const BUF: &[u8] = &[0; 10];
344
345 let mut wt = WtTest::new();
346 let wt_session = wt.create_wt_session();
347
348 let unidi_from_client = wt.create_wt_stream_client(wt_session.stream_id(), StreamType::UniDi);
349
350 wt.send_data_client(unidi_from_client, BUF);
351 drop(wt.receive_data_server(unidi_from_client, true, BUF, false));
352
353 wt.cancel_session_client(wt_session.stream_id());
354
355 wt.check_events_after_closing_session_server(
356 &[unidi_from_client],
357 Some(Error::HttpRequestCancelled.code()),
358 &[],
359 None,
360 Some(&(
361 wt_session.stream_id(),
362 SessionCloseReason::Error(Error::HttpNoError.code()),
363 )),
364 );
365
366 wt.check_events_after_closing_session_client(
367 &[],
368 None,
369 &[unidi_from_client],
370 Some(Error::HttpRequestCancelled.code()),
371 false,
372 None,
373 );
374 }
375
376 #[test]
377 fn wt_client_session_close_3() {
378 const BUF: &[u8] = &[0; 10];
379
380 let mut wt = WtTest::new();
381 let wt_session = wt.create_wt_session();
382
383 let unidi_from_client = wt.create_wt_stream_client(wt_session.stream_id(), StreamType::UniDi);
384
385 wt.send_data_client(unidi_from_client, BUF);
386 drop(wt.receive_data_server(unidi_from_client, true, BUF, false));
387 wt.close_stream_sending_client(unidi_from_client);
388
389 wt.cancel_session_client(wt_session.stream_id());
390
391 wt.check_events_after_closing_session_server(
392 &[],
393 None,
394 &[],
395 None,
396 Some(&(
397 wt_session.stream_id(),
398 SessionCloseReason::Error(Error::HttpNoError.code()),
399 )),
400 );
401
402 wt.check_events_after_closing_session_client(&[], None, &[], None, false, None);
403 }
404
405 #[test]
406 fn wt_client_session_close_4() {
407 const BUF: &[u8] = &[0; 10];
408
409 let mut wt = WtTest::new();
410 let wt_session = wt.create_wt_session();
411
412 let unidi_from_client = wt.create_wt_stream_client(wt_session.stream_id(), StreamType::UniDi);
413
414 wt.send_data_client(unidi_from_client, BUF);
415 let unidi_from_client_s = wt.receive_data_server(unidi_from_client, true, BUF, false);
416 wt.stream_stop_sending_server(&unidi_from_client_s);
417
418 wt.cancel_session_client(wt_session.stream_id());
419
420 wt.check_events_after_closing_session_server(
421 &[],
422 None,
423 &[],
424 None,
425 Some(&(
426 wt_session.stream_id(),
427 SessionCloseReason::Error(Error::HttpNoError.code()),
428 )),
429 );
430
431 wt.check_events_after_closing_session_client(
432 &[],
433 None,
434 &[unidi_from_client],
435 Some(Error::HttpNoError.code()),
436 false,
437 None,
438 );
439 }
440
441 #[test]
442 fn wt_client_session_close_5() {
443 const BUF: &[u8] = &[0; 10];
444
445 let mut wt = WtTest::new();
446 let wt_session = wt.create_wt_session();
447
448 let unidi_from_client = wt.create_wt_stream_client(wt_session.stream_id(), StreamType::UniDi);
449
450 wt.send_data_client(unidi_from_client, BUF);
451 drop(wt.receive_data_server(unidi_from_client, true, BUF, false));
452 wt.reset_stream_client(unidi_from_client);
453
454 wt.cancel_session_client(wt_session.stream_id());
455
456 wt.check_events_after_closing_session_server(
457 &[unidi_from_client],
458 Some(Error::HttpNoError.code()),
459 &[],
460 None,
461 Some(&(
462 wt_session.stream_id(),
463 SessionCloseReason::Error(Error::HttpNoError.code()),
464 )),
465 );
466
467 wt.check_events_after_closing_session_client(&[], None, &[], None, false, None);
468 }
469
470 #[test]
471 fn wt_client_session_close_6() {
472 const BUF: &[u8] = &[0; 10];
473
474 let mut wt = WtTest::new();
475 let wt_session = wt.create_wt_session();
476
477 let bidi_from_server = WtTest::create_wt_stream_server(&wt_session, StreamType::BiDi);
478 wt.send_data_server(&bidi_from_server, BUF);
479 wt.receive_data_client(bidi_from_server.stream_id(), true, BUF, false);
480
481 wt.cancel_session_client(wt_session.stream_id());
482
483 wt.check_events_after_closing_session_server(
484 &[bidi_from_server.stream_id()],
485 Some(Error::HttpRequestCancelled.code()),
486 &[bidi_from_server.stream_id()],
487 Some(Error::HttpRequestCancelled.code()),
488 Some(&(
489 wt_session.stream_id(),
490 SessionCloseReason::Error(Error::HttpNoError.code()),
491 )),
492 );
493
494 wt.check_events_after_closing_session_client(
495 &[bidi_from_server.stream_id()],
496 Some(Error::HttpRequestCancelled.code()),
497 &[bidi_from_server.stream_id()],
498 Some(Error::HttpRequestCancelled.code()),
499 false,
500 None,
501 );
502 }
503
504 #[test]
505 fn wt_client_session_close_7() {
506 const BUF: &[u8] = &[0; 10];
507
508 let mut wt = WtTest::new();
509 let wt_session = wt.create_wt_session();
510
511 let unidi_from_server = WtTest::create_wt_stream_server(&wt_session, StreamType::UniDi);
512 wt.send_data_server(&unidi_from_server, BUF);
513 wt.receive_data_client(unidi_from_server.stream_id(), true, BUF, false);
514
515 wt.cancel_session_client(wt_session.stream_id());
516
517 wt.check_events_after_closing_session_server(
518 &[],
519 None,
520 &[unidi_from_server.stream_id()],
521 Some(Error::HttpRequestCancelled.code()),
522 Some(&(
523 wt_session.stream_id(),
524 SessionCloseReason::Error(Error::HttpNoError.code()),
525 )),
526 );
527
528 wt.check_events_after_closing_session_client(
529 &[unidi_from_server.stream_id()],
530 Some(Error::HttpRequestCancelled.code()),
531 &[],
532 None,
533 false,
534 None,
535 );
536 }
537
538 #[test]
539 fn wt_client_session_close_8() {
540 const BUF: &[u8] = &[0; 10];
541
542 let mut wt = WtTest::new();
543 let wt_session = wt.create_wt_session();
544
545 let unidi_server = WtTest::create_wt_stream_server(&wt_session, StreamType::UniDi);
546 wt.send_data_server(&unidi_server, BUF);
547 wt.close_stream_sending_server(&unidi_server);
548 wt.receive_data_client(unidi_server.stream_id(), true, BUF, true);
549
550 wt.cancel_session_client(wt_session.stream_id());
551
552 wt.check_events_after_closing_session_server(
553 &[],
554 None,
555 &[],
556 None,
557 Some(&(
558 wt_session.stream_id(),
559 SessionCloseReason::Error(Error::HttpNoError.code()),
560 )),
561 );
562
563 wt.check_events_after_closing_session_client(&[], None, &[], None, false, None);
564 }
565
566 #[test]
567 fn wt_client_session_close_9() {
568 const BUF: &[u8] = &[0; 10];
569
570 let mut wt = WtTest::new();
571 let wt_session = wt.create_wt_session();
572
573 let unidi_server = WtTest::create_wt_stream_server(&wt_session, StreamType::UniDi);
574 wt.send_data_server(&unidi_server, BUF);
575 wt.stream_stop_sending_client(unidi_server.stream_id());
576
577 wt.cancel_session_client(wt_session.stream_id());
578
579 wt.check_events_after_closing_session_server(
580 &[],
581 None,
582 &[unidi_server.stream_id()],
583 Some(Error::HttpNoError.code()),
584 Some(&(
585 wt_session.stream_id(),
586 SessionCloseReason::Error(Error::HttpNoError.code()),
587 )),
588 );
589
590 wt.check_events_after_closing_session_client(&[], None, &[], None, false, None);
591 }
592
593 #[test]
594 fn wt_client_session_close_10() {
595 const BUF: &[u8] = &[0; 10];
596
597 let mut wt = WtTest::new();
598 let wt_session = wt.create_wt_session();
599
600 let unidi_server = WtTest::create_wt_stream_server(&wt_session, StreamType::UniDi);
601 wt.send_data_server(&unidi_server, BUF);
602 wt.close_stream_sending_server(&unidi_server);
603
604 wt.cancel_session_client(wt_session.stream_id());
605
606 wt.check_events_after_closing_session_server(
607 &[],
608 None,
609 &[],
610 None,
611 Some(&(
612 wt_session.stream_id(),
613 SessionCloseReason::Error(Error::HttpNoError.code()),
614 )),
615 );
616
617 wt.check_events_after_closing_session_client(
618 &[unidi_server.stream_id()],
619 Some(Error::HttpRequestCancelled.code()),
620 &[],
621 None,
622 false,
623 None,
624 );
625 }
626
627 #[test]
628 fn wt_client_session_close_11() {
629 const BUF: &[u8] = &[0; 10];
630
631 let mut wt = WtTest::new();
632 let wt_session = wt.create_wt_session();
633
634 let bidi_server = WtTest::create_wt_stream_server(&wt_session, StreamType::BiDi);
635 wt.send_data_server(&bidi_server, BUF);
636 wt.close_stream_sending_server(&bidi_server);
637 wt.receive_data_client(bidi_server.stream_id(), true, BUF, true);
638 wt.stream_stop_sending_server(&bidi_server);
639 wt.receive_stop_sending_client(bidi_server.stream_id());
640
641 wt.cancel_session_client(wt_session.stream_id());
642
643 wt.check_events_after_closing_session_server(
644 &[],
645 None,
646 &[],
647 None,
648 Some(&(
649 wt_session.stream_id(),
650 SessionCloseReason::Error(Error::HttpNoError.code()),
651 )),
652 );
653
654 wt.check_events_after_closing_session_client(&[], None, &[], None, false, None);
655 }
656
657 #[test]
658 fn wt_client_session_close_12() {
659 const BUF: &[u8] = &[0; 10];
660
661 let mut wt = WtTest::new();
662 let wt_session = wt.create_wt_session();
663
664 let bidi_server = WtTest::create_wt_stream_server(&wt_session, StreamType::BiDi);
665 wt.send_data_server(&bidi_server, BUF);
666 wt.close_stream_sending_server(&bidi_server);
667 wt.stream_stop_sending_server(&bidi_server);
668
669 wt.cancel_session_client(wt_session.stream_id());
670
671 wt.check_events_after_closing_session_server(
672 &[],
673 None,
674 &[],
675 None,
676 Some(&(
677 wt_session.stream_id(),
678 SessionCloseReason::Error(Error::HttpNoError.code()),
679 )),
680 );
681
682 wt.check_events_after_closing_session_client(
683 &[bidi_server.stream_id()],
684 Some(Error::HttpRequestCancelled.code()),
685 &[bidi_server.stream_id()],
686 Some(Error::HttpNoError.code()),
687 false,
688 None,
689 );
690 }
691
692 #[test]
693 fn wt_client_session_close_13() {
694 const BUF: &[u8] = &[0; 10];
695
696 let mut wt = WtTest::new();
697 let wt_session = wt.create_wt_session();
698
699 let bidi_client_1 = wt.create_wt_stream_client(wt_session.stream_id(), StreamType::BiDi);
700 wt.send_data_client(bidi_client_1, BUF);
701 drop(wt.receive_data_server(bidi_client_1, true, BUF, false));
702 let bidi_client_2 = wt.create_wt_stream_client(wt_session.stream_id(), StreamType::BiDi);
703 wt.send_data_client(bidi_client_2, BUF);
704 drop(wt.receive_data_server(bidi_client_2, true, BUF, false));
705
706 wt.cancel_session_client(wt_session.stream_id());
707
708 wt.check_events_after_closing_session_server(
709 &[bidi_client_1, bidi_client_2],
710 Some(Error::HttpRequestCancelled.code()),
711 &[bidi_client_1, bidi_client_2],
712 Some(Error::HttpRequestCancelled.code()),
713 Some(&(
714 wt_session.stream_id(),
715 SessionCloseReason::Error(Error::HttpNoError.code()),
716 )),
717 );
718
719 wt.check_events_after_closing_session_client(
720 &[bidi_client_1, bidi_client_2],
721 Some(Error::HttpRequestCancelled.code()),
722 &[bidi_client_1, bidi_client_2],
723 Some(Error::HttpRequestCancelled.code()),
724 false,
725 None,
726 );
727 }
728
729 // For the following tests the server cancels a session. The streams are in different states:
730 // 1) Both sides of a bidirectional client stream are opened.
731 // 2) A client unidirectional stream is opened.
732 // 3) A client unidirectional stream has been closed and consumed by both sides.
733 // 4) A client unidirectional stream has been closed, but not consumed by the client.
734 // 5) Both sides of a bidirectional server stream are opened.
735 // 6) A server unidirectional stream is opened.
736 // 7) A server unidirectional stream has been closed and consumed by both sides.
737 // 8) A server unidirectional stream has been closed, but not consumed by the client.
738 // 9) Both sides of a bidirectional stream have been closed and consumed by both sides.
739 // 10) Both sides of a bidirectional stream have been closed, but not consumed by the client.
740 // 12) Multiples open streams
741
742 #[test]
743 fn wt_client_session_server_close_1() {
744 const BUF: &[u8] = &[0; 10];
745
746 let mut wt = WtTest::new();
747 let wt_session = wt.create_wt_session();
748
749 let bidi_client = wt.create_wt_stream_client(wt_session.stream_id(), StreamType::BiDi);
750 wt.send_data_client(bidi_client, BUF);
751 drop(wt.receive_data_server(bidi_client, true, BUF, false));
752
753 wt.cancel_session_server(&wt_session);
754
755 wt.check_events_after_closing_session_client(
756 &[bidi_client],
757 Some(Error::HttpRequestCancelled.code()),
758 &[bidi_client],
759 Some(Error::HttpRequestCancelled.code()),
760 false,
761 Some(&(
762 wt_session.stream_id(),
763 SessionCloseReason::Error(Error::HttpNoError.code()),
764 )),
765 );
766
767 wt.check_events_after_closing_session_server(
768 &[bidi_client],
769 Some(Error::HttpRequestCancelled.code()),
770 &[bidi_client],
771 Some(Error::HttpRequestCancelled.code()),
772 None,
773 );
774 }
775
776 #[test]
777 fn wt_client_session_server_close_2() {
778 const BUF: &[u8] = &[0; 10];
779
780 let mut wt = WtTest::new();
781 let wt_session = wt.create_wt_session();
782
783 let unidi_client = wt.create_wt_stream_client(wt_session.stream_id(), StreamType::UniDi);
784 wt.send_data_client(unidi_client, BUF);
785 drop(wt.receive_data_server(unidi_client, true, BUF, false));
786
787 wt.cancel_session_server(&wt_session);
788
789 wt.check_events_after_closing_session_client(
790 &[],
791 None,
792 &[unidi_client],
793 Some(Error::HttpRequestCancelled.code()),
794 false,
795 Some(&(
796 wt_session.stream_id(),
797 SessionCloseReason::Error(Error::HttpNoError.code()),
798 )),
799 );
800
801 wt.check_events_after_closing_session_server(
802 &[unidi_client],
803 Some(Error::HttpRequestCancelled.code()),
804 &[],
805 None,
806 None,
807 );
808 }
809
810 #[test]
811 fn wt_client_session_server_close_3() {
812 const BUF: &[u8] = &[0; 10];
813
814 let mut wt = WtTest::new();
815 let wt_session = wt.create_wt_session();
816
817 let unidi_client = wt.create_wt_stream_client(wt_session.stream_id(), StreamType::UniDi);
818 wt.send_data_client(unidi_client, BUF);
819 let unidi_client_s = wt.receive_data_server(unidi_client, true, BUF, false);
820 wt.stream_stop_sending_server(&unidi_client_s);
821 wt.receive_stop_sending_client(unidi_client);
822
823 wt.cancel_session_server(&wt_session);
824
825 wt.check_events_after_closing_session_client(
826 &[],
827 None,
828 &[],
829 None,
830 false,
831 Some(&(
832 wt_session.stream_id(),
833 SessionCloseReason::Error(Error::HttpNoError.code()),
834 )),
835 );
836
837 wt.check_events_after_closing_session_server(&[], None, &[], None, None);
838 }
839
840 #[test]
841 fn wt_client_session_server_close_4() {
842 const BUF: &[u8] = &[0; 10];
843
844 let mut wt = WtTest::new();
845 let wt_session = wt.create_wt_session();
846
847 let unidi_client = wt.create_wt_stream_client(wt_session.stream_id(), StreamType::UniDi);
848 wt.send_data_client(unidi_client, BUF);
849 let unidi_client_s = wt.receive_data_server(unidi_client, true, BUF, false);
850 wt.stream_stop_sending_server(&unidi_client_s);
851
852 wt.cancel_session_server(&wt_session);
853
854 wt.check_events_after_closing_session_client(
855 &[],
856 None,
857 &[unidi_client],
858 Some(Error::HttpNoError.code()),
859 false,
860 Some(&(
861 wt_session.stream_id(),
862 SessionCloseReason::Error(Error::HttpNoError.code()),
863 )),
864 );
865
866 wt.check_events_after_closing_session_server(&[], None, &[], None, None);
867 }
868
869 #[test]
870 fn wt_client_session_server_close_5() {
871 const BUF: &[u8] = &[0; 10];
872
873 let mut wt = WtTest::new();
874 let wt_session = wt.create_wt_session();
875
876 let bidi_server = WtTest::create_wt_stream_server(&wt_session, StreamType::BiDi);
877 wt.send_data_server(&bidi_server, BUF);
878 wt.receive_data_client(bidi_server.stream_id(), true, BUF, false);
879
880 wt.cancel_session_server(&wt_session);
881
882 wt.check_events_after_closing_session_client(
883 &[bidi_server.stream_id()],
884 Some(Error::HttpRequestCancelled.code()),
885 &[bidi_server.stream_id()],
886 Some(Error::HttpRequestCancelled.code()),
887 false,
888 Some(&(
889 wt_session.stream_id(),
890 SessionCloseReason::Error(Error::HttpNoError.code()),
891 )),
892 );
893
894 wt.check_events_after_closing_session_server(
895 &[bidi_server.stream_id()],
896 Some(Error::HttpRequestCancelled.code()),
897 &[bidi_server.stream_id()],
898 Some(Error::HttpRequestCancelled.code()),
899 None,
900 );
901 }
902
903 #[test]
904 fn wt_client_session_server_close_6() {
905 const BUF: &[u8] = &[0; 10];
906
907 let mut wt = WtTest::new();
908 let wt_session = wt.create_wt_session();
909
910 let unidi_server = WtTest::create_wt_stream_server(&wt_session, StreamType::UniDi);
911 wt.send_data_server(&unidi_server, BUF);
912 wt.receive_data_client(unidi_server.stream_id(), true, BUF, false);
913
914 wt.cancel_session_server(&wt_session);
915
916 wt.check_events_after_closing_session_client(
917 &[unidi_server.stream_id()],
918 Some(Error::HttpRequestCancelled.code()),
919 &[],
920 None,
921 false,
922 Some(&(
923 wt_session.stream_id(),
924 SessionCloseReason::Error(Error::HttpNoError.code()),
925 )),
926 );
927 wt.check_events_after_closing_session_server(
928 &[],
929 None,
930 &[unidi_server.stream_id()],
931 Some(Error::HttpRequestCancelled.code()),
932 None,
933 );
934 }
935
936 #[test]
937 fn wt_client_session_server_close_7() {
938 const BUF: &[u8] = &[0; 10];
939
940 let mut wt = WtTest::new();
941 let wt_session = wt.create_wt_session();
942
943 let unidi_server = WtTest::create_wt_stream_server(&wt_session, StreamType::UniDi);
944 wt.send_data_server(&unidi_server, BUF);
945 wt.close_stream_sending_server(&unidi_server);
946 wt.receive_data_client(unidi_server.stream_id(), true, BUF, true);
947
948 wt.cancel_session_server(&wt_session);
949
950 // Already close stream will not have a reset event.
951 wt.check_events_after_closing_session_client(
952 &[],
953 None,
954 &[],
955 None,
956 false,
957 Some(&(
958 wt_session.stream_id(),
959 SessionCloseReason::Error(Error::HttpNoError.code()),
960 )),
961 );
962
963 wt.check_events_after_closing_session_server(&[], None, &[], None, None);
964 }
965
966 #[test]
967 fn wt_client_session_server_close_8() {
968 const BUF: &[u8] = &[0; 10];
969
970 let mut wt = WtTest::new();
971 let wt_session = wt.create_wt_session();
972
973 let unidi_server = WtTest::create_wt_stream_server(&wt_session, StreamType::UniDi);
974 wt.send_data_server(&unidi_server, BUF);
975 wt.close_stream_sending_server(&unidi_server);
976
977 wt.cancel_session_server(&wt_session);
978
979 // The stream was only closed on the server side therefore it is cancelled on the client side.
980 wt.check_events_after_closing_session_client(
981 &[unidi_server.stream_id()],
982 Some(Error::HttpRequestCancelled.code()),
983 &[],
984 None,
985 false,
986 Some(&(
987 wt_session.stream_id(),
988 SessionCloseReason::Error(Error::HttpNoError.code()),
989 )),
990 );
991
992 wt.check_events_after_closing_session_server(&[], None, &[], None, None);
993 }
994
995 #[test]
996 fn wt_client_session_server_close_9() {
997 const BUF: &[u8] = &[0; 10];
998
999 let mut wt = WtTest::new();
1000 let wt_session = wt.create_wt_session();
1001
1002 let bidi_server = WtTest::create_wt_stream_server(&wt_session, StreamType::BiDi);
1003 wt.send_data_server(&bidi_server, BUF);
1004 wt.close_stream_sending_server(&bidi_server);
1005 wt.receive_data_client(bidi_server.stream_id(), true, BUF, true);
1006 wt.stream_stop_sending_server(&bidi_server);
1007 wt.receive_stop_sending_client(bidi_server.stream_id());
1008
1009 wt.cancel_session_server(&wt_session);
1010
1011 // Already close stream will not have a reset event.
1012 wt.check_events_after_closing_session_client(
1013 &[],
1014 None,
1015 &[],
1016 None,
1017 false,
1018 Some(&(
1019 wt_session.stream_id(),
1020 SessionCloseReason::Error(Error::HttpNoError.code()),
1021 )),
1022 );
1023
1024 wt.check_events_after_closing_session_server(&[], None, &[], None, None);
1025 }
1026
1027 #[test]
1028 fn wt_client_session_server_close_10() {
1029 const BUF: &[u8] = &[0; 10];
1030
1031 let mut wt = WtTest::new();
1032 let wt_session = wt.create_wt_session();
1033
1034 let bidi_server = WtTest::create_wt_stream_server(&wt_session, StreamType::BiDi);
1035 wt.send_data_server(&bidi_server, BUF);
1036 wt.close_stream_sending_server(&bidi_server);
1037 wt.stream_stop_sending_server(&bidi_server);
1038
1039 wt.cancel_session_server(&wt_session);
1040
1041 wt.check_events_after_closing_session_client(
1042 &[bidi_server.stream_id()],
1043 Some(Error::HttpRequestCancelled.code()),
1044 &[bidi_server.stream_id()],
1045 Some(Error::HttpNoError.code()),
1046 false,
1047 Some(&(
1048 wt_session.stream_id(),
1049 SessionCloseReason::Error(Error::HttpNoError.code()),
1050 )),
1051 );
1052
1053 wt.check_events_after_closing_session_server(&[], None, &[], None, None);
1054 }
1055
1056 #[test]
1057 fn wt_client_session_server_close_11() {
1058 const BUF: &[u8] = &[0; 10];
1059
1060 let mut wt = WtTest::new();
1061 let wt_session = wt.create_wt_session();
1062
1063 let bidi_client_1 = wt.create_wt_stream_client(wt_session.stream_id(), StreamType::BiDi);
1064 wt.send_data_client(bidi_client_1, BUF);
1065 drop(wt.receive_data_server(bidi_client_1, true, BUF, false));
1066 let bidi_client_2 = wt.create_wt_stream_client(wt_session.stream_id(), StreamType::BiDi);
1067 wt.send_data_client(bidi_client_2, BUF);
1068 drop(wt.receive_data_server(bidi_client_2, true, BUF, false));
1069
1070 wt.cancel_session_server(&wt_session);
1071
1072 wt.check_events_after_closing_session_client(
1073 &[bidi_client_1, bidi_client_2],
1074 Some(Error::HttpRequestCancelled.code()),
1075 &[bidi_client_1, bidi_client_2],
1076 Some(Error::HttpRequestCancelled.code()),
1077 false,
1078 Some(&(
1079 wt_session.stream_id(),
1080 SessionCloseReason::Error(Error::HttpNoError.code()),
1081 )),
1082 );
1083
1084 wt.check_events_after_closing_session_server(
1085 &[bidi_client_1, bidi_client_2],
1086 Some(Error::HttpRequestCancelled.code()),
1087 &[bidi_client_1, bidi_client_2],
1088 Some(Error::HttpRequestCancelled.code()),
1089 None,
1090 );
1091 }
1092
1093 #[test]
1094 fn wt_session_close_frame_and_streams_client() {
1095 const BUF: &[u8] = &[0; 10];
1096 const ERROR_NUM: u32 = 23;
1097 const ERROR_MESSAGE: &str = "Something went wrong";
1098 let mut wt = WtTest::new();
1099 let wt_session = wt.create_wt_session();
1100
1101 let unidi_server = WtTest::create_wt_stream_server(&wt_session, StreamType::UniDi);
1102 wt.send_data_server(&unidi_server, BUF);
1103 wt.exchange_packets();
1104
1105 wt.session_close_frame_client(wt_session.stream_id(), ERROR_NUM, ERROR_MESSAGE);
1106 wt.check_events_after_closing_session_client(
1107 &[unidi_server.stream_id()],
1108 Some(Error::HttpRequestCancelled.code()),
1109 &[],
1110 None,
1111 false,
1112 None,
1113 );
1114 wt.exchange_packets();
1115
1116 wt.check_events_after_closing_session_server(
1117 &[],
1118 None,
1119 &[unidi_server.stream_id()],
1120 Some(Error::HttpRequestCancelled.code()),
1121 Some(&(
1122 wt_session.stream_id(),
1123 SessionCloseReason::Clean {
1124 error: ERROR_NUM,
1125 message: ERROR_MESSAGE.to_string(),
1126 },
1127 )),
1128 );
1129 }