increase unit test coverage

Author: camshaft

quic/s2n-quic-core/src/buffer/duplex/split.rs

@@ -182,85 +182,145 @@ mod tests {
     };
 
     #[test]
-    fn split_test() {
+    fn undersized_storage_test() {
         let mut duplex = Reassembler::default();
-        let mut reader = Data::new(10_000);
+        let mut reader = Data::new(10);
         let mut checker = reader;
 
+        let mut storage: Vec<u8> = vec![];
         {
-            let mut storage: Vec<u8> = vec![];
+            // limit the storage capacity so we force writing into the duplex
+            let mut storage = storage.with_write_limit(1);
 
             let mut split = Split::new(&mut storage, &mut duplex);
 
-            let mut reader = reader.with_read_limit(5);
             split.read_from(&mut reader).unwrap();
+        }
 
-            assert_eq!(storage.len(), 5);
-            assert_eq!(duplex.current_offset().as_u64(), 5);
+        // the storage was too small so we delegated to duplex
+        assert!(storage.is_empty());
+        assert_eq!(duplex.buffered_len(), 10);
 
-            checker.receive(&[&storage[..]]);
-        }
+        // move the reassembled bytes into the checker
+        checker.read_from(&mut duplex).unwrap();
+        assert_eq!(duplex.current_offset().as_u64(), 10);
+        assert!(duplex.is_consumed());
+    }
+
+    #[test]
+    fn out_of_order_test() {
+        let mut duplex = Reassembler::default();
 
+        // first write 5 bytes at offset 5
         {
-            let mut storage = writer::storage::Empty;
+            let mut reader = Data::new(10);
+
+            // advance the reader by 5 bytes
+            let _ = reader.send_one(5);
+
+            let mut storage: Vec<u8> = vec![];
 
             let mut split = Split::new(&mut storage, &mut duplex);
 
-            let mut reader = reader.with_read_limit(5);
             split.read_from(&mut reader).unwrap();
 
-            assert_eq!(duplex.current_offset().as_u64(), 5);
-            assert_eq!(duplex.len(), 5);
+            // make sure we consumed the reader
+            assert_eq!(reader.current_offset().as_u64(), 10);
+
+            assert_eq!(split.current_offset().as_u64(), 0);
+            assert_eq!(split.buffered_len(), 0);
+
+            // make sure we didn't write to the storage, even if we had capacity, since the
+            // current_offset doesn't match
+            assert!(storage.is_empty());
         }
 
+        // then write 10 bytes at offset 0
         {
+            let mut reader = Data::new(10);
+
             let mut storage: Vec<u8> = vec![];
 
             let mut split = Split::new(&mut storage, &mut duplex);
 
-            let mut reader = reader.with_read_limit(5);
             split.read_from(&mut reader).unwrap();
 
-            // make sure we didn't write to the storage, even if we had capacity, since the
-            // current_offset doesn't match
-            assert!(storage.is_empty());
-            assert_eq!(duplex.current_offset().as_u64(), 5);
+            // make sure we consumed the reader
+            assert_eq!(reader.current_offset().as_u64(), 10);
 
-            // move the reassembled bytes into the checker
-            checker.read_from(&mut duplex).unwrap();
-            assert_eq!(duplex.current_offset().as_u64(), 15);
+            assert_eq!(split.current_offset().as_u64(), 10);
+            assert_eq!(split.buffered_len(), 0);
+
+            // make sure we copied the entire reader
+            assert_eq!(storage.len(), 10);
+            assert!(duplex.is_consumed());
         }
+    }
 
-        {
-            let mut storage: Vec<u8> = vec![];
-            {
-                let mut storage = storage.with_write_limit(1);
+    #[test]
+    fn skip_test() {
+        let mut duplex = Reassembler::default();
+        let mut reader = Data::new(10);
+        let mut checker = reader;
 
-                let mut split = Split::new(&mut storage, &mut duplex);
+        let mut storage: Vec<u8> = vec![];
 
-                let mut reader = reader.with_read_limit(10);
-                split.read_from(&mut reader).unwrap();
-            }
+        let mut split = Split::new(&mut storage, &mut duplex);
 
-            // the storage was too small so we delegated to duplex
-            assert!(storage.is_empty());
-            assert_eq!(duplex.len(), 10);
+        split.read_from(&mut reader).unwrap();
 
-            // move the reassembled bytes into the checker
-            checker.read_from(&mut duplex).unwrap();
-            assert_eq!(duplex.current_offset().as_u64(), 25);
-        }
+        assert_eq!(storage.len(), 10);
+        assert_eq!(duplex.current_offset().as_u64(), 10);
+
+        checker.receive(&[&storage[..]]);
+    }
+
+    #[test]
+    fn empty_storage_test() {
+        let mut duplex = Reassembler::default();
+        let mut reader = Data::new(10);
+        let mut checker = reader;
+
+        let mut storage = writer::storage::Empty;
+
+        let mut split = Split::new(&mut storage, &mut duplex);
 
+        split.read_from(&mut reader).unwrap();
+
+        assert_eq!(split.current_offset().as_u64(), 0);
+        assert_eq!(split.buffered_len(), 10);
+
+        checker.read_from(&mut split).unwrap();
+
+        assert_eq!(split.current_offset().as_u64(), 10);
+        assert!(split.buffer_is_empty());
+        assert_eq!(split.buffered_len(), 0);
+        assert!(split.is_consumed());
+    }
+
+    #[test]
+    fn partial_test() {
+        let mut duplex = Reassembler::default();
+        let mut reader = Data::new(10);
+        let mut checker = reader;
+
+        let mut storage: Vec<u8> = vec![];
         {
-            let mut storage = writer::storage::Empty;
+            let mut storage = storage.with_write_limit(9);
 
             let mut split = Split::new(&mut storage, &mut duplex);
 
-            let mut reader = reader.with_read_limit(1);
             split.read_from(&mut reader).unwrap();
-
-            assert_eq!(duplex.current_offset().as_u64(), 25);
-            assert_eq!(duplex.len(), 1);
         }
+
+        // the storage was at least half the reader
+        assert_eq!(storage.len(), 9);
+        assert_eq!(duplex.buffered_len(), 1);
+
+        // move the reassembled bytes into the checker
+        checker.receive(&[&storage]);
+        checker.read_from(&mut duplex).unwrap();
+        assert_eq!(duplex.current_offset().as_u64(), 10);
+        assert!(duplex.is_consumed());
     }
 }

