WIP add proptest for SendBuffer

Author: rklaehn

quinn-proto/src/connection/send_buffer.rs

@@ -261,7 +261,8 @@ impl SendBuffer {
     }
 
     pub(super) fn retransmit_all_for_0rtt(&mut self) {
-        debug_assert_eq!(self.offset(), self.data.len() as u64);
+        // check that we still got all data - we didn't get any acks.
+        debug_assert_eq!(self.data.range().start, 0);
         self.unsent = 0;
     }
 
@@ -291,6 +292,10 @@ impl SendBuffer {
 
 #[cfg(test)]
 mod tests {
+    use test_strategy::{Arbitrary, proptest};
+    use proptest::prelude::*;
+    use rand::{SeedableRng, rngs::StdRng};
+
     use super::*;
 
     #[test]
@@ -501,6 +506,80 @@ mod tests {
         let mut buf = Vec::new();
         data.get_into(0..1, &mut buf);
     }
+
+    #[derive(Debug, Clone, Arbitrary)]
+    enum Op {
+        // write the given bytes
+        Write(#[strategy(proptest::collection::vec(any::<u8>(), 0..1024))] Vec<u8>),
+        // ack a random range, the value is the rng seed
+        Ack(u64),
+        // retransmit a random range, the value is the rng seed
+        Retransmit(u64),
+        // poll_transmit with the given max len
+        PollTransmit(#[strategy(16usize..1024)] usize),
+    }
+
+    fn random_range(seed: u64, range: Range<u64>) -> Range<u64> {
+        if range.is_empty() {
+            return range;
+        }
+        let mut rng = StdRng::seed_from_u64(seed);
+        let a = rng.random_range(range.clone());
+        let b = rng.random_range(range);
+        if a < b { a..b } else { b..a }
+    }
+
+    #[proptest]
+    fn send_buffer_matches_reference(
+        #[strategy(proptest::collection::vec(any::<Op>(), 1..100))] ops: Vec<Op>,
+    ) {
+        let mut sb = SendBuffer::new();
+        // total bytes written so far
+        let mut total_bytes = 0u64;
+        // max offset that has been returned by poll_transmit
+        let mut max_send_offset = 0u64;
+        // max offset up to which data has been fully acked
+        let mut max_full_send_offset = 0u64;
+        println!("");
+        for op in ops {
+            match op {
+                Op::Write(data) => {
+                    total_bytes += data.len() as u64;
+                    println!("Writing {} bytes", data.len());
+                    sb.write(Bytes::from(data));
+                }
+                Op::Ack(seed) => {
+                    // only generate acks for data that has been sent
+                    let range = random_range(seed, 0..max_send_offset + 1);
+                    if range.is_empty() {
+                        continue;
+                    }
+                    // update fully acked range
+                    if range.contains(&max_full_send_offset) {
+                        max_full_send_offset = range.end;
+                    }
+                    println!("Acking range: {:?}", range);
+                    sb.ack(range);
+                }
+                Op::Retransmit(seed) => {
+                    let range = random_range(seed, max_full_send_offset..max_send_offset + 1);
+                    if range.is_empty() {
+                        continue;
+                    }
+                    println!("Retransmitting range: {:?}", range);
+                    sb.retransmit(range);
+                }
+                Op::PollTransmit(max_len) => {
+                    let (range, _partial) = sb.poll_transmit(max_len);
+                    max_send_offset = max_send_offset.max(range.end);
+                    let mut buf = Vec::new();
+                    println!("Getting data for range: {:?}", range);
+                    sb.get_into(range, &mut buf);
+                }
+            }
+
+        }
+    }
 }
 
 #[cfg(feature = "bench")]