Skip to content

Commit c1ac6ed

Browse files
wcampbell0x2awcampbell0x2a
committed
Address MR feedback
1 parent 8f41f13 commit c1ac6ed

15 files changed

+63
-82
lines changed

‎src/impls/bool.rs

+5-8
Original file line numberDiff line numberDiff line change
@@ -76,19 +76,16 @@ mod tests {
7676

7777
#[test]
7878
fn test_writer() {
79-
let mut out_buf = vec![];
80-
let mut writer = Writer::new(&mut out_buf);
79+
let mut writer = Writer::new(vec![]);
8180
true.to_writer(&mut writer, BitSize(1)).unwrap();
8281
assert_eq!(vec![true], writer.rest());
8382

84-
let mut out_buf = vec![];
85-
let mut writer = Writer::new(&mut out_buf);
83+
let mut writer = Writer::new(vec![]);
8684
true.to_writer(&mut writer, ()).unwrap();
87-
assert_eq!(vec![1], out_buf);
85+
assert_eq!(vec![1], writer.inner);
8886

89-
let mut out_buf = vec![];
90-
let mut writer = Writer::new(&mut out_buf);
87+
let mut writer = Writer::new(vec![]);
9188
false.to_writer(&mut writer, ()).unwrap();
92-
assert_eq!(vec![0], out_buf);
89+
assert_eq!(vec![0], writer.inner);
9390
}
9491
}

‎src/impls/boxed.rs

+4-6
Original file line numberDiff line numberDiff line change
@@ -87,10 +87,9 @@ mod tests {
8787
let res_read = <Box<u16>>::from_reader_with_ctx(&mut reader, ()).unwrap();
8888
assert_eq!(expected, res_read);
8989

90-
let mut out_buf = vec![];
91-
let mut writer = Writer::new(&mut out_buf);
90+
let mut writer = Writer::new(vec![]);
9291
res_read.to_writer(&mut writer, ()).unwrap();
93-
assert_eq!(input.to_vec(), out_buf.to_vec());
92+
assert_eq!(input.to_vec(), writer.inner);
9493
}
9594

9695
// Note: Copied tests from vec.rs impl
@@ -131,12 +130,11 @@ mod tests {
131130

132131
assert_eq!(input[..expected_write.len()].to_vec(), expected_write);
133132

134-
let mut out_buf = vec![];
135-
let mut writer = Writer::new(&mut out_buf);
133+
let mut writer = Writer::new(vec![]);
136134
res_read
137135
.to_writer(&mut writer, (endian, BitSize(bit_size)))
138136
.unwrap();
139-
assert_eq!(expected_write, out_buf.to_vec());
137+
assert_eq!(expected_write, writer.inner);
140138

141139
assert_eq!(input[..expected_write.len()].to_vec(), expected_write);
142140
}

‎src/impls/cow.rs

+2-3
Original file line numberDiff line numberDiff line change
@@ -51,9 +51,8 @@ mod tests {
5151
let res_read = <Cow<u16>>::from_reader_with_ctx(&mut reader, ()).unwrap();
5252
assert_eq!(expected, res_read);
5353

54-
let mut out_buf = vec![];
55-
let mut writer = Writer::new(&mut out_buf);
54+
let mut writer = Writer::new(vec![]);
5655
res_read.to_writer(&mut writer, ()).unwrap();
57-
assert_eq!(input.to_vec(), out_buf.to_vec());
56+
assert_eq!(input.to_vec(), writer.inner);
5857
}
5958
}

‎src/impls/cstring.rs

+2-3
Original file line numberDiff line numberDiff line change
@@ -67,9 +67,8 @@ mod tests {
6767
cursor.read_to_end(&mut buf).unwrap();
6868
assert_eq!(expected_rest, buf);
6969

70-
let mut out_buf = vec![];
71-
let mut writer = Writer::new(&mut out_buf);
70+
let mut writer = Writer::new(vec![]);
7271
res_read.to_writer(&mut writer, ()).unwrap();
73-
assert_eq!(vec![b't', b'e', b's', b't', b'\0'], out_buf.to_vec());
72+
assert_eq!(vec![b't', b'e', b's', b't', b'\0'], writer.inner);
7473
}
7574
}

