1use std::cmp;
28
29use std::collections::BTreeMap;
30use std::collections::VecDeque;
31
32use std::time::Duration;
33use std::time::Instant;
34
35use crate::stream::RecvAction;
36use crate::stream::RecvBufResetReturn;
37use crate::Error;
38use crate::Result;
39
40use crate::flowcontrol;
41
42use crate::range_buf::RangeBuf;
43
44#[derive(Debug, Default)]
50pub struct RecvBuf {
51 data: BTreeMap<u64, RangeBuf>,
54
55 off: u64,
57
58 len: u64,
60
61 flow_control: flowcontrol::FlowControl,
63
64 fin_off: Option<u64>,
66
67 error: Option<u64>,
69
70 drain: bool,
72}
73
74impl RecvBuf {
75 pub fn new(max_data: u64, initial_window: u64, max_window: u64) -> RecvBuf {
77 RecvBuf {
78 flow_control: flowcontrol::FlowControl::new(
79 max_data,
80 initial_window,
81 max_window,
82 ),
83 ..RecvBuf::default()
84 }
85 }
86
87 pub fn write(&mut self, mut buf: RangeBuf) -> Result<()> {
93 if buf.max_off() > self.max_data() {
94 return Err(Error::FlowControl);
95 }
96
97 if let Some(fin_off) = self.fin_off {
98 if buf.max_off() > fin_off {
100 return Err(Error::FinalSize);
101 }
102
103 if buf.fin() && fin_off != buf.max_off() {
105 return Err(Error::FinalSize);
106 }
107 }
108
109 if buf.fin() && buf.max_off() < self.len {
111 return Err(Error::FinalSize);
112 }
113
114 if self.fin_off.is_some() && buf.is_empty() {
117 return Ok(());
118 }
119
120 let new_fin = buf.fin() && self.fin_off.is_none();
121
122 if new_fin {
123 self.fin_off = Some(buf.max_off());
124 }
125
126 if !buf.fin() && buf.is_empty() {
130 self.len = cmp::max(self.len, buf.max_off());
131
132 if self.drain {
133 self.off = self.len;
135 }
136
137 return Ok(());
138 }
139
140 if self.off >= buf.max_off() && !buf.is_empty() {
145 if !new_fin {
146 return Ok(());
147 }
148
149 buf = RangeBuf::from(b"", buf.max_off(), true);
150 }
151
152 let mut tmp_bufs = VecDeque::with_capacity(2);
153 tmp_bufs.push_back(buf);
154
155 'tmp: while let Some(mut buf) = tmp_bufs.pop_front() {
156 if self.off_front() > buf.off() {
162 buf = buf.split_off((self.off_front() - buf.off()) as usize);
163 }
164
165 if buf.off() < self.max_off() || buf.is_empty() {
172 for (_, b) in self.data.range(buf.off()..) {
173 let off = buf.off();
174
175 if b.off() > buf.max_off() {
177 break;
178 }
179
180 if off >= b.off() && buf.max_off() <= b.max_off() {
182 continue 'tmp;
183 }
184
185 if off >= b.off() && off < b.max_off() {
187 buf = buf.split_off((b.max_off() - off) as usize);
188 }
189
190 if off < b.off() && buf.max_off() > b.off() {
192 tmp_bufs
193 .push_back(buf.split_off((b.off() - off) as usize));
194 }
195 }
196 }
197
198 self.len = cmp::max(self.len, buf.max_off());
199
200 if !self.drain {
201 self.data.insert(buf.max_off(), buf);
202 } else {
203 self.off = self.len;
205 }
206 }
207
208 Ok(())
209 }
210
211 #[inline]
222 pub fn emit(&mut self, mut out: &mut [u8]) -> Result<(usize, bool)> {
223 self.emit_or_discard(RecvAction::Emit { out: &mut out })
224 }
225
226 pub fn emit_or_discard<B: bytes::BufMut>(
241 &mut self, mut action: RecvAction<B>,
242 ) -> Result<(usize, bool)> {
243 let mut len = 0;
244 let mut cap = match &action {
245 RecvAction::Emit { out } => out.remaining_mut(),
246 RecvAction::Discard { len } => *len,
247 };
248
249 if !self.ready() {
250 return Err(Error::Done);
251 }
252
253 if let Some(e) = self.error {
256 self.data.clear();
257 return Err(Error::StreamReset(e));
258 }
259
260 while self.ready() {
261 let mut entry = match self.data.first_entry() {
262 Some(entry) => entry,
263 None => break,
264 };
265
266 let buf = entry.get_mut();
267
268 if cap == 0 && !buf.is_empty() {
269 break;
270 }
271
272 let buf_len = cmp::min(buf.len(), cap);
273
274 if let RecvAction::Emit { ref mut out } = action {
276 debug_assert!(
281 cap <= out.remaining_mut(),
282 "We updated `cap` incorrectly"
283 );
284 out.put_slice(&buf[..buf_len])
285 }
286
287 self.off += buf_len as u64;
288
289 len += buf_len;
290 cap -= buf_len;
291
292 if buf_len < buf.len() {
293 buf.consume(buf_len);
294
295 break;
297 }
298
299 entry.remove();
300 }
301
302 self.flow_control.add_consumed(len as u64);
304
305 Ok((len, self.is_fin()))
306 }
307
308 pub fn reset(
310 &mut self, error_code: u64, final_size: u64,
311 ) -> Result<RecvBufResetReturn> {
312 if let Some(fin_off) = self.fin_off {
314 if fin_off != final_size {
315 return Err(Error::FinalSize);
316 }
317 }
318
319 if final_size < self.len {
321 return Err(Error::FinalSize);
322 }
323
324 if final_size > self.max_data() {
325 return Err(Error::FlowControl);
326 }
327
328 if self.error.is_some() {
329 return Ok(RecvBufResetReturn::zero());
331 }
332
333 let result = RecvBufResetReturn {
336 max_data_delta: final_size - self.len,
337 consumed_flowcontrol: final_size - self.off,
338 };
339
340 let notify = !self.drain && (!self.is_fin() || self.ready());
341
342 self.error = Some(error_code);
343 self.fin_off = Some(final_size);
344 self.len = final_size;
345
346 self.off = final_size;
348
349 self.data.clear();
350
351 if notify {
354 let buf = RangeBuf::from(b"", final_size, true);
355 self.data.insert(final_size, buf);
356 }
357
358 Ok(result)
359 }
360
361 pub fn update_max_data(&mut self, now: Instant) {
363 self.flow_control.update_max_data(now);
364 }
365
366 pub fn max_data_next(&mut self) -> u64 {
368 self.flow_control.max_data_next()
369 }
370
371 pub fn max_data(&self) -> u64 {
373 self.flow_control.max_data()
374 }
375
376 pub fn window(&self) -> u64 {
378 self.flow_control.window()
379 }
380
381 pub fn autotune_window(&mut self, now: Instant, rtt: Duration) {
383 self.flow_control.autotune_window(now, rtt);
384 }
385
386 pub fn shutdown(&mut self) -> Result<u64> {
390 if self.drain {
391 return Err(Error::Done);
392 }
393
394 self.drain = true;
395
396 self.data.clear();
397
398 let consumed = self.max_off() - self.off;
399 self.off = self.max_off();
400
401 Ok(consumed)
402 }
403
404 pub fn off_front(&self) -> u64 {
406 self.off
407 }
408
409 pub fn almost_full(&self) -> bool {
411 self.fin_off.is_none() && self.flow_control.should_update_max_data()
412 }
413
414 pub fn max_off(&self) -> u64 {
416 self.len
417 }
418
419 pub fn is_fin(&self) -> bool {
424 self.fin_off == Some(self.off)
425 }
426
427 pub fn is_draining(&self) -> bool {
429 self.drain
430 }
431
432 pub fn ready(&self) -> bool {
434 let (_, buf) = match self.data.first_key_value() {
435 Some(v) => v,
436 None => return false,
437 };
438
439 buf.off() == self.off
440 }
441
442 pub fn readable_len(&self, max_len: usize) -> usize {
450 let mut contiguous = 0usize;
451 let mut next_off = self.off;
452
453 for buf in self.data.values() {
457 if buf.off() != next_off {
458 break;
459 }
460
461 contiguous = contiguous.saturating_add(buf.len()).min(max_len);
462 next_off = buf.max_off();
463
464 if contiguous == max_len {
465 break;
466 }
467 }
468
469 contiguous
470 }
471
472 #[cfg(test)]
473 pub(crate) fn flow_control_for_tests(&self) -> &flowcontrol::FlowControl {
474 &self.flow_control
475 }
476}
477
478#[cfg(test)]
479mod tests {
480 use super::*;
481
482 const DEFAULT_STREAM_WINDOW: u64 = 32 * 1024;
484 use bytes::BufMut as _;
485 use rstest::rstest;
486
487 fn assert_emit_discard(
505 recv: &mut RecvBuf, emit: bool, target_len: usize, result_len: usize,
506 is_fin: bool, test_bytes: Option<&[u8]>,
507 ) {
508 let mut buf = Vec::<u8>::with_capacity(512).limit(target_len);
509 let action = if emit {
510 RecvAction::Emit { out: &mut buf }
511 } else {
512 RecvAction::Discard { len: target_len }
513 };
514
515 let (read, fin) = recv.emit_or_discard(action).unwrap();
516
517 let buf = buf.into_inner();
518 if emit {
519 assert_eq!(buf.len(), read);
520 if let Some(v) = test_bytes {
521 assert_eq!(&buf, v);
522 }
523 }
524
525 assert_eq!(read, result_len);
526 assert_eq!(is_fin, fin);
527 }
528
529 fn assert_emit_discard_done(recv: &mut RecvBuf, emit: bool) {
531 let mut buf = [0u8; 32];
532 let action = if emit {
533 RecvAction::Emit {
534 out: &mut buf.as_mut_slice(),
535 }
536 } else {
537 RecvAction::Discard { len: 32 }
538 };
539 assert_eq!(recv.emit_or_discard(action), Err(Error::Done));
540 }
541
542 #[rstest]
543 fn empty_read(#[values(true, false)] emit: bool) {
544 let mut recv =
545 RecvBuf::new(u64::MAX, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
546 assert_eq!(recv.len, 0);
547
548 assert_emit_discard_done(&mut recv, emit);
549 }
550
551 #[rstest]
552 fn empty_stream_frame(#[values(true, false)] emit: bool) {
553 let mut recv =
554 RecvBuf::new(15, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
555 assert_eq!(recv.len, 0);
556
557 let buf = RangeBuf::from(b"hello", 0, false);
558 assert!(recv.write(buf).is_ok());
559 assert_eq!(recv.len, 5);
560 assert_eq!(recv.off, 0);
561 assert_eq!(recv.data.len(), 1);
562
563 assert_emit_discard(&mut recv, emit, 32, 5, false, None);
564
565 let buf = RangeBuf::from(b"", 10, false);
567 assert!(recv.write(buf).is_ok());
568 assert_eq!(recv.len, 10);
569 assert_eq!(recv.off, 5);
570 assert_eq!(recv.data.len(), 0);
571
572 let buf = RangeBuf::from(b"", 16, false);
574 assert_eq!(recv.write(buf), Err(Error::FlowControl));
575
576 let buf = RangeBuf::from(b"", 5, true);
579 assert_eq!(recv.write(buf), Err(Error::FinalSize));
580
581 let buf = RangeBuf::from(b"", 10, true);
583 assert!(recv.write(buf).is_ok());
584 assert_eq!(recv.len, 10);
585 assert_eq!(recv.off, 5);
586 assert_eq!(recv.data.len(), 1);
587
588 let buf = RangeBuf::from(b"", 10, true);
590 assert!(recv.write(buf).is_ok());
591 assert_eq!(recv.len, 10);
592 assert_eq!(recv.off, 5);
593 assert_eq!(recv.data.len(), 1);
594
595 let buf = RangeBuf::from(b"aa", 8, true);
597 assert!(recv.write(buf).is_ok());
598 assert_eq!(recv.len, 10);
599 assert_eq!(recv.off, 5);
600 assert_eq!(recv.data.len(), 1);
601
602 let buf = RangeBuf::from(b"aa", 3, true);
604 assert_eq!(recv.write(buf), Err(Error::FinalSize));
605
606 let buf = RangeBuf::from(b"", 11, true);
608 assert_eq!(recv.write(buf), Err(Error::FinalSize));
609 let buf = RangeBuf::from(b"", 9, true);
610 assert_eq!(recv.write(buf), Err(Error::FinalSize));
611
612 assert_emit_discard_done(&mut recv, emit);
615 }
616
617 #[rstest]
618 fn ordered_read(#[values(true, false)] emit: bool) {
619 let mut recv =
620 RecvBuf::new(u64::MAX, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
621 assert_eq!(recv.len, 0);
622
623 let first = RangeBuf::from(b"hello", 0, false);
624 let second = RangeBuf::from(b"world", 5, false);
625 let third = RangeBuf::from(b"something", 10, true);
626
627 assert!(recv.write(second).is_ok());
628 assert_eq!(recv.len, 10);
629 assert_eq!(recv.off, 0);
630
631 assert_emit_discard_done(&mut recv, emit);
632
633 assert!(recv.write(third).is_ok());
634 assert_eq!(recv.len, 19);
635 assert_eq!(recv.off, 0);
636
637 assert_emit_discard_done(&mut recv, emit);
638
639 assert!(recv.write(first).is_ok());
640 assert_eq!(recv.len, 19);
641 assert_eq!(recv.off, 0);
642
643 assert_emit_discard(
644 &mut recv,
645 emit,
646 32,
647 19,
648 true,
649 Some(b"helloworldsomething"),
650 );
651 assert_eq!(recv.len, 19);
652 assert_eq!(recv.off, 19);
653
654 assert_emit_discard_done(&mut recv, emit);
655 }
656
657 #[test]
658 fn readable_len() {
660 let mut recv =
661 RecvBuf::new(u64::MAX, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
662
663 assert_eq!(recv.readable_len(64 * 1024), 0);
665
666 assert!(recv.write(RangeBuf::from(b"hello", 0, false)).is_ok());
668 assert!(recv.write(RangeBuf::from(b"something", 10, false)).is_ok());
669 assert_eq!(recv.readable_len(64 * 1024), 5);
670
671 assert!(recv.write(RangeBuf::from(b"world", 5, false)).is_ok());
673 assert_eq!(recv.readable_len(64 * 1024), 19);
674 assert_eq!(recv.readable_len(10), 10);
675 }
676
677 #[rstest]
679 fn shutdown(#[values(true, false)] emit: bool) {
680 let mut recv =
681 RecvBuf::new(u64::MAX, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
682 assert_eq!(recv.len, 0);
683
684 let first = RangeBuf::from(b"hello", 0, false);
685 let second = RangeBuf::from(b"world", 5, false);
686 let third = RangeBuf::from(b"something", 10, false);
687
688 assert!(recv.write(second).is_ok());
689 assert_eq!(recv.len, 10);
690 assert_eq!(recv.off, 0);
691
692 assert_emit_discard_done(&mut recv, emit);
693
694 assert_eq!(recv.shutdown(), Ok(10));
696 assert_eq!(recv.len, 10);
697 assert_eq!(recv.off, 10);
698 assert_eq!(recv.data.len(), 0);
699
700 assert_emit_discard_done(&mut recv, emit);
701
702 assert!(recv.write(first).is_ok());
704 assert_eq!(recv.len, 10);
705 assert_eq!(recv.off, 10);
706 assert_eq!(recv.data.len(), 0);
707
708 assert!(recv.write(third).is_ok());
711 assert_eq!(recv.len, 19);
712 assert_eq!(recv.off, 19);
713 assert_eq!(recv.data.len(), 0);
714
715 assert_emit_discard_done(&mut recv, emit);
717 assert_eq!(
718 recv.reset(42, 123),
719 Ok(RecvBufResetReturn {
720 max_data_delta: 104,
721 consumed_flowcontrol: 104,
722 })
723 );
724 assert_eq!(recv.len, 123);
725 assert_eq!(recv.off, 123);
726 assert_eq!(recv.data.len(), 0);
727
728 assert_emit_discard_done(&mut recv, emit);
729 }
730
731 #[test]
735 fn shutdown_empty_stream_frame() {
736 let mut recv =
737 RecvBuf::new(u64::MAX, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
738
739 assert!(recv.write(RangeBuf::from(b"hello", 0, false)).is_ok());
740 assert_eq!(recv.shutdown(), Ok(5));
741
742 assert!(recv.write(RangeBuf::from(b"", 10, false)).is_ok());
743 assert_eq!(recv.len, 10);
744 assert_eq!(recv.off, 10);
745 assert_eq!(recv.data.len(), 0);
746
747 assert_eq!(
748 recv.reset(42, 10),
749 Ok(RecvBufResetReturn {
750 max_data_delta: 0,
751 consumed_flowcontrol: 0,
752 })
753 );
754 }
755
756 #[rstest]
757 fn reset_after_fin(
758 #[values("unread", "partial", "gap", "empty", "consumed", "draining")]
759 state: &str,
760 ) {
761 let mut recv =
762 RecvBuf::new(15, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
763 let mut out = [0; 5];
764 let (data, offset) = if state == "gap" {
765 (b"llo".as_slice(), 2)
766 } else {
767 (b"hello".as_slice(), 0)
768 };
769 recv.write(RangeBuf::from(data, offset, state != "empty"))
770 .unwrap();
771
772 match state {
773 "partial" => assert_eq!(recv.emit(&mut out[..2]), Ok((2, false))),
774 "consumed" => assert_eq!(recv.emit(&mut out), Ok((5, true))),
775 "empty" => {
776 assert_eq!(recv.emit(&mut out), Ok((5, false)));
777 recv.write(RangeBuf::from(b"", 5, true)).unwrap();
778 },
779 "draining" => assert_eq!(recv.shutdown(), Ok(5)),
780 _ => (),
781 }
782
783 let consumed = 5 - recv.off_front();
784 assert_eq!(
785 recv.reset(42, 5),
786 Ok(RecvBufResetReturn {
787 max_data_delta: 0,
788 consumed_flowcontrol: consumed,
789 })
790 );
791 assert!(recv.is_fin());
792 assert_eq!(recv.max_off(), 5);
793 assert_eq!(recv.ready(), state != "consumed" && state != "draining");
794 if recv.ready() {
795 assert_eq!(recv.emit(&mut out), Err(Error::StreamReset(42)));
796 }
797 assert_eq!(recv.emit(&mut out), Err(Error::Done));
798 assert_eq!(recv.reset(42, 5), Ok(RecvBufResetReturn::zero()));
799 recv.write(RangeBuf::from(b"hello", 0, true)).unwrap();
800 assert!(!recv.ready());
801 }
802
803 #[rstest]
804 fn duplicate_data_first_fin(#[values(true, false)] drain: bool) {
805 let mut recv =
806 RecvBuf::new(15, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
807 let mut out = [0; 5];
808 recv.write(RangeBuf::from(b"hello", 0, false)).unwrap();
809 assert_eq!(recv.emit(&mut out), Ok((5, false)));
810 if drain {
811 assert_eq!(recv.shutdown(), Ok(0));
812 }
813
814 recv.write(RangeBuf::from(b"hello", 0, false)).unwrap();
815 assert!(!recv.ready());
816 recv.write(RangeBuf::from(b"hello", 0, true)).unwrap();
817 assert!(recv.is_fin());
818 assert_eq!(recv.ready(), !drain);
819 assert!(recv.data.values().all(|buf| buf.data.as_ref().is_empty()));
820 if !drain {
821 assert_eq!(recv.emit(&mut out), Ok((0, true)));
822 }
823
824 recv.write(RangeBuf::from(b"hello", 0, true)).unwrap();
825 recv.write(RangeBuf::from(b"", 5, true)).unwrap();
826 assert!(!recv.ready());
827 assert_eq!(recv.emit(&mut out), Err(Error::Done));
828 }
829
830 #[rstest]
831 fn split_read(#[values(true, false)] emit: bool) {
832 let mut recv =
833 RecvBuf::new(u64::MAX, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
834 assert_eq!(recv.len, 0);
835
836 let first = RangeBuf::from(b"something", 0, false);
837 let second = RangeBuf::from(b"helloworld", 9, true);
838
839 assert!(recv.write(first).is_ok());
840 assert_eq!(recv.len, 9);
841 assert_eq!(recv.off, 0);
842
843 assert!(recv.write(second).is_ok());
844 assert_eq!(recv.len, 19);
845 assert_eq!(recv.off, 0);
846
847 assert_emit_discard(&mut recv, emit, 10, 10, false, Some(b"somethingh"));
848 assert_eq!(recv.len, 19);
849 assert_eq!(recv.off, 10);
850
851 assert_emit_discard(&mut recv, emit, 5, 5, false, Some(b"ellow"));
852 assert_eq!(recv.len, 19);
853 assert_eq!(recv.off, 15);
854
855 assert_emit_discard(&mut recv, emit, 5, 4, true, Some(b"orld"));
856 assert_eq!(recv.len, 19);
857 assert_eq!(recv.off, 19);
858 }
859
860 #[test]
861 fn split_read_incremental_buf() {
862 let mut recv =
863 RecvBuf::new(u64::MAX, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
864 assert_eq!(recv.len, 0);
865
866 let first = RangeBuf::from(b"something", 0, false);
867 let second = RangeBuf::from(b"helloworld", 9, true);
868
869 assert!(recv.write(first).is_ok());
870 assert_eq!(recv.len, 9);
871 assert_eq!(recv.off, 0);
872
873 assert!(recv.write(second).is_ok());
874 assert_eq!(recv.len, 19);
875 assert_eq!(recv.off, 0);
876
877 let mut buf = Vec::new().limit(10);
878 assert_eq!(
879 recv.emit_or_discard(RecvAction::Emit { out: &mut buf }),
880 Ok((10, false))
881 );
882 assert_eq!(recv.len, 19);
883 assert_eq!(recv.off, 10);
884 assert_eq!(buf.get_ref().len(), 10);
885 assert_eq!(buf.get_ref().as_slice(), b"somethingh");
886
887 buf.set_limit(5);
888 assert_eq!(
889 recv.emit_or_discard(RecvAction::Emit { out: &mut buf }),
890 Ok((5, false))
891 );
892 assert_eq!(recv.len, 19);
893 assert_eq!(recv.off, 15);
894 assert_eq!(buf.get_ref().len(), 15);
895 assert_eq!(buf.get_ref().as_slice(), b"somethinghellow");
896
897 buf.set_limit(42);
898 assert_eq!(
899 recv.emit_or_discard(RecvAction::Emit { out: &mut buf }),
900 Ok((4, true))
901 );
902 assert_eq!(recv.len, 19);
903 assert_eq!(recv.off, 19);
904 assert_eq!(buf.get_ref().len(), 19);
905 assert_eq!(buf.get_ref().as_slice(), b"somethinghelloworld");
906 }
907
908 #[rstest]
909 fn incomplete_read(#[values(true, false)] emit: bool) {
910 let mut recv =
911 RecvBuf::new(u64::MAX, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
912 assert_eq!(recv.len, 0);
913
914 let mut buf = [0u8; 32];
915
916 let first = RangeBuf::from(b"something", 0, false);
917 let second = RangeBuf::from(b"helloworld", 9, true);
918
919 assert!(recv.write(second).is_ok());
920 assert_eq!(recv.len, 19);
921 assert_eq!(recv.off, 0);
922
923 let action = if emit {
924 RecvAction::Emit {
925 out: &mut buf.as_mut_slice(),
926 }
927 } else {
928 RecvAction::Discard { len: 32 }
929 };
930 assert_eq!(recv.emit_or_discard(action), Err(Error::Done));
931
932 assert!(recv.write(first).is_ok());
933 assert_eq!(recv.len, 19);
934 assert_eq!(recv.off, 0);
935
936 assert_emit_discard(
937 &mut recv,
938 emit,
939 32,
940 19,
941 true,
942 Some(b"somethinghelloworld"),
943 );
944 assert_eq!(recv.len, 19);
945 assert_eq!(recv.off, 19);
946 }
947
948 #[rstest]
949 fn zero_len_read(#[values(true, false)] emit: bool) {
950 let mut recv =
951 RecvBuf::new(u64::MAX, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
952 assert_eq!(recv.len, 0);
953
954 let first = RangeBuf::from(b"something", 0, false);
955 let second = RangeBuf::from(b"", 9, true);
956
957 assert!(recv.write(first).is_ok());
958 assert_eq!(recv.len, 9);
959 assert_eq!(recv.off, 0);
960 assert_eq!(recv.data.len(), 1);
961
962 assert!(recv.write(second).is_ok());
963 assert_eq!(recv.len, 9);
964 assert_eq!(recv.off, 0);
965 assert_eq!(recv.data.len(), 1);
966
967 assert_emit_discard(&mut recv, emit, 32, 9, true, Some(b"something"));
968 assert_eq!(recv.len, 9);
969 assert_eq!(recv.off, 9);
970 }
971
972 #[rstest]
973 fn past_read(#[values(true, false)] emit: bool) {
974 let mut recv =
975 RecvBuf::new(u64::MAX, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
976 assert_eq!(recv.len, 0);
977
978 let first = RangeBuf::from(b"something", 0, false);
979 let second = RangeBuf::from(b"hello", 3, false);
980 let third = RangeBuf::from(b"ello", 4, true);
981 let fourth = RangeBuf::from(b"ello", 5, true);
982
983 assert!(recv.write(first).is_ok());
984 assert_eq!(recv.len, 9);
985 assert_eq!(recv.off, 0);
986 assert_eq!(recv.data.len(), 1);
987
988 assert_emit_discard(&mut recv, emit, 32, 9, false, Some(b"something"));
989 assert_eq!(recv.len, 9);
990 assert_eq!(recv.off, 9);
991
992 assert!(recv.write(second).is_ok());
993 assert_eq!(recv.len, 9);
994 assert_eq!(recv.off, 9);
995 assert_eq!(recv.data.len(), 0);
996
997 assert_eq!(recv.write(third), Err(Error::FinalSize));
998
999 assert!(recv.write(fourth).is_ok());
1000 assert_eq!(recv.len, 9);
1001 assert_eq!(recv.off, 9);
1002 assert_eq!(recv.data.len(), 1);
1003
1004 assert_emit_discard(&mut recv, emit, 32, 0, true, Some(b""));
1005 assert_emit_discard_done(&mut recv, emit);
1006 }
1007
1008 #[rstest]
1009 fn fully_overlapping_read(#[values(true, false)] emit: bool) {
1010 let mut recv =
1011 RecvBuf::new(u64::MAX, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
1012 assert_eq!(recv.len, 0);
1013
1014 let first = RangeBuf::from(b"something", 0, false);
1015 let second = RangeBuf::from(b"hello", 4, false);
1016
1017 assert!(recv.write(first).is_ok());
1018 assert_eq!(recv.len, 9);
1019 assert_eq!(recv.off, 0);
1020 assert_eq!(recv.data.len(), 1);
1021
1022 assert!(recv.write(second).is_ok());
1023 assert_eq!(recv.len, 9);
1024 assert_eq!(recv.off, 0);
1025 assert_eq!(recv.data.len(), 1);
1026
1027 assert_emit_discard(&mut recv, emit, 32, 9, false, Some(b"something"));
1028 assert_eq!(recv.len, 9);
1029 assert_eq!(recv.off, 9);
1030 assert_eq!(recv.data.len(), 0);
1031
1032 assert_emit_discard_done(&mut recv, emit);
1033 }
1034
1035 #[rstest]
1036 fn fully_overlapping_read2(#[values(true, false)] emit: bool) {
1037 let mut recv =
1038 RecvBuf::new(u64::MAX, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
1039 assert_eq!(recv.len, 0);
1040
1041 let first = RangeBuf::from(b"something", 0, false);
1042 let second = RangeBuf::from(b"hello", 4, false);
1043
1044 assert!(recv.write(second).is_ok());
1045 assert_eq!(recv.len, 9);
1046 assert_eq!(recv.off, 0);
1047 assert_eq!(recv.data.len(), 1);
1048
1049 assert!(recv.write(first).is_ok());
1050 assert_eq!(recv.len, 9);
1051 assert_eq!(recv.off, 0);
1052 assert_eq!(recv.data.len(), 2);
1053
1054 assert_emit_discard(&mut recv, emit, 32, 9, false, Some(b"somehello"));
1055 assert_eq!(recv.len, 9);
1056 assert_eq!(recv.off, 9);
1057 assert_eq!(recv.data.len(), 0);
1058
1059 assert_emit_discard_done(&mut recv, emit);
1060 }
1061
1062 #[rstest]
1063 fn fully_overlapping_read3(#[values(true, false)] emit: bool) {
1064 let mut recv =
1065 RecvBuf::new(u64::MAX, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
1066 assert_eq!(recv.len, 0);
1067
1068 let first = RangeBuf::from(b"something", 0, false);
1069 let second = RangeBuf::from(b"hello", 3, false);
1070
1071 assert!(recv.write(second).is_ok());
1072 assert_eq!(recv.len, 8);
1073 assert_eq!(recv.off, 0);
1074 assert_eq!(recv.data.len(), 1);
1075
1076 assert!(recv.write(first).is_ok());
1077 assert_eq!(recv.len, 9);
1078 assert_eq!(recv.off, 0);
1079 assert_eq!(recv.data.len(), 3);
1080
1081 assert_emit_discard(&mut recv, emit, 32, 9, false, Some(b"somhellog"));
1082 assert_eq!(recv.len, 9);
1083 assert_eq!(recv.off, 9);
1084 assert_eq!(recv.data.len(), 0);
1085
1086 assert_emit_discard_done(&mut recv, emit);
1087 }
1088
1089 #[rstest]
1090 fn fully_overlapping_read_multi(#[values(true, false)] emit: bool) {
1091 let mut recv =
1092 RecvBuf::new(u64::MAX, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
1093 assert_eq!(recv.len, 0);
1094
1095 let first = RangeBuf::from(b"somethingsomething", 0, false);
1096 let second = RangeBuf::from(b"hello", 3, false);
1097 let third = RangeBuf::from(b"hello", 12, false);
1098
1099 assert!(recv.write(second).is_ok());
1100 assert_eq!(recv.len, 8);
1101 assert_eq!(recv.off, 0);
1102 assert_eq!(recv.data.len(), 1);
1103
1104 assert!(recv.write(third).is_ok());
1105 assert_eq!(recv.len, 17);
1106 assert_eq!(recv.off, 0);
1107 assert_eq!(recv.data.len(), 2);
1108
1109 assert!(recv.write(first).is_ok());
1110 assert_eq!(recv.len, 18);
1111 assert_eq!(recv.off, 0);
1112 assert_eq!(recv.data.len(), 5);
1113
1114 assert_emit_discard(
1115 &mut recv,
1116 emit,
1117 32,
1118 18,
1119 false,
1120 Some(b"somhellogsomhellog"),
1121 );
1122 assert_eq!(recv.len, 18);
1123 assert_eq!(recv.off, 18);
1124 assert_eq!(recv.data.len(), 0);
1125
1126 assert_emit_discard_done(&mut recv, emit);
1127 }
1128
1129 #[rstest]
1130 fn overlapping_start_read(#[values(true, false)] emit: bool) {
1131 let mut recv =
1132 RecvBuf::new(u64::MAX, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
1133 assert_eq!(recv.len, 0);
1134
1135 let first = RangeBuf::from(b"something", 0, false);
1136 let second = RangeBuf::from(b"hello", 8, true);
1137
1138 assert!(recv.write(first).is_ok());
1139 assert_eq!(recv.len, 9);
1140 assert_eq!(recv.off, 0);
1141 assert_eq!(recv.data.len(), 1);
1142
1143 assert!(recv.write(second).is_ok());
1144 assert_eq!(recv.len, 13);
1145 assert_eq!(recv.off, 0);
1146 assert_eq!(recv.data.len(), 2);
1147
1148 assert_emit_discard(
1149 &mut recv,
1150 emit,
1151 32,
1152 13,
1153 true,
1154 Some(b"somethingello"),
1155 );
1156
1157 assert_eq!(recv.len, 13);
1158 assert_eq!(recv.off, 13);
1159
1160 assert_emit_discard_done(&mut recv, emit);
1161 }
1162
1163 #[rstest]
1164 fn overlapping_end_read(#[values(true, false)] emit: bool) {
1165 let mut recv =
1166 RecvBuf::new(u64::MAX, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
1167 assert_eq!(recv.len, 0);
1168
1169 let first = RangeBuf::from(b"hello", 0, false);
1170 let second = RangeBuf::from(b"something", 3, true);
1171
1172 assert!(recv.write(second).is_ok());
1173 assert_eq!(recv.len, 12);
1174 assert_eq!(recv.off, 0);
1175 assert_eq!(recv.data.len(), 1);
1176
1177 assert!(recv.write(first).is_ok());
1178 assert_eq!(recv.len, 12);
1179 assert_eq!(recv.off, 0);
1180 assert_eq!(recv.data.len(), 2);
1181
1182 assert_emit_discard(&mut recv, emit, 32, 12, true, Some(b"helsomething"));
1183 assert_eq!(recv.len, 12);
1184 assert_eq!(recv.off, 12);
1185
1186 assert_emit_discard_done(&mut recv, emit);
1187 }
1188
1189 #[rstest]
1190 fn overlapping_end_twice_read(#[values(true, false)] emit: bool) {
1191 let mut recv =
1192 RecvBuf::new(u64::MAX, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
1193 assert_eq!(recv.len, 0);
1194
1195 let first = RangeBuf::from(b"he", 0, false);
1196 let second = RangeBuf::from(b"ow", 4, false);
1197 let third = RangeBuf::from(b"rl", 7, false);
1198 let fourth = RangeBuf::from(b"helloworld", 0, true);
1199
1200 assert!(recv.write(third).is_ok());
1201 assert_eq!(recv.len, 9);
1202 assert_eq!(recv.off, 0);
1203 assert_eq!(recv.data.len(), 1);
1204
1205 assert!(recv.write(second).is_ok());
1206 assert_eq!(recv.len, 9);
1207 assert_eq!(recv.off, 0);
1208 assert_eq!(recv.data.len(), 2);
1209
1210 assert!(recv.write(first).is_ok());
1211 assert_eq!(recv.len, 9);
1212 assert_eq!(recv.off, 0);
1213 assert_eq!(recv.data.len(), 3);
1214
1215 assert!(recv.write(fourth).is_ok());
1216 assert_eq!(recv.len, 10);
1217 assert_eq!(recv.off, 0);
1218 assert_eq!(recv.data.len(), 6);
1219
1220 assert_emit_discard(&mut recv, emit, 32, 10, true, Some(b"helloworld"));
1221 assert_eq!(recv.len, 10);
1222 assert_eq!(recv.off, 10);
1223
1224 assert_emit_discard_done(&mut recv, emit);
1225 }
1226
1227 #[rstest]
1228 fn overlapping_end_twice_and_contained_read(
1229 #[values(true, false)] emit: bool,
1230 ) {
1231 let mut recv =
1232 RecvBuf::new(u64::MAX, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
1233 assert_eq!(recv.len, 0);
1234
1235 let first = RangeBuf::from(b"hellow", 0, false);
1236 let second = RangeBuf::from(b"barfoo", 10, true);
1237 let third = RangeBuf::from(b"rl", 7, false);
1238 let fourth = RangeBuf::from(b"elloworldbarfoo", 1, true);
1239
1240 assert!(recv.write(third).is_ok());
1241 assert_eq!(recv.len, 9);
1242 assert_eq!(recv.off, 0);
1243 assert_eq!(recv.data.len(), 1);
1244
1245 assert!(recv.write(second).is_ok());
1246 assert_eq!(recv.len, 16);
1247 assert_eq!(recv.off, 0);
1248 assert_eq!(recv.data.len(), 2);
1249
1250 assert!(recv.write(first).is_ok());
1251 assert_eq!(recv.len, 16);
1252 assert_eq!(recv.off, 0);
1253 assert_eq!(recv.data.len(), 3);
1254
1255 assert!(recv.write(fourth).is_ok());
1256 assert_eq!(recv.len, 16);
1257 assert_eq!(recv.off, 0);
1258 assert_eq!(recv.data.len(), 5);
1259
1260 assert_emit_discard(
1261 &mut recv,
1262 emit,
1263 32,
1264 16,
1265 true,
1266 Some(b"helloworldbarfoo"),
1267 );
1268 assert_eq!(recv.len, 16);
1269 assert_eq!(recv.off, 16);
1270
1271 assert_emit_discard_done(&mut recv, emit);
1272 }
1273
1274 #[rstest]
1275 fn partially_multi_overlapping_reordered_read(
1276 #[values(true, false)] emit: bool,
1277 ) {
1278 let mut recv =
1279 RecvBuf::new(u64::MAX, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
1280 assert_eq!(recv.len, 0);
1281
1282 let first = RangeBuf::from(b"hello", 8, false);
1283 let second = RangeBuf::from(b"something", 0, false);
1284 let third = RangeBuf::from(b"moar", 11, true);
1285
1286 assert!(recv.write(first).is_ok());
1287 assert_eq!(recv.len, 13);
1288 assert_eq!(recv.off, 0);
1289 assert_eq!(recv.data.len(), 1);
1290
1291 assert!(recv.write(second).is_ok());
1292 assert_eq!(recv.len, 13);
1293 assert_eq!(recv.off, 0);
1294 assert_eq!(recv.data.len(), 2);
1295
1296 assert!(recv.write(third).is_ok());
1297 assert_eq!(recv.len, 15);
1298 assert_eq!(recv.off, 0);
1299 assert_eq!(recv.data.len(), 3);
1300
1301 assert_emit_discard(
1302 &mut recv,
1303 emit,
1304 32,
1305 15,
1306 true,
1307 Some(b"somethinhelloar"),
1308 );
1309 assert_eq!(recv.len, 15);
1310 assert_eq!(recv.off, 15);
1311 assert_eq!(recv.data.len(), 0);
1312
1313 assert_emit_discard_done(&mut recv, emit);
1314 }
1315
1316 #[rstest]
1317 fn partially_multi_overlapping_reordered_read2(
1318 #[values(true, false)] emit: bool,
1319 ) {
1320 let mut recv =
1321 RecvBuf::new(u64::MAX, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
1322 assert_eq!(recv.len, 0);
1323
1324 let first = RangeBuf::from(b"aaa", 0, false);
1325 let second = RangeBuf::from(b"bbb", 2, false);
1326 let third = RangeBuf::from(b"ccc", 4, false);
1327 let fourth = RangeBuf::from(b"ddd", 6, false);
1328 let fifth = RangeBuf::from(b"eee", 9, false);
1329 let sixth = RangeBuf::from(b"fff", 11, false);
1330
1331 assert!(recv.write(second).is_ok());
1332 assert_eq!(recv.len, 5);
1333 assert_eq!(recv.off, 0);
1334 assert_eq!(recv.data.len(), 1);
1335
1336 assert!(recv.write(fourth).is_ok());
1337 assert_eq!(recv.len, 9);
1338 assert_eq!(recv.off, 0);
1339 assert_eq!(recv.data.len(), 2);
1340
1341 assert!(recv.write(third).is_ok());
1342 assert_eq!(recv.len, 9);
1343 assert_eq!(recv.off, 0);
1344 assert_eq!(recv.data.len(), 3);
1345
1346 assert!(recv.write(first).is_ok());
1347 assert_eq!(recv.len, 9);
1348 assert_eq!(recv.off, 0);
1349 assert_eq!(recv.data.len(), 4);
1350
1351 assert!(recv.write(sixth).is_ok());
1352 assert_eq!(recv.len, 14);
1353 assert_eq!(recv.off, 0);
1354 assert_eq!(recv.data.len(), 5);
1355
1356 assert!(recv.write(fifth).is_ok());
1357 assert_eq!(recv.len, 14);
1358 assert_eq!(recv.off, 0);
1359 assert_eq!(recv.data.len(), 6);
1360
1361 assert_emit_discard(
1362 &mut recv,
1363 emit,
1364 32,
1365 14,
1366 false,
1367 Some(b"aabbbcdddeefff"),
1368 );
1369 assert_eq!(recv.len, 14);
1370 assert_eq!(recv.off, 14);
1371 assert_eq!(recv.data.len(), 0);
1372
1373 assert_emit_discard_done(&mut recv, emit);
1374 }
1375
1376 #[test]
1377 fn mixed_read_actions() {
1378 let mut recv =
1379 RecvBuf::new(u64::MAX, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
1380 assert_eq!(recv.len, 0);
1381
1382 let first = RangeBuf::from(b"hello", 0, false);
1383 let second = RangeBuf::from(b"world", 5, false);
1384 let third = RangeBuf::from(b"something", 10, true);
1385
1386 assert!(recv.write(second).is_ok());
1387 assert_eq!(recv.len, 10);
1388 assert_eq!(recv.off, 0);
1389
1390 assert_emit_discard_done(&mut recv, true);
1391 assert_emit_discard_done(&mut recv, false);
1392
1393 assert!(recv.write(third).is_ok());
1394 assert_eq!(recv.len, 19);
1395 assert_eq!(recv.off, 0);
1396
1397 assert_emit_discard_done(&mut recv, true);
1398 assert_emit_discard_done(&mut recv, false);
1399
1400 assert!(recv.write(first).is_ok());
1401 assert_eq!(recv.len, 19);
1402 assert_eq!(recv.off, 0);
1403
1404 assert_emit_discard(&mut recv, true, 5, 5, false, Some(b"hello"));
1405 assert_eq!(recv.len, 19);
1406 assert_eq!(recv.off, 5);
1407
1408 assert_emit_discard(&mut recv, false, 5, 5, false, None);
1409 assert_eq!(recv.len, 19);
1410 assert_eq!(recv.off, 10);
1411
1412 assert_emit_discard(&mut recv, true, 9, 9, true, Some(b"something"));
1413 assert_eq!(recv.len, 19);
1414 assert_eq!(recv.off, 19);
1415
1416 assert_emit_discard_done(&mut recv, true);
1417 assert_emit_discard_done(&mut recv, false);
1418 }
1419}