Debian Codegraph @

third_party/rust/neqo-transport/src/connection/tests/stream.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 std::{cmp::max, collections::HashMap, fmt::Debug};
8
9 use neqo_common::{event::Provider as _, qdebug};
10 use test_fixture::now;
11
12 use super::{
13 super::State, assert_error, connect, connect_force_idle, default_client, default_server,
14 maybe_authenticate, new_client, new_server, send_something, send_with_extra,
15 DEFAULT_STREAM_DATA,
16 };
17 use crate::{
18 events::ConnectionEvent,
19 frame::FrameType,
20 packet::PacketBuilder,
21 recv_stream::INITIAL_RECV_WINDOW_SIZE,
22 send_stream::{OrderGroup, SendStreamState},
23 streams::{SendOrder, StreamOrder},
24 tparams::{TransportParameter, TransportParameterId::*},
25 CloseReason, Connection, ConnectionParameters, Error, StreamId, StreamType,
26 };
27
28 #[test]
29 fn stream_create() {
30 let mut client = default_client();
31
32 let out = client.process_output(now());
33 let out2 = client.process_output(now());
34 let mut server = default_server();
35 server.process_input(out.dgram().unwrap(), now());
36 let out = server.process(out2.dgram(), now());
37
38 let out = client.process(out.dgram(), now());
39 let out = server.process(out.dgram(), now());
40 let out = client.process(out.dgram(), now());
41 drop(server.process(out.dgram(), now()));
42 assert!(maybe_authenticate(&mut client));
43 let out = client.process_output(now());
44
45 // client now in State::Connected
46 assert_eq!(client.stream_create(StreamType::UniDi).unwrap(), 2);
47 assert_eq!(client.stream_create(StreamType::UniDi).unwrap(), 6);
48 assert_eq!(client.stream_create(StreamType::BiDi).unwrap(), 0);
49 assert_eq!(client.stream_create(StreamType::BiDi).unwrap(), 4);
50
51 drop(server.process(out.dgram(), now()));
52 // server now in State::Connected
53 assert_eq!(server.stream_create(StreamType::UniDi).unwrap(), 3);
54 assert_eq!(server.stream_create(StreamType::UniDi).unwrap(), 7);
55 assert_eq!(server.stream_create(StreamType::BiDi).unwrap(), 1);
56 assert_eq!(server.stream_create(StreamType::BiDi).unwrap(), 5);
57 }
58
59 #[test]
60 // tests stream send/recv after connection is established.
61 fn transfer() {
62 let mut client = default_client();
63 let mut server = default_server();
64 connect_force_idle(&mut client, &mut server);
65
66 qdebug!("---- client sends");
67 // Send
68 let client_stream_id = client.stream_create(StreamType::UniDi).unwrap();
69 client.stream_send(client_stream_id, &[6; 100]).unwrap();
70 client.stream_send(client_stream_id, &[7; 40]).unwrap();
71 client.stream_send(client_stream_id, &[8; 4000]).unwrap();
72
73 // Send to another stream but some data after fin has been set
74 let client_stream_id2 = client.stream_create(StreamType::UniDi).unwrap();
75 client.stream_send(client_stream_id2, &[6; 60]).unwrap();
76 client.stream_close_send(client_stream_id2).unwrap();
77 client.stream_send(client_stream_id2, &[7; 50]).unwrap_err();
78 // Sending this much takes a few datagrams.
79 let mut datagrams = vec![];
80 let mut out = client.process_output(now());
81 while let Some(d) = out.dgram() {
82 datagrams.push(d);
83 out = client.process_output(now());
84 }
85 assert_eq!(datagrams.len(), 4);
86 assert_eq!(*client.state(), State::Confirmed);
87
88 qdebug!("---- server receives");
89 for d in datagrams {
90 let out = server.process(Some(d), now());
91 // With an RTT of zero, the server will acknowledge every packet immediately.
92 assert!(out.as_dgram_ref().is_some());
93 qdebug!("Output={:0x?}", out.as_dgram_ref());
94 }
95 assert_eq!(*server.state(), State::Confirmed);
96
97 let mut buf = vec![0; 4000];
98
99 let mut stream_ids = server.events().filter_map(|evt| match evt {
100 ConnectionEvent::NewStream { stream_id, .. } => Some(stream_id),
101 _ => None,
102 });
103 let first_stream = stream_ids.next().expect("should have a new stream event");
104 let second_stream = stream_ids
105 .next()
106 .expect("should have a second new stream event");
107 assert!(stream_ids.next().is_none());
108 let (received1, fin1) = server.stream_recv(first_stream, &mut buf).unwrap();
109 assert_eq!(received1, 4000);
110 assert!(!fin1);
111 let (received2, fin2) = server.stream_recv(first_stream, &mut buf).unwrap();
112 assert_eq!(received2, 140);
113 assert!(!fin2);
114
115 let (received3, fin3) = server.stream_recv(second_stream, &mut buf).unwrap();
116 assert_eq!(received3, 60);
117 assert!(fin3);
118 }
119
120 // tests stream sendorder prioritization
121 fn sendorder_test(order_of_sendorder: &[Option<SendOrder>]) {
122 let mut client = default_client();
123 let mut server = default_server();
124 connect_force_idle(&mut client, &mut server);
125
126 qdebug!("---- client sends");
127 // open all streams and set the sendorders
128 let mut ordered = Vec::new();
129 let mut streams = Vec::<StreamId>::new();
130 for sendorder in order_of_sendorder {
131 let id = client.stream_create(StreamType::UniDi).unwrap();
132 streams.push(id);
133 ordered.push((id, *sendorder));
134 // must be set before sendorder
135 client.streams.set_fairness(id, true).unwrap();
136 client.streams.set_sendorder(id, *sendorder).unwrap();
137 }
138 // Write some data to all the streams
139 for stream_id in streams {
140 client.stream_send(stream_id, &[6; 100]).unwrap();
141 }
142
143 // Sending this much takes a few datagrams.
144 // Note: this test uses an RTT of 0 which simplifies things (no pacing)
145 let mut datagrams = Vec::new();
146 let mut out = client.process_output(now());
147 while let Some(d) = out.dgram() {
148 datagrams.push(d);
149 out = client.process_output(now());
150 }
151 assert_eq!(*client.state(), State::Confirmed);
152
153 qdebug!("---- server receives");
154 for d in datagrams {
155 let out = server.process(Some(d), now());
156 qdebug!("Output={:0x?}", out.as_dgram_ref());
157 }
158 assert_eq!(*server.state(), State::Confirmed);
159
160 let stream_ids = server
161 .events()
162 .filter_map(|evt| match evt {
163 ConnectionEvent::RecvStreamReadable { stream_id, .. } => Some(stream_id),
164 _ => None,
165 })
166 .enumerate()
167 .map(|(a, b)| (b, a))
168 .collect::<HashMap<_, _>>();
169
170 // streams should arrive in priority order, not order of creation, if sendorder prioritization
171 // is working correctly
172
173 // 'ordered' has the send order currently. Re-sort it by sendorder, but
174 // if two items from the same sendorder exist, secondarily sort by the ordering in
175 // the stream_ids vector (HashMap<StreamId, index: usize>)
176 ordered.sort_unstable_by_key(|(stream_id, sendorder)| {
177 (
178 StreamOrder {
179 sendorder: *sendorder,
180 },
181 stream_ids[stream_id],
182 )
183 });
184 // make sure everything now is in the same order, since we modified the order of
185 // same-sendorder items to match the ordering of those we saw in reception
186 for (i, (stream_id, _sendorder)) in ordered.iter().enumerate() {
187 assert_eq!(i, stream_ids[stream_id]);
188 }
189 }
190
191 #[test]
192 fn sendorder_0() {
193 sendorder_test(&[None, Some(1), Some(2), Some(3)]);
194 }
195 #[test]
196 fn sendorder_1() {
197 sendorder_test(&[Some(3), Some(2), Some(1), None]);
198 }
199 #[test]
200 fn sendorder_2() {
201 sendorder_test(&[Some(3), None, Some(2), Some(1)]);
202 }
203 #[test]
204 fn sendorder_3() {
205 sendorder_test(&[Some(1), Some(2), None, Some(3)]);
206 }
207 #[test]
208 fn sendorder_4() {
209 sendorder_test(&[
210 Some(1),
211 Some(2),
212 Some(1),
213 None,
214 Some(3),
215 Some(1),
216 Some(3),
217 None,
218 ]);
219 }
220
221 // Tests stream sendorder prioritization
222 // Converts Vecs of u64's into StreamIds
223 fn fairness_test<S, R>(source: S, number_iterates: usize, truncate_to: usize, result_array: &R)
224 where
225 S: IntoIterator,
226 S::Item: Into<StreamId>,
227 R: IntoIterator + Debug,
228 R::Item: Into<StreamId>,
229 Vec<u64>: PartialEq<R>,
230 {
231 // test the OrderGroup code used for fairness
232 let mut group: OrderGroup = OrderGroup::default();
233 for stream_id in source {
234 group.insert(stream_id.into());
235 }
236 {
237 let mut iterator1 = group.iter();
238 // advance_by() would help here
239 let mut n = number_iterates;
240 while n > 0 {
241 iterator1.next();
242 n -= 1;
243 }
244 // let iterator1 go out of scope
245 }
246 group.truncate(truncate_to);
247
248 let iterator2 = group.iter();
249 let result: Vec<u64> = iterator2.map(StreamId::as_u64).collect();
250 assert_eq!(result, *result_array);
251 }
252
253 #[test]
254 fn ordergroup_0() {
255 let source: [u64; 0] = [];
256 let result: [u64; 0] = [];
257 fairness_test(source, 1, usize::MAX, &result);
258 }
259
260 #[test]
261 fn ordergroup_1() {
262 let source: [u64; 6] = [0, 1, 2, 3, 4, 5];
263 let result: [u64; 6] = [1, 2, 3, 4, 5, 0];
264 fairness_test(source, 1, usize::MAX, &result);
265 }
266
267 #[test]
268 fn ordergroup_2() {
269 let source: [u64; 6] = [0, 1, 2, 3, 4, 5];
270 let result: [u64; 6] = [2, 3, 4, 5, 0, 1];
271 fairness_test(source, 2, usize::MAX, &result);
272 }
273
274 #[test]
275 fn ordergroup_3() {
276 let source: [u64; 6] = [0, 1, 2, 3, 4, 5];
277 let result: [u64; 6] = [0, 1, 2, 3, 4, 5];
278 fairness_test(source, 10, usize::MAX, &result);
279 }
280
281 #[test]
282 fn ordergroup_4() {
283 let source: [u64; 6] = [0, 1, 2, 3, 4, 5];
284 let result: [u64; 6] = [0, 1, 2, 3, 4, 5];
285 fairness_test(source, 0, usize::MAX, &result);
286 }
287
288 #[test]
289 fn ordergroup_5() {
290 let source: [u64; 1] = [0];
291 let result: [u64; 1] = [0];
292 fairness_test(source, 1, usize::MAX, &result);
293 }
294
295 #[test]
296 fn ordergroup_6() {
297 let source: [u64; 6] = [0, 1, 2, 3, 4, 5];
298 let result: [u64; 6] = [5, 0, 1, 2, 3, 4];
299 fairness_test(source, 5, usize::MAX, &result);
300 }
301
302 #[test]
303 fn ordergroup_7() {
304 let source: [u64; 6] = [0, 1, 2, 3, 4, 5];
305 let result: [u64; 3] = [0, 1, 2];
306 fairness_test(source, 5, 3, &result);
307 }
308
309 #[test]
310 // Send fin even if a peer closes a remote bidi send stream before sending any data.
311 fn report_fin_when_stream_closed_wo_data() {
312 // Note that the two servers in this test will get different anti-replay filters.
313 // That's OK because we aren't testing anti-replay.
314 let mut client = default_client();
315 let mut server = default_server();
316 connect(&mut client, &mut server);
317
318 // create a stream
319 let stream_id = client.stream_create(StreamType::BiDi).unwrap();
320 client.stream_send(stream_id, &[0x00]).unwrap();
321 let out = client.process_output(now());
322 drop(server.process(out.dgram(), now()));
323
324 server.stream_close_send(stream_id).unwrap();
325 let out = server.process_output(now());
326 drop(client.process(out.dgram(), now()));
327 let stream_readable = |e| matches!(e, ConnectionEvent::RecvStreamReadable { .. });
328 assert!(client.events().any(stream_readable));
329 }
330
331 fn exchange_data(client: &mut Connection, server: &mut Connection) {
332 let mut input = None;
333 loop {
334 let out = client.process(input, now()).dgram();
335 let c_done = out.is_none();
336 let out = server.process(out, now()).dgram();
337 if out.is_none() && c_done {
338 break;
339 }
340 input = out;
341 }
342 }
343
344 #[test]
345 fn sending_max_data() {
346 const SMALL_MAX_DATA: usize = 2048;
347
348 let mut client = default_client();
349 let mut server = new_server(
350 ConnectionParameters::default().max_data(u64::try_from(SMALL_MAX_DATA).unwrap()),
351 );
352
353 connect(&mut client, &mut server);
354
355 let stream_id = client.stream_create(StreamType::UniDi).unwrap();
356 assert_eq!(client.events().count(), 2); // SendStreamWritable, StateChange(connected)
357 assert_eq!(stream_id, 2);
358 assert_eq!(
359 client.stream_avail_send_space(stream_id).unwrap(),
360 SMALL_MAX_DATA
361 );
362
363 assert_eq!(
364 client
365 .stream_send(stream_id, &[b'a'; SMALL_MAX_DATA + 1])
366 .unwrap(),
367 SMALL_MAX_DATA
368 );
369
370 exchange_data(&mut client, &mut server);
371
372 let mut buf = vec![0; 40000];
373 let (received, fin) = server.stream_recv(stream_id, &mut buf).unwrap();
374 assert_eq!(received, SMALL_MAX_DATA);
375 assert!(!fin);
376
377 let out = server.process_output(now()).dgram();
378 client.process_input(out.unwrap(), now());
379
380 assert_eq!(
381 client
382 .stream_send(stream_id, &[b'a'; SMALL_MAX_DATA + 1])
383 .unwrap(),
384 SMALL_MAX_DATA
385 );
386 }
387
388 #[test]
389 fn max_data() {
390 const SMALL_MAX_DATA: usize = 16383;
391
392 let mut client = default_client();
393 let mut server = default_server();
394
395 server
396 .set_local_tparam(
397 InitialMaxData,
398 TransportParameter::Integer(u64::try_from(SMALL_MAX_DATA).unwrap()),
399 )
400 .unwrap();
401
402 connect(&mut client, &mut server);
403
404 let stream_id = client.stream_create(StreamType::UniDi).unwrap();
405 assert_eq!(client.events().count(), 2); // SendStreamWritable, StateChange(connected)
406 assert_eq!(stream_id, 2);
407 assert_eq!(
408 client.stream_avail_send_space(stream_id).unwrap(),
409 SMALL_MAX_DATA
410 );
411 assert_eq!(
412 client
413 .stream_send(stream_id, &[b'a'; SMALL_MAX_DATA + 1])
414 .unwrap(),
415 SMALL_MAX_DATA
416 );
417 assert_eq!(client.events().count(), 0);
418
419 assert_eq!(client.stream_send(stream_id, b"hello").unwrap(), 0);
420 client
421 .streams
422 .get_send_stream_mut(stream_id)
423 .unwrap()
424 .mark_as_sent(0, 4096, false);
425 assert_eq!(client.events().count(), 0);
426 client
427 .streams
428 .get_send_stream_mut(stream_id)
429 .unwrap()
430 .mark_as_acked(0, 4096, false);
431 assert_eq!(client.events().count(), 0);
432
433 assert_eq!(client.stream_send(stream_id, b"hello").unwrap(), 0);
434 // no event because still limited by conn max data
435 assert_eq!(client.events().count(), 0);
436
437 // Increase max data. Avail space now limited by stream credit
438 client.streams.handle_max_data(100_000_000);
439 assert_eq!(
440 client.stream_avail_send_space(stream_id).unwrap(),
441 INITIAL_RECV_WINDOW_SIZE - SMALL_MAX_DATA
442 );
443
444 let evts = client.events().collect::<Vec<_>>();
445 assert_eq!(evts.len(), 1);
446 assert!(matches!(
447 evts[0],
448 ConnectionEvent::SendStreamWritable { .. }
449 ));
450 }
451
452 #[test]
453 fn exceed_max_data() {
454 const SMALL_MAX_DATA: usize = 1024;
455
456 let mut client = default_client();
457 let mut server = new_server(
458 ConnectionParameters::default().max_data(u64::try_from(SMALL_MAX_DATA).unwrap()),
459 );
460
461 connect(&mut client, &mut server);
462
463 let stream_id = client.stream_create(StreamType::UniDi).unwrap();
464 assert_eq!(client.events().count(), 2); // SendStreamWritable, StateChange(connected)
465 assert_eq!(stream_id, 2);
466 assert_eq!(
467 client.stream_avail_send_space(stream_id).unwrap(),
468 SMALL_MAX_DATA
469 );
470 assert_eq!(
471 client
472 .stream_send(stream_id, &[b'a'; SMALL_MAX_DATA + 1])
473 .unwrap(),
474 SMALL_MAX_DATA
475 );
476
477 assert_eq!(client.stream_send(stream_id, b"hello").unwrap(), 0);
478
479 // Artificially trick the client to think that it has more flow control credit.
480 client.streams.handle_max_data(100_000_000);
481 assert_eq!(client.stream_send(stream_id, b"h").unwrap(), 1);
482
483 exchange_data(&mut client, &mut server);
484
485 assert_error(
486 &client,
487 &CloseReason::Transport(Error::PeerError(Error::FlowControlError.code())),
488 );
489 assert_error(&server, &CloseReason::Transport(Error::FlowControlError));
490 }
491
492 #[test]
493 // If we send a stop_sending to the peer, we should not accept more data from the peer.
494 fn do_not_accept_data_after_stop_sending() {
495 // Note that the two servers in this test will get different anti-replay filters.
496 // That's OK because we aren't testing anti-replay.
497 let mut client = default_client();
498 let mut server = default_server();
499 connect(&mut client, &mut server);
500
501 // create a stream
502 let stream_id = client.stream_create(StreamType::BiDi).unwrap();
503 client.stream_send(stream_id, &[0x00]).unwrap();
504 let out = client.process_output(now());
505 drop(server.process(out.dgram(), now()));
506
507 let stream_readable = |e| matches!(e, ConnectionEvent::RecvStreamReadable { .. });
508 assert!(server.events().any(stream_readable));
509
510 // Send one more packet from client. The packet should arrive after the server
511 // has already requested stop_sending.
512 client.stream_send(stream_id, &[0x00]).unwrap();
513 let out_second_data_frame = client.process_output(now());
514 // Call stop sending.
515 assert_eq!(
516 Ok(()),
517 server.stream_stop_sending(stream_id, Error::NoError.code())
518 );
519
520 // Receive the second data frame. The frame should be ignored and
521 // DataReadable events shouldn't be posted.
522 let out = server.process(out_second_data_frame.dgram(), now());
523 assert!(!server.events().any(stream_readable));
524
525 drop(client.process(out.dgram(), now()));
526 assert_eq!(
527 Err(Error::FinalSizeError),
528 client.stream_send(stream_id, &[0x00])
529 );
530 }
531
532 struct Writer(Vec<u64>);
533
534 impl crate::connection::test_internal::FrameWriter for Writer {
535 fn write_frames(&mut self, builder: &mut PacketBuilder) {
536 builder.write_varint_frame(&self.0);
537 }
538 }
539
540 #[test]
541 /// Server sends a number of stream-related frames for a client-initiated stream that is not yet
542 /// created. This should cause the client to close the connection.
543 fn illegal_stream_related_frames() {
544 fn test_with_illegal_frame(frame: &[u64]) {
545 let mut client = default_client();
546 let mut server = default_server();
547 connect(&mut client, &mut server);
548 let dgram = send_with_extra(&mut server, Writer(frame.to_vec()), now());
549 client.process_input(dgram, now());
550 assert!(client.state().closed());
551 }
552
553 // 0 = Client-Initiated, Bidirectional; 2 = Client-Initiated, Unidirectional
554 for stream_id in [0, 2] {
555 for frame_type in [
556 FrameType::ResetStream,
557 FrameType::StopSending,
558 FrameType::MaxStreamData,
559 FrameType::StreamDataBlocked,
560 FrameType::Stream,
561 ] {
562 // The slice contains an extra 0 that is only needed for a RESET_STREAM frame.
563 // It's ignored for the other frame types as PADDING.
564 test_with_illegal_frame(&[frame_type.into(), stream_id, 0, 0]);
565 }
566 }
567 }
568
569 #[test]
570 /// Regression <https://github.com/mozilla/neqo/pull/2358>.
571 fn legal_out_of_order_frame_on_remote_initiated_closed_stream() {
572 const REQUEST: &[u8] = b"ping";
573 let mut client = default_client();
574 let mut server = default_server();
575 connect(&mut client, &mut server);
576
577 // Client sends request and closes stream.
578 let stream_id = client.stream_create(StreamType::BiDi).unwrap();
579 _ = client.stream_send(stream_id, REQUEST).unwrap();
580 client.stream_close_send(stream_id).unwrap();
581 let dgram = client.process_output(now()).dgram();
582
583 // Server reads request and closes stream.
584 server.process_input(dgram.unwrap(), now());
585 let mut buf = [0; REQUEST.len()];
586 server.stream_recv(stream_id, &mut buf).unwrap();
587 server.stream_close_send(stream_id).unwrap();
588 let dgram = server.process_output(now()).dgram();
589 client.process_input(dgram.unwrap(), now());
590
591 // Client ACKs server's close stream, thus server forgetting about stream.
592 let dgram = send_something(&mut client, now());
593 let dgram = server.process(Some(dgram), now()).dgram();
594 client.process_input(dgram.unwrap(), now());
595
596 // Deliver an out-of-order `FRAME_TYPE_MAX_STREAM_DATA` on forgotten stream.
597 let dgram = send_with_extra(
598 &mut client,
599 Writer(vec![
600 u64::from(FrameType::MaxStreamData),
601 stream_id.as_u64(),
602 0,
603 0,
604 ]),
605 now(),
606 );
607 server.process_input(dgram, now());
608
609 assert!(
610 !server.state().closed(),
611 "expect server to ignore out-of-order frame on forgotten stream"
612 );
613 }
614
615 #[test]
616 // Server sends stop_sending, the client simultaneous sends reset.
617 fn simultaneous_stop_sending_and_reset() {
618 let mut client = default_client();
619 let mut server = default_server();
620 connect(&mut client, &mut server);
621
622 // create a stream
623 let stream_id = client.stream_create(StreamType::BiDi).unwrap();
624 client.stream_send(stream_id, &[0x00]).unwrap();
625 let out = client.process_output(now());
626 let ack = server.process(out.dgram(), now()).dgram();
627
628 let stream_readable =
629 |e| matches!(e, ConnectionEvent::RecvStreamReadable { stream_id: id } if id == stream_id);
630 assert!(server.events().any(stream_readable));
631
632 // The client resets the stream. The packet with reset should arrive after the server
633 // has already requested stop_sending.
634 client.stream_reset_send(stream_id, 0).unwrap();
635 let out_reset_frame = client.process(ack, now()).dgram();
636
637 // Send something out of order to force the server to generate an
638 // acknowledgment at the next opportunity.
639 let force_ack = send_something(&mut client, now());
640 server.process_input(force_ack, now());
641
642 // Call stop sending.
643 server.stream_stop_sending(stream_id, 0).unwrap();
644 // Receive the second data frame. The frame should be ignored and
645 // DataReadable events shouldn't be posted.
646 let ack = server.process(out_reset_frame, now()).dgram();
647 assert!(ack.is_some());
648 assert!(!server.events().any(stream_readable));
649
650 // The client gets the STOP_SENDING frame.
651 client.process_input(ack.unwrap(), now());
652 assert_eq!(
653 Err(Error::InvalidStreamId),
654 client.stream_send(stream_id, &[0x00])
655 );
656 }
657
658 #[test]
659 /// Make a stream data or control frame arrive after the stream has been used and cleared.
660 fn late_stream_related_frames() {
661 fn late_stream_related_frame(frame_type: FrameType) {
662 let mut client = default_client();
663 let mut server = default_server();
664 connect(&mut client, &mut server);
665
666 // Client creates a stream and sends some data.
667 let stream_id = client.stream_create(StreamType::BiDi).unwrap();
668 client.stream_send(stream_id, &[0x00]).unwrap();
669 let out = client.process_output(now());
670 _ = server.process(out.dgram(), now()).dgram();
671
672 // Make the server generate a packet containing the test frame.
673 let before = server.stats().frame_tx;
674 match frame_type {
675 FrameType::ResetStream => {
676 server.stream_reset_send(stream_id, 0).unwrap();
677 }
678 FrameType::StopSending => {
679 server.stream_stop_sending(stream_id, 0).unwrap();
680 }
681 FrameType::Stream => {
682 server.stream_send(stream_id, &[0x00]).unwrap();
683 server.stream_close_send(stream_id).unwrap();
684 }
685 FrameType::MaxStreamData => {
686 server
687 .streams
688 .get_recv_stream_mut(stream_id)
689 .unwrap()
690 .set_stream_max_data(u32::MAX.into());
691 }
692 FrameType::StreamDataBlocked => {
693 let internal_stream = server.streams.get_send_stream_mut(stream_id).unwrap();
694 if let SendStreamState::Ready { fc, .. } = internal_stream.state() {
695 fc.blocked();
696 } else {
697 panic!("unexpected stream state");
698 }
699 }
700 _ => panic!("unexpected frame type"),
701 }
702 let tester = server.process_output(now()).dgram();
703 let after = server.stats().frame_tx;
704 match frame_type {
705 FrameType::ResetStream => {
706 assert_eq!(after.reset_stream, before.reset_stream + 1);
707 }
708 FrameType::StopSending => {
709 assert_eq!(after.stop_sending, before.stop_sending + 1);
710 }
711 FrameType::Stream => {
712 assert_eq!(after.stream, before.stream + 1);
713 }
714 FrameType::MaxStreamData => {
715 assert_eq!(after.max_stream_data, before.max_stream_data + 1);
716 }
717 FrameType::StreamDataBlocked => {
718 assert_eq!(after.stream_data_blocked, before.stream_data_blocked + 1);
719 }
720 _ => panic!("unexpected frame type"),
721 }
722
723 // Now clear the streams on the client, and then deliver the test frame.
724 client.streams.clear_streams();
725 let (ss, rs) = client.streams.obtain_stream(stream_id).unwrap();
726 assert!(ss.is_none() && rs.is_none());
727 _ = client.process(tester, now()).dgram();
728
729 // Make sure this worked, i.e., the connection didn't close.
730 assert_eq!(*client.state(), State::Confirmed);
731 }
732
733 for frame_type in [
734 FrameType::ResetStream,
735 FrameType::StopSending,
736 FrameType::MaxStreamData,
737 FrameType::StreamDataBlocked,
738 FrameType::Stream,
739 ] {
740 late_stream_related_frame(frame_type);
741 }
742 }
743
744 #[test]
745 fn client_fin_reorder() {
746 let mut client = default_client();
747 let mut server = default_server();
748
749 // Send ClientHello.
750 let client_hs = client.process_output(now());
751 let client_hs2 = client.process_output(now());
752 assert!(client_hs.as_dgram_ref().is_some() && client_hs2.as_dgram_ref().is_some());
753
754 server.process_input(client_hs.dgram().unwrap(), now());
755 let server_hs = server.process(client_hs2.dgram(), now());
756 assert!(server_hs.as_dgram_ref().is_some()); // ServerHello, etc...
757
758 let client_ack = client.process(server_hs.dgram(), now());
759 assert!(client_ack.as_dgram_ref().is_some());
760
761 let dgram = server.process(client_ack.dgram(), now());
762 let dgram = client.process(dgram.dgram(), now());
763
764 let server_out = server.process(dgram.dgram(), now());
765 assert!(server_out.as_dgram_ref().is_none());
766
767 assert!(maybe_authenticate(&mut client));
768 assert_eq!(*client.state(), State::Connected);
769
770 let client_fin = client.process_output(now());
771 assert!(client_fin.as_dgram_ref().is_some());
772
773 let client_stream_id = client.stream_create(StreamType::UniDi).unwrap();
774 client.stream_send(client_stream_id, &[1, 2, 3]).unwrap();
775 let client_stream_data = client.process_output(now());
776 assert!(client_stream_data.as_dgram_ref().is_some());
777
778 // Now stream data gets before client_fin
779 let server_out = server.process(client_stream_data.dgram(), now());
780 assert!(server_out.as_dgram_ref().is_none()); // the packet will be discarded
781
782 assert_eq!(*server.state(), State::Handshaking);
783 let server_out = server.process(client_fin.dgram(), now());
784 assert!(server_out.as_dgram_ref().is_some());
785 }
786
787 #[test]
788 fn after_fin_is_read_conn_events_for_stream_should_be_removed() {
789 let mut client = default_client();
790 let mut server = default_server();
791 connect(&mut client, &mut server);
792
793 let id = server.stream_create(StreamType::BiDi).unwrap();
794 server.stream_send(id, &[6; 10]).unwrap();
795 server.stream_close_send(id).unwrap();
796 let out = server.process_output(now()).dgram();
797 assert!(out.is_some());
798
799 drop(client.process(out, now()));
800
801 // read from the stream before checking connection events.
802 let mut buf = vec![0; 4000];
803 let (_, fin) = client.stream_recv(id, &mut buf).unwrap();
804 assert!(fin);
805
806 // Make sure we do not have RecvStreamReadable events for the stream when fin has been read.
807 let readable_stream_evt =
808 |e| matches!(e, ConnectionEvent::RecvStreamReadable { stream_id } if stream_id == id);
809 assert!(!client.events().any(readable_stream_evt));
810 }
811
812 #[test]
813 fn after_stream_stop_sending_is_called_conn_events_for_stream_should_be_removed() {
814 let mut client = default_client();
815 let mut server = default_server();
816 connect(&mut client, &mut server);
817
818 let id = server.stream_create(StreamType::BiDi).unwrap();
819 server.stream_send(id, &[6; 10]).unwrap();
820 server.stream_close_send(id).unwrap();
821 let out = server.process_output(now()).dgram();
822 assert!(out.is_some());
823
824 drop(client.process(out, now()));
825
826 // send stop sending.
827 client
828 .stream_stop_sending(id, Error::NoError.code())
829 .unwrap();
830
831 // Make sure we do not have RecvStreamReadable events for the stream after stream_stop_sending
832 // has been called.
833 let readable_stream_evt =
834 |e| matches!(e, ConnectionEvent::RecvStreamReadable { stream_id } if stream_id == id);
835 assert!(!client.events().any(readable_stream_evt));
836 }
837
838 #[test]
839 fn stream_data_blocked_generates_max_stream_data() {
840 let mut client = default_client();
841 let mut server = default_server();
842 connect(&mut client, &mut server);
843
844 let now = now();
845
846 // Send some data and consume some flow control.
847 let stream_id = server.stream_create(StreamType::UniDi).unwrap();
848 _ = server.stream_send(stream_id, DEFAULT_STREAM_DATA).unwrap();
849 let dgram = server.process_output(now).dgram();
850 assert!(dgram.is_some());
851
852 // Consume the data.
853 client.process_input(dgram.unwrap(), now);
854 let mut buf = [0; 10];
855 let (count, end) = client.stream_recv(stream_id, &mut buf[..]).unwrap();
856 assert_eq!(count, DEFAULT_STREAM_DATA.len());
857 assert!(!end);
858
859 // Now send `STREAM_DATA_BLOCKED`.
860 let internal_stream = server.streams.get_send_stream_mut(stream_id).unwrap();
861 if let SendStreamState::Send { fc, .. } = internal_stream.state() {
862 fc.blocked();
863 } else {
864 panic!("unexpected stream state");
865 }
866 let dgram = server.process_output(now).dgram();
867 assert!(dgram.is_some());
868
869 let sdb_before = client.stats().frame_rx.stream_data_blocked;
870 let dgram = client.process(dgram, now).dgram();
871 assert_eq!(client.stats().frame_rx.stream_data_blocked, sdb_before + 1);
872 assert!(dgram.is_some());
873
874 // Client should have sent a MAX_STREAM_DATA frame with just a small increase
875 // on the default window size.
876 let msd_before = server.stats().frame_rx.max_stream_data;
877 server.process_input(dgram.unwrap(), now);
878 assert_eq!(server.stats().frame_rx.max_stream_data, msd_before + 1);
879
880 // Test that the entirety of the receive buffer is available now.
881 let mut written = 0;
882 loop {
883 const LARGE_BUFFER: &[u8] = &[0; 1024];
884 let amount = server.stream_send(stream_id, LARGE_BUFFER).unwrap();
885 if amount == 0 {
886 break;
887 }
888 written += amount;
889 }
890 assert_eq!(written, INITIAL_RECV_WINDOW_SIZE);
891 }
892
893 /// See <https://github.com/mozilla/neqo/issues/871>
894 #[test]
895 fn max_streams_after_bidi_closed() {
896 const REQUEST: &[u8] = b"ping";
897 const RESPONSE: &[u8] = b"pong";
898 let mut client = default_client();
899 let mut server = default_server();
900 connect(&mut client, &mut server);
901
902 let stream_id = client.stream_create(StreamType::BiDi).unwrap();
903 while client.stream_create(StreamType::BiDi).is_ok() {
904 // Exhaust the stream limit.
905 }
906 // Write on the one stream and send that out.
907 _ = client.stream_send(stream_id, REQUEST).unwrap();
908 client.stream_close_send(stream_id).unwrap();
909 let dgram = client.process_output(now()).dgram();
910
911 // Now handle the stream and send an incomplete response.
912 server.process_input(dgram.unwrap(), now());
913 server.stream_send(stream_id, RESPONSE).unwrap();
914 let dgram = server.process_output(now()).dgram();
915
916 // The server shouldn't have released more stream credit.
917 client.process_input(dgram.unwrap(), now());
918 let e = client.stream_create(StreamType::BiDi).unwrap_err();
919 assert!(matches!(e, Error::StreamLimitError));
920
921 // Closing the stream isn't enough.
922 server.stream_close_send(stream_id).unwrap();
923 let dgram = server.process_output(now()).dgram();
924 client.process_input(dgram.unwrap(), now());
925 assert!(client.stream_create(StreamType::BiDi).is_err());
926
927 // The server needs to see an acknowledgment from the client for its
928 // response AND the server has to read all of the request.
929 // and the server needs to read all the data. Read first.
930 let mut buf = [0; REQUEST.len()];
931 let (count, fin) = server.stream_recv(stream_id, &mut buf).unwrap();
932 assert_eq!(&buf[..count], REQUEST);
933 assert!(fin);
934
935 // We need an ACK from the client now, but that isn't guaranteed,
936 // so give the client one more packet just in case.
937 let dgram = send_something(&mut server, now());
938 client.process_input(dgram, now());
939
940 // Now get the client to send the ACK and have the server handle that.
941 let dgram = send_something(&mut client, now());
942 let dgram = server.process(Some(dgram), now()).dgram();
943 client.process_input(dgram.unwrap(), now());
944 assert!(client.stream_create(StreamType::BiDi).is_ok());
945 assert!(client.stream_create(StreamType::BiDi).is_err());
946 }
947
948 #[test]
949 fn no_dupdata_readable_events() {
950 let mut client = default_client();
951 let mut server = default_server();
952 connect(&mut client, &mut server);
953
954 // create a stream
955 let stream_id = client.stream_create(StreamType::BiDi).unwrap();
956 client.stream_send(stream_id, &[0x00]).unwrap();
957 let out = client.process_output(now());
958 drop(server.process(out.dgram(), now()));
959
960 // We have a data_readable event.
961 let stream_readable = |e| matches!(e, ConnectionEvent::RecvStreamReadable { .. });
962 assert!(server.events().any(stream_readable));
963
964 // Send one more data frame from client. The previous stream data has not been read yet,
965 // therefore there should not be a new DataReadable event.
966 client.stream_send(stream_id, &[0x00]).unwrap();
967 let out_second_data_frame = client.process_output(now());
968 drop(server.process(out_second_data_frame.dgram(), now()));
969 assert!(!server.events().any(stream_readable));
970
971 // One more frame with a fin will not produce a new DataReadable event, because the
972 // previous stream data has not been read yet.
973 client.stream_send(stream_id, &[0x00]).unwrap();
974 client.stream_close_send(stream_id).unwrap();
975 let out_third_data_frame = client.process_output(now());
976 drop(server.process(out_third_data_frame.dgram(), now()));
977 assert!(!server.events().any(stream_readable));
978 }
979
980 #[test]
981 fn no_dupdata_readable_events_empty_last_frame() {
982 let mut client = default_client();
983 let mut server = default_server();
984 connect(&mut client, &mut server);
985
986 // create a stream
987 let stream_id = client.stream_create(StreamType::BiDi).unwrap();
988 client.stream_send(stream_id, &[0x00]).unwrap();
989 let out = client.process_output(now());
990 drop(server.process(out.dgram(), now()));
991
992 // We have a data_readable event.
993 let stream_readable = |e| matches!(e, ConnectionEvent::RecvStreamReadable { .. });
994 assert!(server.events().any(stream_readable));
995
996 // An empty frame with a fin will not produce a new DataReadable event, because
997 // the previous stream data has not been read yet.
998 client.stream_close_send(stream_id).unwrap();
999 let out_second_data_frame = client.process_output(now());
1000 drop(server.process(out_second_data_frame.dgram(), now()));
1001 assert!(!server.events().any(stream_readable));
1002 }
1003
1004 fn change_flow_control(stream_type: StreamType, new_fc: u64) {
1005 const RECV_BUFFER_START: u64 = 300;
1006
1007 let mut client = new_client(
1008 ConnectionParameters::default()
1009 .max_stream_data(StreamType::BiDi, true, RECV_BUFFER_START)
1010 .max_stream_data(StreamType::UniDi, true, RECV_BUFFER_START),
1011 );
1012 let mut server = default_server();
1013 connect(&mut client, &mut server);
1014
1015 // create a stream
1016 let stream_id = server.stream_create(stream_type).unwrap();
1017 let written1 = server.stream_send(stream_id, &[0x0; 10000]).unwrap();
1018 assert_eq!(u64::try_from(written1).unwrap(), RECV_BUFFER_START);
1019
1020 // Send the stream to the client.
1021 let out = server.process_output(now());
1022 drop(client.process(out.dgram(), now()));
1023
1024 // change max_stream_data for stream_id.
1025 client.set_stream_max_data(stream_id, new_fc).unwrap();
1026
1027 // server should receive a MAX_SREAM_DATA frame if the flow control window is updated.
1028 let out2 = client.process_output(now());
1029 let out3 = server.process(out2.dgram(), now());
1030 let expected = usize::from(RECV_BUFFER_START < new_fc);
1031 assert_eq!(server.stats().frame_rx.max_stream_data, expected);
1032
1033 // If the flow control window has been increased, server can write more data.
1034 let written2 = server.stream_send(stream_id, &[0x0; 10000]).unwrap();
1035 if RECV_BUFFER_START < new_fc {
1036 assert_eq!(u64::try_from(written2).unwrap(), new_fc - RECV_BUFFER_START);
1037 } else {
1038 assert_eq!(written2, 0);
1039 }
1040
1041 // Exchange packets so that client gets all data.
1042 let out4 = client.process(out3.dgram(), now());
1043 let out5 = server.process(out4.dgram(), now());
1044 drop(client.process(out5.dgram(), now()));
1045
1046 // read all data by client
1047 let mut buf = [0x0; 10000];
1048 let (read, _) = client.stream_recv(stream_id, &mut buf).unwrap();
1049 assert_eq!(u64::try_from(read).unwrap(), max(RECV_BUFFER_START, new_fc));
1050
1051 let out4 = client.process_output(now());
1052 drop(server.process(out4.dgram(), now()));
1053
1054 let written3 = server.stream_send(stream_id, &[0x0; 10000]).unwrap();
1055 assert_eq!(u64::try_from(written3).unwrap(), new_fc);
1056 }
1057
1058 #[test]
1059 fn increase_decrease_flow_control() {
1060 const RECV_BUFFER_NEW_BIGGER: u64 = 400;
1061 const RECV_BUFFER_NEW_SMALLER: u64 = 200;
1062
1063 change_flow_control(StreamType::UniDi, RECV_BUFFER_NEW_BIGGER);
1064 change_flow_control(StreamType::BiDi, RECV_BUFFER_NEW_BIGGER);
1065
1066 change_flow_control(StreamType::UniDi, RECV_BUFFER_NEW_SMALLER);
1067 change_flow_control(StreamType::BiDi, RECV_BUFFER_NEW_SMALLER);
1068 }
1069
1070 #[test]
1071 fn session_flow_control_stop_sending_state_recv() {
1072 const SMALL_MAX_DATA: usize = 1024;
1073
1074 let mut client = default_client();
1075 let mut server = new_server(
1076 ConnectionParameters::default().max_data(u64::try_from(SMALL_MAX_DATA).unwrap()),
1077 );
1078
1079 connect(&mut client, &mut server);
1080
1081 let stream_id = client.stream_create(StreamType::UniDi).unwrap();
1082 assert_eq!(
1083 client.stream_avail_send_space(stream_id).unwrap(),
1084 SMALL_MAX_DATA
1085 );
1086
1087 // send 1 byte so that the server learns about the stream.
1088 assert_eq!(client.stream_send(stream_id, b"a").unwrap(), 1);
1089
1090 exchange_data(&mut client, &mut server);
1091
1092 server
1093 .stream_stop_sending(stream_id, Error::NoError.code())
1094 .unwrap();
1095
1096 assert_eq!(
1097 client
1098 .stream_send(stream_id, &[b'a'; SMALL_MAX_DATA])
1099 .unwrap(),
1100 SMALL_MAX_DATA - 1
1101 );
1102
1103 // In this case the final size is only known after RESET frame is received.
1104 // The server sends STOP_SENDING -> the client sends RESET -> the server
1105 // sends MAX_DATA.
1106 let out = server.process_output(now()).dgram();
1107 let out = client.process(out, now()).dgram();
1108 // the client is still limited.
1109 let stream_id2 = client.stream_create(StreamType::UniDi).unwrap();
1110 assert_eq!(client.stream_avail_send_space(stream_id2).unwrap(), 0);
1111 let out = server.process(out, now()).dgram();
1112 client.process_input(out.unwrap(), now());
1113 assert_eq!(
1114 client.stream_avail_send_space(stream_id2).unwrap(),
1115 SMALL_MAX_DATA
1116 );
1117 }
1118
1119 #[test]
1120 fn session_flow_control_stop_sending_state_size_known() {
1121 const SMALL_MAX_DATA: usize = 1024;
1122
1123 let mut client = default_client();
1124 let mut server = new_server(
1125 ConnectionParameters::default().max_data(u64::try_from(SMALL_MAX_DATA).unwrap()),
1126 );
1127
1128 connect(&mut client, &mut server);
1129
1130 let stream_id = client.stream_create(StreamType::UniDi).unwrap();
1131 assert_eq!(
1132 client.stream_avail_send_space(stream_id).unwrap(),
1133 SMALL_MAX_DATA
1134 );
1135
1136 // send 1 byte so that the server learns about the stream.
1137 assert_eq!(
1138 client
1139 .stream_send(stream_id, &[b'a'; SMALL_MAX_DATA + 1])
1140 .unwrap(),
1141 SMALL_MAX_DATA
1142 );
1143
1144 let out1 = client.process_output(now()).dgram();
1145 // Delay this packet and let the server receive fin first (it will enter SizeKnown state).
1146 client.stream_close_send(stream_id).unwrap();
1147 let out2 = client.process_output(now()).dgram();
1148
1149 server.process_input(out2.unwrap(), now());
1150
1151 server
1152 .stream_stop_sending(stream_id, Error::NoError.code())
1153 .unwrap();
1154
1155 // In this case the final size is known when stream_stop_sending is called
1156 // and the server releases flow control immediately and sends STOP_SENDING and
1157 // MAX_DATA in the same packet.
1158 let out = server.process(out1, now()).dgram();
1159 client.process_input(out.unwrap(), now());
1160
1161 // The flow control should have been updated and the client can again send
1162 // SMALL_MAX_DATA.
1163 let stream_id2 = client.stream_create(StreamType::UniDi).unwrap();
1164 assert_eq!(
1165 client.stream_avail_send_space(stream_id2).unwrap(),
1166 SMALL_MAX_DATA
1167 );
1168 }
1169
1170 #[test]
1171 fn session_flow_control_stop_sending_state_data_recvd() {
1172 const SMALL_MAX_DATA: usize = 1024;
1173
1174 let mut client = default_client();
1175 let mut server = new_server(
1176 ConnectionParameters::default().max_data(u64::try_from(SMALL_MAX_DATA).unwrap()),
1177 );
1178
1179 connect(&mut client, &mut server);
1180
1181 let stream_id = client.stream_create(StreamType::UniDi).unwrap();
1182 assert_eq!(
1183 client.stream_avail_send_space(stream_id).unwrap(),
1184 SMALL_MAX_DATA
1185 );
1186
1187 // send 1 byte so that the server learns about the stream.
1188 assert_eq!(
1189 client
1190 .stream_send(stream_id, &[b'a'; SMALL_MAX_DATA + 1])
1191 .unwrap(),
1192 SMALL_MAX_DATA
1193 );
1194
1195 client.stream_close_send(stream_id).unwrap();
1196
1197 exchange_data(&mut client, &mut server);
1198
1199 // The stream is DataRecvd state
1200 server
1201 .stream_stop_sending(stream_id, Error::NoError.code())
1202 .unwrap();
1203
1204 exchange_data(&mut client, &mut server);
1205
1206 // The flow control should have been updated and the client can again send
1207 // SMALL_MAX_DATA.
1208 let stream_id2 = client.stream_create(StreamType::UniDi).unwrap();
1209 assert_eq!(
1210 client.stream_avail_send_space(stream_id2).unwrap(),
1211 SMALL_MAX_DATA
1212 );
1213 }
1214
1215 #[test]
1216 fn session_flow_control_affects_all_streams() {
1217 const SMALL_MAX_DATA: usize = 1024;
1218
1219 let mut client = default_client();
1220 let mut server = new_server(
1221 ConnectionParameters::default().max_data(u64::try_from(SMALL_MAX_DATA).unwrap()),
1222 );
1223
1224 connect(&mut client, &mut server);
1225
1226 let stream_id = client.stream_create(StreamType::UniDi).unwrap();
1227 assert_eq!(
1228 client.stream_avail_send_space(stream_id).unwrap(),
1229 SMALL_MAX_DATA
1230 );
1231
1232 let stream_id2 = client.stream_create(StreamType::UniDi).unwrap();
1233 assert_eq!(
1234 client.stream_avail_send_space(stream_id2).unwrap(),
1235 SMALL_MAX_DATA
1236 );
1237
1238 assert_eq!(
1239 client
1240 .stream_send(stream_id, &[b'a'; SMALL_MAX_DATA / 2 + 1])
1241 .unwrap(),
1242 SMALL_MAX_DATA / 2 + 1
1243 );
1244
1245 assert_eq!(
1246 client.stream_avail_send_space(stream_id).unwrap(),
1247 SMALL_MAX_DATA / 2 - 1
1248 );
1249 assert_eq!(
1250 client.stream_avail_send_space(stream_id2).unwrap(),
1251 SMALL_MAX_DATA / 2 - 1
1252 );
1253
1254 exchange_data(&mut client, &mut server);
1255
1256 let mut buf = [0x0; SMALL_MAX_DATA];
1257 let (read, _) = server.stream_recv(stream_id, &mut buf).unwrap();
1258 assert_eq!(read, SMALL_MAX_DATA / 2 + 1);
1259
1260 exchange_data(&mut client, &mut server);
1261
1262 assert_eq!(
1263 client.stream_avail_send_space(stream_id).unwrap(),
1264 SMALL_MAX_DATA
1265 );
1266
1267 assert_eq!(
1268 client.stream_avail_send_space(stream_id2).unwrap(),
1269 SMALL_MAX_DATA
1270 );
1271 }
1272
1273 fn connect_w_different_limit(bidi_limit: u64, unidi_limit: u64) {
1274 let mut client = default_client();
1275 let out = client.process_output(now());
1276 let out2 = client.process_output(now());
1277 let mut server = new_server(
1278 ConnectionParameters::default()
1279 .max_streams(StreamType::BiDi, bidi_limit)
1280 .max_streams(StreamType::UniDi, unidi_limit),
1281 );
1282 server.process_input(out.dgram().unwrap(), now());
1283 let out = server.process(out2.dgram(), now());
1284
1285 let out = client.process(out.dgram(), now());
1286 let out = server.process(out.dgram(), now());
1287 let out = client.process(out.dgram(), now());
1288 drop(server.process(out.dgram(), now()));
1289
1290 assert!(maybe_authenticate(&mut client));
1291
1292 let mut bidi_events = 0;
1293 let mut unidi_events = 0;
1294 let mut connected_events = 0;
1295 for e in client.events() {
1296 match e {
1297 ConnectionEvent::SendStreamCreatable { stream_type } => {
1298 if stream_type == StreamType::BiDi {
1299 bidi_events += 1;
1300 } else {
1301 unidi_events += 1;
1302 }
1303 }
1304 ConnectionEvent::StateChange(State::Connected) => {
1305 connected_events += 1;
1306 }
1307 _ => {}
1308 }
1309 }
1310 assert_eq!(bidi_events, usize::from(bidi_limit > 0));
1311 assert_eq!(unidi_events, usize::from(unidi_limit > 0));
1312 assert_eq!(connected_events, 1);
1313 }
1314
1315 #[test]
1316 fn client_stream_creatable_event() {
1317 connect_w_different_limit(0, 0);
1318 connect_w_different_limit(0, 1);
1319 connect_w_different_limit(1, 0);
1320 connect_w_different_limit(1, 1);
1321 }