‎src/impls/hashmap.rs

+2-3
Original file line numberDiff line numberDiff line change
@@ -302,9 +302,8 @@ mod tests {
302302
case::normal(fxhashmap!{0x11u8 => 0xAABBu16, 0x23u8 => 0xCCDDu16}, Endian::Little, vec![0x11, 0xBB, 0xAA, 0x23, 0xDD, 0xCC]),
303303
)]
304304
fn test_hashmap_write(input: FxHashMap<u8, u16>, endian: Endian, expected: Vec<u8>) {
305-
let mut out_buf = vec![];
306-
let mut writer = Writer::new(&mut out_buf);
305+
let mut writer = Writer::new(vec![]);
307306
input.to_writer(&mut writer, endian).unwrap();
308-
assert_eq!(expected, out_buf);
307+
assert_eq!(expected, writer.inner);
309308
}
310309
}

‎src/impls/hashset.rs

+4-6
Original file line numberDiff line numberDiff line change
@@ -271,10 +271,9 @@ mod tests {
271271
case::normal(vec![0xAABB, 0xCCDD].into_iter().collect(), Endian::Little, vec![0xDD, 0xCC, 0xBB, 0xAA]),
272272
)]
273273
fn test_hashset_write(input: FxHashSet<u16>, endian: Endian, expected: Vec<u8>) {
274-
let mut out_buf = vec![];
275-
let mut writer = Writer::new(&mut out_buf);
274+
let mut writer = Writer::new(vec![]);
276275
input.to_writer(&mut writer, endian).unwrap();
277-
assert_eq!(expected, out_buf);
276+
assert_eq!(expected, writer.inner);
278277
}
279278

280279
// Note: These tests also exist in boxed.rs
@@ -315,11 +314,10 @@ mod tests {
315314
cursor.read_to_end(&mut buf).unwrap();
316315
assert_eq!(expected_rest_bytes, buf);
317316

318-
let mut out_buf = vec![];
319-
let mut writer = Writer::new(&mut out_buf);
317+
let mut writer = Writer::new(vec![]);
320318
res_read
321319
.to_writer(&mut writer, (endian, BitSize(bit_size)))
322320
.unwrap();
323-
assert_eq!(expected_write, out_buf);
321+
assert_eq!(expected_write, writer.inner);
324322
}
325323
}

‎src/impls/ipaddr.rs

+8-12
Original file line numberDiff line numberDiff line change
@@ -83,10 +83,9 @@ mod tests {
8383
let res_read = Ipv4Addr::from_reader_with_ctx(&mut reader, endian).unwrap();
8484
assert_eq!(expected, res_read);
8585

86-
let mut out_buf = vec![];
87-
let mut writer = Writer::new(&mut out_buf);
86+
let mut writer = Writer::new(vec![]);
8887
res_read.to_writer(&mut writer, endian).unwrap();
89-
assert_eq!(input.to_vec(), out_buf.to_vec());
88+
assert_eq!(input.to_vec(), writer.inner);
9089
}
9190

9291
#[rstest(input, endian, expected,
@@ -99,31 +98,28 @@ mod tests {
9998
let res_read = Ipv6Addr::from_reader_with_ctx(&mut reader, endian).unwrap();
10099
assert_eq!(expected, res_read);
101100

102-
let mut out_buf = vec![];
103-
let mut writer = Writer::new(&mut out_buf);
101+
let mut writer = Writer::new(vec![]);
104102
res_read.to_writer(&mut writer, endian).unwrap();
105-
assert_eq!(input.to_vec(), out_buf.to_vec());
103+
assert_eq!(input.to_vec(), writer.inner);
106104
}
107105

