Skip to content

Commit 3680946

Browse files
camshaftcamshaft
committed
add duplex test
1 parent 2009a83 commit 3680946

File tree

12 files changed

+129
-34
lines changed

12 files changed

+129
-34
lines changed

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

+100-5
Original file line numberDiff line numberDiff line change
@@ -114,17 +114,16 @@ where
114114
where
115115
R: Reader + ?Sized,
116116
{
117-
// enable reader checks
118-
let mut reader = reader.with_checks();
119-
let reader = &mut reader;
120-
121117
let final_offset = reader.final_offset();
122118

123119
{
124120
// if the storage specializes writing zero-copy Bytes/BytesMut, then just write to the
125121
// receive buffer, since that's what it stores
126122
let mut should_delegate = C::SPECIALIZES_BYTES || C::SPECIALIZES_BYTES_MUT;
127123

124+
// if the storage is empty then write into the duplex
125+
should_delegate |= !self.storage.has_remaining_capacity();
126+
128127
// if this packet is non-contiguous, then delegate to the wrapped writer
129128
should_delegate |= reader.current_offset() != self.duplex.current_offset();
130129

@@ -148,7 +147,7 @@ where
148147

149148
{
150149
// track the number of consumed bytes
151-
let mut reader = reader.tracked();
150+
let mut reader = reader.track_read();
152151

153152
reader.copy_into(self.storage)?;
154153

@@ -169,3 +168,99 @@ where
169168
Ok(())
170169
}
171170
}
171+
172+
#[cfg(test)]
173+
mod tests {
174+
use super::*;
175+
use crate::{
176+
buffer::{
177+
reader::Reader,
178+
writer::{Storage as _, Writer},
179+
Reassembler,
180+
},
181+
stream::testing::Data,
182+
};
183+
184+
#[test]
185+
fn split_test() {
186+
let mut duplex = Reassembler::default();
187+
let mut reader = Data::new(10_000);
188+
let mut checker = reader;
189+
190+
{
191+
let mut storage: Vec<u8> = vec![];
192+
193+
let mut split = Split::new(&mut storage, &mut duplex);
194+
195+
let mut reader = reader.with_read_limit(5);
196+
split.read_from(&mut reader).unwrap();
197+
198+
assert_eq!(storage.len(), 5);
199+
assert_eq!(duplex.current_offset().as_u64(), 5);
200+
201+
checker.receive(&[&storage[..]]);
202+
}
203+
204+
{
205+
let mut storage = writer::storage::Empty;
206+
207+
let mut split = Split::new(&mut storage, &mut duplex);
208+
209+
let mut reader = reader.with_read_limit(5);
210+
split.read_from(&mut reader).unwrap();
211+
212+
assert_eq!(duplex.current_offset().as_u64(), 5);
213+
assert_eq!(duplex.len(), 5);
214+
}
215+
216+
{
217+
let mut storage: Vec<u8> = vec![];
218+
219+
let mut split = Split::new(&mut storage, &mut duplex);
220+
221+
let mut reader = reader.with_read_limit(5);
222+
split.read_from(&mut reader).unwrap();
223+
224+
// make sure we didn't write to the storage, even if we had capacity, since the
225+
// current_offset doesn't match
226+
assert!(storage.is_empty());
227+
assert_eq!(duplex.current_offset().as_u64(), 5);
228+
229+
// move the reassembled bytes into the checker
230+
checker.read_from(&mut duplex).unwrap();
231+
assert_eq!(duplex.current_offset().as_u64(), 15);
232+
}
233+
234+
{
235+
let mut storage: Vec<u8> = vec![];
236+
{
237+
let mut storage = storage.with_write_limit(1);
238+
239+
let mut split = Split::new(&mut storage, &mut duplex);
240+
241+
let mut reader = reader.with_read_limit(10);
242+
split.read_from(&mut reader).unwrap();
243+
}
244+
245+
// the storage was too small so we delegated to duplex
246+
assert!(storage.is_empty());
247+
assert_eq!(duplex.len(), 10);
248+
249+
// move the reassembled bytes into the checker
250+
checker.read_from(&mut duplex).unwrap();
251+
assert_eq!(duplex.current_offset().as_u64(), 25);
252+
}
253+
254+
{
255+
let mut storage = writer::storage::Empty;
256+
257+
let mut split = Split::new(&mut storage, &mut duplex);
258+
259+
let mut reader = reader.with_read_limit(1);
260+
split.read_from(&mut reader).unwrap();
261+
262+
assert_eq!(duplex.current_offset().as_u64(), 25);
263+
assert_eq!(duplex.len(), 1);
264+
}
265+
}
266+
}

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

+2-2
Original file line numberDiff line numberDiff line change
@@ -49,12 +49,12 @@ pub trait Reader: Storage {
4949
fn with_max_data(&mut self, max_data: VarInt) -> Limit<Self> {
5050
let max_buffered_len = max_data.saturating_sub(self.current_offset());
5151
let max_buffered_len = max_buffered_len.as_u64().min(self.buffered_len() as u64) as usize;
52-
self.with_limit(max_buffered_len)
52+
self.with_read_limit(max_buffered_len)
5353
}
5454

5555
/// Limits the maximum amount of data that the caller can read from the reader
5656
#[inline]
57-
fn with_limit(&mut self, max_buffered_len: usize) -> Limit<Self> {
57+
fn with_read_limit(&mut self, max_buffered_len: usize) -> Limit<Self> {
5858
Limit::new(self, max_buffered_len)
5959
}
6060

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

+2-2
Original file line numberDiff line numberDiff line change
@@ -110,7 +110,7 @@ where
110110
Dest: writer::Storage + ?Sized,
111111
{
112112
let snapshot = Snapshot::new(self.inner, dest.remaining_capacity());
113-
let mut dest = dest.tracked();
113+
let mut dest = dest.track_write();
114114

115115
let mut chunk = self.inner.partial_copy_into(&mut dest)?;
116116

@@ -129,7 +129,7 @@ where
129129
Dest: writer::Storage + ?Sized,
130130
{
131131
let snapshot = Snapshot::new(self.inner, dest.remaining_capacity());
132-
let mut dest = dest.tracked();
132+
let mut dest = dest.track_write();
133133

134134
self.inner.copy_into(&mut dest)?;
135135

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

+2-2
Original file line numberDiff line numberDiff line change
@@ -64,7 +64,7 @@ where
6464
where
6565
Dest: writer::Storage + ?Sized,
6666
{
67-
let mut dest = dest.tracked();
67+
let mut dest = dest.track_write();
6868
let chunk = self.storage.partial_copy_into(&mut dest)?;
6969
self.current_offset += chunk.len();
7070
self.current_offset += dest.written_len();
@@ -76,7 +76,7 @@ where
7676
where
7777
Dest: writer::Storage + ?Sized,
7878
{
79-
let mut dest = dest.tracked();
79+
let mut dest = dest.track_write();
8080
self.storage.copy_into(&mut dest)?;
8181
self.current_offset += dest.written_len();
8282
Ok(())

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

+2-2
Original file line numberDiff line numberDiff line change
@@ -100,7 +100,7 @@ impl<'a, C: Storage> Storage for WithStorage<'a, C> {
100100
where
101101
Dest: writer::Storage + ?Sized,
102102
{
103-
let mut dest = dest.tracked();
103+
let mut dest = dest.track_write();
104104
let chunk = self.storage.partial_copy_into(&mut dest)?;
105105
self.incremental.current_offset += chunk.len();
106106
self.incremental.current_offset += dest.written_len();
@@ -112,7 +112,7 @@ impl<'a, C: Storage> Storage for WithStorage<'a, C> {
112112
where
113113
Dest: writer::Storage + ?Sized,
114114
{
115-
let mut dest = dest.tracked();
115+
let mut dest = dest.track_write();
116116
self.storage.copy_into(&mut dest)?;
117117
self.incremental.current_offset += dest.written_len();
118118
Ok(())

‎quic/s2n-quic-core/src/buffer/reader/limit.rs

+4-4
Original file line numberDiff line numberDiff line change
@@ -53,8 +53,8 @@ impl<'a, R: Reader + ?Sized> Storage for Limit<'a, R> {
5353
where
5454
Dest: writer::Storage + ?Sized,
5555
{
56-
let mut dest = dest.limit(self.buffered_len);
57-
let mut dest = dest.tracked();
56+
let mut dest = dest.with_write_limit(self.buffered_len);
57+
let mut dest = dest.track_write();
5858
let chunk = self.reader.partial_copy_into(&mut dest)?;
5959
let len = dest.written_len() + chunk.len();
6060
unsafe {
@@ -69,8 +69,8 @@ impl<'a, R: Reader + ?Sized> Storage for Limit<'a, R> {
6969
where
7070
Dest: writer::Storage + ?Sized,
7171
{
72-
let mut dest = dest.limit(self.buffered_len);
73-
let mut dest = dest.tracked();
72+
let mut dest = dest.with_write_limit(self.buffered_len);
73+
let mut dest = dest.track_write();
7474
self.reader.copy_into(&mut dest)?;
7575
let len = dest.written_len();
7676
unsafe {

‎quic/s2n-quic-core/src/buffer/reader/storage.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -72,7 +72,7 @@ pub trait Storage {
7272

7373
/// Tracks the number of bytes read from the storage
7474
#[inline]
75-
fn tracked(&mut self) -> Tracked<Self> {
75+
fn track_read(&mut self) -> Tracked<Self> {
7676
Tracked::new(self)
7777
}
7878
}

‎quic/s2n-quic-core/src/buffer/reader/storage/bytes.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -107,7 +107,7 @@ mod tests {
107107

108108
let mut writer: Vec<Bytes> = vec![];
109109
{
110-
let mut writer = writer.limit(5);
110+
let mut writer = writer.with_write_limit(5);
111111
let chunk = reader.partial_copy_into(&mut writer).unwrap();
112112
assert_eq!(&chunk[..], b"hello");
113113
}

‎quic/s2n-quic-core/src/buffer/reader/storage/tracked.rs

+6-6
Original file line numberDiff line numberDiff line change
@@ -46,7 +46,7 @@ impl<'a, S: Storage + ?Sized> Storage for Tracked<'a, S> {
4646
where
4747
Dest: writer::Storage + ?Sized,
4848
{
49-
let mut dest = dest.tracked();
49+
let mut dest = dest.track_write();
5050
let chunk = self.storage.partial_copy_into(&mut dest)?;
5151
self.consumed += dest.written_len();
5252
self.consumed += chunk.len();
@@ -58,7 +58,7 @@ impl<'a, S: Storage + ?Sized> Storage for Tracked<'a, S> {
5858
where
5959
Dest: writer::Storage + ?Sized,
6060
{
61-
let mut dest = dest.tracked();
61+
let mut dest = dest.track_write();
6262
self.storage.copy_into(&mut dest)?;
6363
self.consumed += dest.written_len();
6464
Ok(())
@@ -98,15 +98,15 @@ mod tests {
9898
let mut writer: Vec<u8> = vec![];
9999

100100
{
101-
let mut reader = reader.tracked();
101+
let mut reader = reader.track_read();
102102
let chunk = reader.read_chunk(1).unwrap();
103103
assert_eq!(&chunk[..], b"h");
104104
assert_eq!(reader.consumed_len(), 1);
105105
}
106106

107107
{
108-
let mut reader = reader.tracked();
109-
let mut writer = writer.limit(5);
108+
let mut reader = reader.track_read();
109+
let mut writer = writer.with_write_limit(5);
110110

111111
let chunk = reader.partial_copy_into(&mut writer).unwrap();
112112
assert_eq!(&chunk[..], b"ello ");
@@ -116,7 +116,7 @@ mod tests {
116116
assert_eq!(writer.len(), 0);
117117

118118
{
119-
let mut reader = reader.tracked();
119+
let mut reader = reader.track_read();
120120
reader.copy_into(&mut writer).unwrap();
121121
assert_eq!(reader.consumed_len(), 5);
122122
assert_eq!(&writer[..], b"world");

‎quic/s2n-quic-core/src/buffer/writer/storage.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -87,13 +87,13 @@ pub trait Storage {
8787

8888
/// Limits the number of bytes that can be written to the storage
8989
#[inline]
90-
fn limit(&mut self, max_len: usize) -> Limit<Self> {
90+
fn with_write_limit(&mut self, max_len: usize) -> Limit<Self> {
9191
Limit::new(self, max_len)
9292
}
9393

9494
/// Tracks the number of bytes written to the storage
9595
#[inline]
96-
fn tracked(&mut self) -> Tracked<Self> {
96+
fn track_write(&mut self) -> Tracked<Self> {
9797
Tracked::new(self)
9898
}
9999

‎quic/s2n-quic-core/src/buffer/writer/storage/limit.rs

+4-4
Original file line numberDiff line numberDiff line change
@@ -109,28 +109,28 @@ mod tests {
109109
let mut writer: Vec<u8> = vec![];
110110

111111
{
112-
let mut writer = writer.limit(5);
112+
let mut writer = writer.with_write_limit(5);
113113
assert_eq!(writer.remaining_capacity(), 5);
114114
writer.put_slice(b"hello");
115115
assert_eq!(writer.remaining_capacity(), 0);
116116
}
117117

118118
{
119-
let mut writer = writer.limit(5);
119+
let mut writer = writer.with_write_limit(5);
120120
assert_eq!(writer.remaining_capacity(), 5);
121121
writer.put_bytes(Bytes::from_static(b"hello"));
122122
assert_eq!(writer.remaining_capacity(), 0);
123123
}
124124

125125
{
126-
let mut writer = writer.limit(5);
126+
let mut writer = writer.with_write_limit(5);
127127
assert_eq!(writer.remaining_capacity(), 5);
128128
writer.put_bytes_mut(BytesMut::from(&b"hello"[..]));
129129
assert_eq!(writer.remaining_capacity(), 0);
130130
}
131131

132132
{
133-
let writer = writer.limit(0);
133+
let writer = writer.with_write_limit(0);
134134
assert!(!writer.has_remaining_capacity());
135135
}
136136
}

‎quic/s2n-quic-core/src/buffer/writer/storage/tracked.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -89,21 +89,21 @@ mod tests {
8989
let mut writer: Vec<u8> = vec![];
9090

9191
{
92-
let mut writer = writer.tracked();
92+
let mut writer = writer.track_write();
9393
assert_eq!(writer.written_len(), 0);
9494
writer.put_slice(b"hello");
9595
assert_eq!(writer.written_len(), 5);
9696
}
9797

9898
{
99-
let mut writer = writer.tracked();
99+
let mut writer = writer.track_write();
100100
assert_eq!(writer.written_len(), 0);
101101
writer.put_bytes(Bytes::from_static(b"hello"));
102102
assert_eq!(writer.written_len(), 5);
103103
}
104104

105105
{
106-
let mut writer = writer.tracked();
106+
let mut writer = writer.track_write();
107107
assert_eq!(writer.written_len(), 0);
108108
writer.put_bytes_mut(BytesMut::from(&b"hello"[..]));
109109
assert_eq!(writer.written_len(), 5);

0 commit comments

Comments
 (0)