quic/s2n-quic-core/src/buffer/reader/checked.rs

@@ -49,6 +49,11 @@ where
         self.inner.buffered_len()
     }
 
+    #[inline(always)]
+    fn buffer_is_empty(&self) -> bool {
+        self.inner.buffer_is_empty()
+    }
+
     #[inline(always)]
     fn read_chunk(&mut self, watermark: usize) -> Result<super::storage::Chunk<'_>, Self::Error> {
         self.inner.read_chunk(watermark)
@@ -86,6 +91,11 @@ where
         self.inner.buffered_len()
     }
 
+    #[inline]
+    fn buffer_is_empty(&self) -> bool {
+        self.inner.buffer_is_empty()
+    }
+
     #[inline]
     fn read_chunk(&mut self, watermark: usize) -> Result<super::storage::Chunk<'_>, Self::Error> {
         let snapshot = Snapshot::new(self.inner, watermark);

quic/s2n-quic-core/src/buffer/reader/complete.rs

@@ -34,11 +34,6 @@ where
             final_offset,
         })
     }
-
-    #[inline]
-    pub fn is_empty(&self) -> bool {
-        self.storage.buffer_is_empty()
-    }
 }
 
 impl<'a, S> Storage for Complete<'a, S>
@@ -52,6 +47,11 @@ where
         self.storage.buffered_len()
     }
 
+    #[inline]
+    fn buffer_is_empty(&self) -> bool {
+        self.storage.buffer_is_empty()
+    }
+
     #[inline]
     fn read_chunk(&mut self, watermark: usize) -> Result<Chunk, Self::Error> {
         let chunk = self.storage.read_chunk(watermark)?;
@@ -103,7 +103,23 @@ mod tests {
     use super::*;
 
     #[test]
-    fn complete_test() {
+    fn read_chunk_test() {
+        let mut storage: &[u8] = &[1, 2, 3, 4];
+        let mut reader = Complete::new(&mut storage).unwrap();
+        let mut reader = reader.with_checks();
+
+        assert_eq!(reader.current_offset(), VarInt::ZERO);
+        assert_eq!(reader.final_offset(), Some(VarInt::from_u8(4)));
+
+        let chunk = reader.read_chunk(usize::MAX).unwrap();
+        assert_eq!(&*chunk, &[1, 2, 3, 4]);
+
+        assert_eq!(reader.current_offset(), VarInt::from_u8(4));
+        assert!(reader.buffer_is_empty());
+    }
+
+    #[test]
+    fn partial_copy_test() {
         let mut storage: &[u8] = &[1, 2, 3, 4];
         let mut reader = Complete::new(&mut storage).unwrap();
         let mut reader = reader.with_checks();
@@ -118,4 +134,24 @@ mod tests {
         assert_eq!(reader.current_offset(), VarInt::from_u8(4));
         assert!(reader.buffer_is_empty());
     }
+
+    #[test]
+    fn copy_test() {
+        let mut storage: &[u8] = &[1, 2, 3, 4];
+        let mut reader = Complete::new(&mut storage).unwrap();
+        let mut reader = reader.with_checks();
+
+        assert_eq!(reader.current_offset(), VarInt::ZERO);
+        assert_eq!(reader.final_offset(), Some(VarInt::from_u8(4)));
+
+        let mut dest = [0; 4];
+        {
+            let mut dest = &mut dest[..];
+            reader.copy_into(&mut dest).unwrap();
+        }
+        assert_eq!(&dest[..], &[1, 2, 3, 4]);
+
+        assert_eq!(reader.current_offset(), VarInt::from_u8(4));
+        assert!(reader.buffer_is_empty());
+    }
 }

quic/s2n-quic-core/src/buffer/reader/incremental.rs

@@ -157,5 +157,20 @@ mod tests {
         }
 
         assert_eq!(incremental.current_offset(), VarInt::from_u8(4));
+
+        {
+            let mut chunk: &[u8] = &[5, 6, 7, 8];
+            let mut reader = incremental.with_storage(&mut chunk, true).unwrap();
+            let mut reader = reader.with_checks();
+
+            assert_eq!(reader.buffered_len(), 4);
+
+            let trailing_chunk = reader.read_chunk(usize::MAX).unwrap();
+            assert_eq!(&*trailing_chunk, &[5, 6, 7, 8]);
+
+            assert_eq!(reader.buffered_len(), 0);
+            assert!(reader.buffer_is_empty());
+            assert!(reader.is_consumed());
+        }
     }
 }