108106
#[test]
109107
fn test_ip_addr_write() {
110108
let ip_addr = IpAddr::V4(Ipv4Addr::new(145, 254, 160, 237));
111109

112-
let mut out_buf = vec![];
113-
let mut writer = Writer::new(&mut out_buf);
110+
let mut writer = Writer::new(vec![]);
114111
ip_addr.to_writer(&mut writer, Endian::Little).unwrap();
115-
assert_eq!(vec![237, 160, 254, 145], out_buf.to_vec());
112+
assert_eq!(vec![237, 160, 254, 145], writer.inner);
116113

117114
let ip_addr = IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x02ff));
118-
let mut out_buf = vec![];
119-
let mut writer = Writer::new(&mut out_buf);
115+
let mut writer = Writer::new(vec![]);
120116
ip_addr.to_writer(&mut writer, Endian::Little).unwrap();
121117
assert_eq!(
122118
vec![
123119
0xff, 0x02, 0x0a, 0xc0, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
124120
0x00, 0x00
125121
],
126-
out_buf.to_vec()
122+
writer.inner
127123
);
128124
}
129125
}

‎src/impls/nonzero.rs

+2-3
Original file line numberDiff line numberDiff line change
@@ -83,9 +83,8 @@ mod tests {
8383
let res_read = NonZeroU8::from_reader_with_ctx(&mut reader, ()).unwrap();
8484
assert_eq!(expected, res_read);
8585

86-
let mut out_buf = vec![];
87-
let mut writer = Writer::new(&mut out_buf);
86+
let mut writer = Writer::new(vec![]);
8887
res_read.to_writer(&mut writer, ()).unwrap();
89-
assert_eq!(input.to_vec(), out_buf.to_vec());
88+
assert_eq!(input.to_vec(), writer.inner);
9089
}
9190
}

‎src/impls/option.rs

+8-1
Original file line numberDiff line numberDiff line change
@@ -27,12 +27,19 @@ mod tests {
2727
use crate::reader::Reader;
2828

2929
#[test]
30-
fn test_option() {
30+
fn test_option_read() {
3131
use crate::ctx::*;
3232
let input = &[1u8, 2, 3, 4];
3333
let mut cursor = Cursor::new(input);
3434
let mut reader = Reader::new(&mut cursor);
3535
let v = Option::<u32>::from_reader_with_ctx(&mut reader, Endian::Little).unwrap();
3636
assert_eq!(v, Some(0x04030201))
3737
}
38+
39+
#[test]
40+
fn test_option_write() {
41+
let mut writer = Writer::new(vec![]);
42+
Some(true).to_writer(&mut writer, ()).unwrap();
43+
assert_eq!(vec![1], writer.inner);
44+
}
3845
}

‎src/impls/primitive.rs

+8-12
Original file line numberDiff line numberDiff line change
@@ -624,10 +624,9 @@ mod tests {
624624
let res_read = <$typ>::from_reader_with_ctx(&mut reader, ENDIAN).unwrap();
625625
assert_eq!($expected, res_read);
626626

627-
let mut out_buf = vec![];
628-
let mut writer = Writer::new(&mut out_buf);
627+
let mut writer = Writer::new(vec![]);
629628
res_read.to_writer(&mut writer, ENDIAN).unwrap();
630-
assert_eq!($input, out_buf);
629+
assert_eq!($input, writer.inner);
631630
}
632631
};
633632
}
@@ -816,16 +815,15 @@ mod tests {
816815
expected: Vec<u8>,
817816
expected_leftover: Vec<bool>,
818817
) {
819-
let mut out_buf = vec![];
820-
let mut writer = Writer::new(&mut out_buf);
818+
let mut writer = Writer::new(vec![]);
821819
match bit_size {
822820
Some(bit_size) => input
823821
.to_writer(&mut writer, (endian, BitSize(bit_size)))
824822
.unwrap(),
825823
None => input.to_writer(&mut writer, endian).unwrap(),
826824
};
827825
assert_eq!(expected_leftover, writer.rest());
828-
assert_eq!(expected, out_buf);
826+
assert_eq!(expected, writer.inner);
829827
}
830828

