Skip to main content

quiche/stream/
recv_buf.rs

1// Copyright (C) 2023, Cloudflare, Inc.
2// All rights reserved.
3//
4// Redistribution and use in source and binary forms, with or without
5// modification, are permitted provided that the following conditions are
6// met:
7//
8//     * Redistributions of source code must retain the above copyright notice,
9//       this list of conditions and the following disclaimer.
10//
11//     * Redistributions in binary form must reproduce the above copyright
12//       notice, this list of conditions and the following disclaimer in the
13//       documentation and/or other materials provided with the distribution.
14//
15// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
16// IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
17// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
19// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
23// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
24// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26
27use 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/// Receive-side stream buffer.
45///
46/// Stream data received by the peer is buffered in a list of data chunks
47/// ordered by offset in ascending order. Contiguous data can then be read
48/// into a slice.
49#[derive(Debug, Default)]
50pub struct RecvBuf {
51    /// Chunks of data received from the peer that have not yet been read by
52    /// the application, ordered by offset.
53    data: BTreeMap<u64, RangeBuf>,
54
55    /// The lowest data offset that has yet to be read by the application.
56    off: u64,
57
58    /// The total length of data received on this stream.
59    len: u64,
60
61    /// Receiver flow controller.
62    flow_control: flowcontrol::FlowControl,
63
64    /// The final stream offset received from the peer, if any.
65    fin_off: Option<u64>,
66
67    /// The error code received via RESET_STREAM.
68    error: Option<u64>,
69
70    /// Whether incoming data is validated but not buffered.
71    drain: bool,
72}
73
74impl RecvBuf {
75    /// Creates a new receive buffer.
76    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    /// Inserts the given chunk of data in the buffer.
88    ///
89    /// This also takes care of enforcing stream flow control limits, as well
90    /// as handling incoming data that overlaps data that is already in the
91    /// buffer.
92    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            // Stream's size is known, forbid data beyond that point.
99            if buf.max_off() > fin_off {
100                return Err(Error::FinalSize);
101            }
102
103            // Stream's size is already known, forbid changing it.
104            if buf.fin() && fin_off != buf.max_off() {
105                return Err(Error::FinalSize);
106            }
107        }
108
109        // Stream's known size is lower than data already received.
110        if buf.fin() && buf.max_off() < self.len {
111            return Err(Error::FinalSize);
112        }
113
114        // We already saved the final offset, so there's nothing else we
115        // need to keep from the RangeBuf if it's empty.
116        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        // No need to store empty buffer that doesn't carry the fin flag, but
127        // its offset still advances the largest received offset used by flow
128        // control (RFC 9000 Section 19.8).
129        if !buf.fin() && buf.is_empty() {
130            self.len = cmp::max(self.len, buf.max_off());
131
132            if self.drain {
133                // we are not storing any data, off == len
134                self.off = self.len;
135            }
136
137            return Ok(());
138        }
139
140        // Discard consumed data unless it carries the first FIN. Such data is
141        // replaced with an empty buffer at the final size, so the application
142        // reads the FIN without receiving duplicate data and the queued buffer
143        // does not keep the duplicate payload alive.
144        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            // Discard incoming data below current stream offset. Bytes up to
157            // `self.off` have already been received so we should not buffer
158            // them again. This is also important to make sure `ready()` doesn't
159            // get stuck when a buffer with lower offset than the stream's is
160            // buffered.
161            if self.off_front() > buf.off() {
162                buf = buf.split_off((self.off_front() - buf.off()) as usize);
163            }
164
165            // Handle overlapping data. If the incoming data's starting offset
166            // is above the previous maximum received offset, there is clearly
167            // no overlap so this logic can be skipped. However do still try to
168            // merge an empty final buffer (i.e. an empty buffer with the fin
169            // flag set, which is the only kind of empty buffer that should
170            // reach this point).
171            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                    // We are past the current buffer.
176                    if b.off() > buf.max_off() {
177                        break;
178                    }
179
180                    // New buffer is fully contained in existing buffer.
181                    if off >= b.off() && buf.max_off() <= b.max_off() {
182                        continue 'tmp;
183                    }
184
185                    // New buffer's start overlaps existing buffer.
186                    if off >= b.off() && off < b.max_off() {
187                        buf = buf.split_off((b.max_off() - off) as usize);
188                    }
189
190                    // New buffer's end overlaps existing buffer.
191                    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                // we are not storing any data, off == len
204                self.off = self.len;
205            }
206        }
207
208        Ok(())
209    }
210
211    /// Reads contiguous data from the receive buffer.
212    ///
213    /// Data is written into the given `out` buffer, up to the length of `out`.
214    ///
215    /// Only contiguous data is removed, starting from offset 0. The offset is
216    /// incremented as data is taken out of the receive buffer. If there is no
217    /// data at the expected read offset, the `Done` error is returned.
218    ///
219    /// On success the amount of data read and a flag indicating
220    /// if there is no more data in the buffer, are returned as a tuple.
221    #[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    /// Reads or discards contiguous data from the receive buffer.
227    ///
228    /// Passing an `action` of `StreamRecvAction::Emit` results in data being
229    /// written into the provided buffer, up to its length.
230    ///
231    /// Passing an `action` of `StreamRecvAction::Discard` results in up to
232    /// the indicated number of bytes being discarded without copying.
233    ///
234    /// Only contiguous data is removed, starting from offset 0. The offset is
235    /// incremented as data is taken out of the receive buffer. If there is no
236    /// data at the expected read offset, the `Done` error is returned.
237    ///
238    /// On success the amount of data read or discarded, and a flag indicating
239    /// if there is no more data in the buffer, are returned as a tuple.
240    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        // The stream was reset, so clear its data and return the error code
254        // instead.
255        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            // Only copy data if we're emitting, not discarding.
275            if let RecvAction::Emit { ref mut out } = action {
276                // Note: `BufMut::remaining_mut()` cannot "shrink", but BufMut
277                // impls are allowed to grow the buffer, so we
278                // check here that we still have at least
279                // `cap` bytes, but we can't require equality
280                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                // We reached the maximum capacity, so end here.
296                break;
297            }
298
299            entry.remove();
300        }
301
302        // Update consumed bytes for flow control.
303        self.flow_control.add_consumed(len as u64);
304
305        Ok((len, self.is_fin()))
306    }
307
308    /// Resets the stream at the given offset.
309    pub fn reset(
310        &mut self, error_code: u64, final_size: u64,
311    ) -> Result<RecvBufResetReturn> {
312        // Stream's size is already known, forbid changing it.
313        if let Some(fin_off) = self.fin_off {
314            if fin_off != final_size {
315                return Err(Error::FinalSize);
316            }
317        }
318
319        // Stream's known size is lower than data already received.
320        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            // We already verified that the final size matches
330            return Ok(RecvBufResetReturn::zero());
331        }
332
333        // Calculate how many bytes need to be removed from the connection flow
334        // control.
335        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        // Clear all data already buffered.
347        self.off = final_size;
348
349        self.data.clear();
350
351        // Preserve an unread terminal notification even if FIN already
352        // established the final size, but do not notify again after EOF.
353        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    /// Commits the new max_data limit.
362    pub fn update_max_data(&mut self, now: Instant) {
363        self.flow_control.update_max_data(now);
364    }
365
366    /// Return the new max_data limit.
367    pub fn max_data_next(&mut self) -> u64 {
368        self.flow_control.max_data_next()
369    }
370
371    /// Return the current flow control limit.
372    pub fn max_data(&self) -> u64 {
373        self.flow_control.max_data()
374    }
375
376    /// Return the current window.
377    pub fn window(&self) -> u64 {
378        self.flow_control.window()
379    }
380
381    /// Autotune the window size.
382    pub fn autotune_window(&mut self, now: Instant, rtt: Duration) {
383        self.flow_control.autotune_window(now, rtt);
384    }
385
386    /// Shuts down receiving data and returns the number of bytes
387    /// that should be returned to the connection level flow
388    /// control
389    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    /// Returns the lowest offset of data buffered.
405    pub fn off_front(&self) -> u64 {
406        self.off
407    }
408
409    /// Returns true if we need to update the local flow control limit.
410    pub fn almost_full(&self) -> bool {
411        self.fin_off.is_none() && self.flow_control.should_update_max_data()
412    }
413
414    /// Returns the largest offset ever received.
415    pub fn max_off(&self) -> u64 {
416        self.len
417    }
418
419    /// Returns true if the receive-side of the stream is complete.
420    ///
421    /// This happens when the stream's receive final size is known, and the
422    /// application has read all data from the stream.
423    pub fn is_fin(&self) -> bool {
424        self.fin_off == Some(self.off)
425    }
426
427    /// Returns true if the stream is not storing incoming data.
428    pub fn is_draining(&self) -> bool {
429        self.drain
430    }
431
432    /// Returns true if the stream has data to be read.
433    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    /// Returns the number of bytes that can be read contiguously from the
443    /// current read offset, up to `max_len`.
444    ///
445    /// Data buffered behind a gap (received out of order) is not counted, so
446    /// this never reports bytes that are not yet readable. The cost is
447    /// proportional to the number of contiguous buffered chunks at the front
448    /// of the buffer, up to `max_len`; no data is copied.
449    pub fn readable_len(&self, max_len: usize) -> usize {
450        let mut contiguous = 0usize;
451        let mut next_off = self.off;
452
453        // `data` is ordered by offset, so walk from the front and stop at the
454        // first gap (a chunk that does not start where the contiguous run so
455        // far leaves off).
456        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    /// The default size of the receiver stream flow control window.
483    const DEFAULT_STREAM_WINDOW: u64 = 32 * 1024;
484    use bytes::BufMut as _;
485    use rstest::rstest;
486
487    // Helper function for testing either buffer emit or discard.
488    //
489    // The `emit` parameter controls whether data is emitted or discarded from
490    // `recv`.
491    //
492    // The `target_len` parameter controls the maximum amount of bytes that
493    // could be read, up to the capacity of `recv`. The `result_len` is the
494    // actual number of bytes that were taken out of `recv`. An assert is
495    // performed on `result_len` to ensure the number of bytes read meets the
496    // caller expectations.
497    //
498    // The `is_fin` parameter relates to the buffer's finished status. An assert
499    // is performed on it to ensure the status meet the caller expectations.
500    //
501    // The `test_bytes` parameter carries an optional slice of bytes. Is set, an
502    // assert is performed against the bytes that were read out of the buffer,
503    // to ensure caller expectations are met.
504    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    // Helper function for testing buffer status for either emit or discard.
530    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        // Don't store non-fin empty buffer, but track its offset.
566        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        // Check flow control for empty buffer.
573        let buf = RangeBuf::from(b"", 16, false);
574        assert_eq!(recv.write(buf), Err(Error::FlowControl));
575
576        // A final size below the advanced largest offset is an error
577        // (RFC 9000 Section 4.5).
578        let buf = RangeBuf::from(b"", 5, true);
579        assert_eq!(recv.write(buf), Err(Error::FinalSize));
580
581        // Store fin empty buffer at the largest received offset.
582        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        // Don't store additional fin empty buffers.
589        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        // Accept another fin buffer with the same final size.
596        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        // A fin buffer whose end disagrees with the known final size errors.
603        let buf = RangeBuf::from(b"aa", 3, true);
604        assert_eq!(recv.write(buf), Err(Error::FinalSize));
605
606        // Validate final size with fin empty buffers.
607        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        // The range (5..10) was never received, so the stream cannot reach
613        // its fin and nothing further is readable.
614        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    /// `readable_len` counts only contiguous in-order data, up to its limit.
659    fn readable_len() {
660        let mut recv =
661            RecvBuf::new(u64::MAX, DEFAULT_STREAM_WINDOW, DEFAULT_STREAM_WINDOW);
662
663        // Empty buffer: nothing readable.
664        assert_eq!(recv.readable_len(64 * 1024), 0);
665
666        // Data buffered behind a gap is not readable.
667        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        // Filling the gap makes the full range readable, bounded by the limit.
672        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    /// Test shutdown behavior
678    #[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        // shutdown the buffer. Buffer is dropped.
695        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        // subsequent writes are validated but not added to the buffer
703        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        // the max offset of received data can increase and
709        // the recv.off must increase with it
710        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        // Send a reset
716        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    /// An empty non-fin buffer advances the largest received offset, which the
732    /// connection charges to flow control on arrival, so a draining stream must
733    /// consume it too and a later reset must not credit it again.
734    #[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}