831829
#[rstest(input, endian, byte_size, expected,
@@ -837,15 +835,14 @@ mod tests {
837835
case::byte_size_le_bigger(0x03AB, Endian::Little, Some(10), vec![0xAB, 0b11_000000]),
838836
)]
839837
fn test_byte_writer(input: u32, endian: Endian, byte_size: Option<usize>, expected: Vec<u8>) {
840-
let mut out_buf = vec![];
841-
let mut writer = Writer::new(&mut out_buf);
838+
let mut writer = Writer::new(vec![]);
842839
match byte_size {
843840
Some(byte_size) => input
844841
.to_writer(&mut writer, (endian, ByteSize(byte_size)))
845842
.unwrap(),
846843
None => input.to_writer(&mut writer, endian).unwrap(),
847844
};
848-
assert_hex::assert_eq_hex!(expected, out_buf);
845+
assert_hex::assert_eq_hex!(expected, writer.inner);
849846
}
850847

851848
#[rstest(input, endian, bit_size, expected, expected_write,
@@ -869,15 +866,14 @@ mod tests {
869866
};
870867
assert_eq!(expected, res_read);
871868

872-
let mut out_buf = vec![];
873-
let mut writer = Writer::new(&mut out_buf);
869+
let mut writer = Writer::new(vec![]);
874870
match bit_size {
875871
Some(bit_size) => res_read
876872
.to_writer(&mut writer, (endian, BitSize(bit_size)))
877873
.unwrap(),
878874
None => res_read.to_writer(&mut writer, endian).unwrap(),
879875
};
880-
assert_hex::assert_eq_hex!(expected_write, out_buf);
876+
assert_hex::assert_eq_hex!(expected_write, writer.inner);
881877
}
882878

883879
macro_rules! TestSignExtending {

‎src/impls/slice.rs

+5-7
Original file line numberDiff line numberDiff line change
@@ -106,11 +106,9 @@ mod tests {
106106
)]
107107
fn test_bit_write(input: [u16; 2], endian: Endian, expected: Vec<u8>) {
108108
// test writer
109-
let mut out_buf = vec![];
110-
let mut writer = Writer::new(&mut out_buf);
109+
let mut writer = Writer::new(vec![]);
111110
input.to_writer(&mut writer, endian).unwrap();
112-
assert_eq!(expected, out_buf.to_vec());
113-
}
111+
assert_eq!(expected, writer.inner);
114112

115113
#[rstest(input,endian,expected,expected_rest,
116114
case::normal_le(
@@ -158,10 +156,10 @@ mod tests {
158156
)]
159157
fn test_nested_array_bit_write(input: [[u16; 2]; 2], endian: Endian, expected: Vec<u8>) {
160158
// test &slice
161-
let mut out_buf = vec![];
162-
let mut writer = Writer::new(&mut out_buf);
159+
let input = input.as_ref();
160+
let mut writer = Writer::new(vec![]);
163161
input.to_writer(&mut writer, endian).unwrap();
164-
assert_eq!(expected, out_buf.to_vec());
162+
assert_eq!(expected, writer.inner);
165163
}
166164

167165
#[test]

‎src/impls/tuple.rs

+2-3
Original file line numberDiff line numberDiff line change
@@ -97,9 +97,8 @@ mod tests {
9797
where
9898
T: DekuWriter,
9999
{
100-
let mut out_buf = vec![];
101-
let mut writer = Writer::new(&mut out_buf);
100+
let mut writer = Writer::new(vec![]);
102101
input.to_writer(&mut writer, ()).unwrap();
103-
assert_eq!(expected, out_buf);
102+
assert_eq!(expected, writer.inner);
104103
}
105104
}

‎src/impls/unit.rs

+2-3
Original file line numberDiff line numberDiff line change
@@ -40,9 +40,8 @@ mod tests {
4040
let res_read = <()>::from_reader_with_ctx(&mut reader, ()).unwrap();
4141
assert_eq!((), res_read);
4242

43-
let mut out_buf = vec![];
44-
let mut writer = Writer::new(&mut out_buf);
43+
let mut writer = Writer::new(vec![]);
4544
res_read.to_writer(&mut writer, ()).unwrap();
46-
assert_eq!(0, out_buf.len());
45+
assert!(writer.inner.is_empty());
4746
}
4847
}

‎src/impls/vec.rs

+4-6
Original file line numberDiff line numberDiff line change
@@ -256,10 +256,9 @@ mod tests {
256256
case::normal(vec![0xAABB, 0xCCDD], Endian::Little, vec![0xBB, 0xAA, 0xDD, 0xCC]),
257257
)]
258258
fn test_vec_write(input: Vec<u16>, endian: Endian, expected: Vec<u8>) {
259-
let mut out_buf = vec![];
260-
let mut writer = Writer::new(&mut out_buf);
259+
let mut writer = Writer::new(vec![]);
261260
input.to_writer(&mut writer, endian).unwrap();
262-
assert_eq!(expected, out_buf.to_vec());
261+
assert_eq!(expected, writer.inner);
263262
}
264263

265264
// Note: These tests also exist in boxed.rs
@@ -298,12 +297,11 @@ mod tests {
298297
input.read_to_end(&mut buf).unwrap();
299298
assert_eq!(expected_rest_bytes, buf);
300299

301-
let mut out_buf = vec![];
302-
let mut writer = Writer::new(&mut out_buf);
300+
let mut writer = Writer::new(vec![]);
303301
res_read
304302
.to_writer(&mut writer, (endian, BitSize(bit_size)))
305303
.unwrap();
306-
assert_eq!(expected_write, out_buf.to_vec());
304+
assert_eq!(expected_write, writer.inner);
307305

308306
assert_eq!(input_clone[..expected_write.len()].to_vec(), expected_write);
309307
}

‎src/writer.rs

+5-6
Original file line numberDiff line numberDiff line change
@@ -75,12 +75,11 @@ impl<W: Write> Writer<W> {
7575
count += 1;
7676
});
7777

78-
// SAFETY: This does noto have a safety comment in bitvec. But this is safe
78+
// SAFETY: This does not have a safety comment in bitvec. But this is safe
7979
// because of `count` here will always still be within the bounds
8080
// of `bits`
8181
bits = unsafe { bits.get_unchecked(count * bits_of::<u8>()..) };
8282

83-
// TODO: with_capacity?
8483
self.leftover = bits.to_bitvec();
8584
if self.inner.write_all(&buf).is_err() {
8685
return Err(DekuError::Write);
@@ -107,8 +106,8 @@ impl<W: Write> Writer<W> {
107106
#[cfg(feature = "logging")]
108107
log::trace!("leftover exists");
109108

110-
// TODO: we could check here and only send the required bits to finish the byte?
111-
// (instead of sending the entire thing)
109+
// TODO(perf): we could check here and only send the required bits to finish the byte,
110+
// instead of sending the entire thing. The rest would be through self.inner.write.
112111
self.write_bits(&BitVec::from_slice(buf))?;
113112
} else {
114113
if self.inner.write_all(buf).is_err() {
@@ -133,8 +132,8 @@ impl<W: Write> Writer<W> {
133132
.extend_from_bitslice(&bitvec![u8, Msb0; 0; 8 - self.leftover.len()]);
134133
let mut buf = alloc::vec![0x00; self.leftover.len() / 8];
135134

136-
// write as many leftover to the buffer (as we can, can't write bits just bytes)
137-
// TODO: error if bits are leftover? (not bytes aligned)
135+
// write as many leftover to the buffer. Because of the previous extend,
136+
// this will include all the bits in self.leftover
138137
self.leftover
139138
.chunks_exact(bits_of::<u8>())
140139
.zip(buf.iter_mut())

0 commit comments

Comments
 (0)