Debian Codegraph @

.cargo/vendor/bytes/tests/test_buf.rs

raw
1 #![warn(rust_2018_idioms)]
2
3 use ::bytes::{Buf, Bytes, BytesMut};
4 use core::{cmp, mem};
5 use std::collections::VecDeque;
6 #[cfg(feature = "std")]
7 use std::io::IoSlice;
8
9 // A random 64-byte ascii string, with the first 8 bytes altered to
10 // give valid representations of f32 and f64 (making them easier to compare)
11 // and negative signed numbers when interpreting as big endian
12 // (testing Sign Extension for `Buf::get_int' and `Buf::get_int_ne`).
13 const INPUT: &[u8] = b"\xffFqrjrDqPhvTc45vvq33f6bJrUtyHESuTeklWKgYd64xgzxJwvAkpYYnpNJyZSRn";
14
15 macro_rules! e {
16 ($big_endian_val:expr, $little_endian_val:expr) => {
17 if cfg!(target_endian = "big") {
18 $big_endian_val
19 } else {
20 $little_endian_val
21 }
22 };
23 }
24
25 macro_rules! buf_tests {
26 ($make_input:ident) => {
27 buf_tests!($make_input, true);
28 };
29 ($make_input:ident, $checks_vectored_is_complete:expr) => {
30 use super::*;
31
32 #[test]
33 fn empty_state() {
34 let buf = $make_input(&[]);
35 assert_eq!(buf.remaining(), 0);
36 assert!(!buf.has_remaining());
37 assert!(buf.chunk().is_empty());
38 }
39
40 #[test]
41 fn fresh_state() {
42 let buf = $make_input(INPUT);
43 assert_eq!(buf.remaining(), 64);
44 assert!(buf.has_remaining());
45
46 let chunk = buf.chunk();
47 assert!(chunk.len() <= 64);
48 assert!(INPUT.starts_with(chunk));
49 }
50
51 #[test]
52 fn advance() {
53 let mut buf = $make_input(INPUT);
54 buf.advance(8);
55 assert_eq!(buf.remaining(), 64 - 8);
56 assert!(buf.has_remaining());
57
58 let chunk = buf.chunk();
59 assert!(chunk.len() <= 64 - 8);
60 assert!(INPUT[8..].starts_with(chunk));
61 }
62
63 #[test]
64 fn advance_to_end() {
65 let mut buf = $make_input(INPUT);
66 buf.advance(64);
67 assert_eq!(buf.remaining(), 0);
68 assert!(!buf.has_remaining());
69
70 let chunk = buf.chunk();
71 assert!(chunk.is_empty());
72 }
73
74 #[test]
75 #[should_panic]
76 fn advance_past_end() {
77 let mut buf = $make_input(INPUT);
78 buf.advance(65);
79 }
80
81 #[test]
82 #[cfg(feature = "std")]
83 fn chunks_vectored_empty() {
84 let buf = $make_input(&[]);
85 let mut bufs = [IoSlice::new(&[]); 16];
86
87 let n = buf.chunks_vectored(&mut bufs);
88 assert_eq!(n, 0);
89 assert!(bufs.iter().all(|buf| buf.is_empty()));
90 }
91
92 #[test]
93 #[cfg(feature = "std")]
94 fn chunks_vectored_is_complete() {
95 let buf = $make_input(INPUT);
96 let mut bufs = [IoSlice::new(&[]); 16];
97
98 let n = buf.chunks_vectored(&mut bufs);
99 assert!(n > 0);
100 assert!(n <= 16);
101
102 let bufs_concat = bufs[..n]
103 .iter()
104 .flat_map(|b| b.iter().copied())
105 .collect::<Vec<u8>>();
106 if $checks_vectored_is_complete {
107 assert_eq!(bufs_concat, INPUT);
108 } else {
109 // If this panics then `buf` implements `chunks_vectored`.
110 // Remove the `false` argument from `buf_tests!` for that type.
111 assert!(bufs_concat.len() < INPUT.len());
112 assert!(INPUT.starts_with(&bufs_concat));
113 }
114
115 for i in n..16 {
116 assert!(bufs[i].is_empty());
117 }
118 }
119
120 #[test]
121 fn copy_to_slice() {
122 let mut buf = $make_input(INPUT);
123
124 let mut chunk = [0u8; 8];
125 buf.copy_to_slice(&mut chunk);
126 assert_eq!(buf.remaining(), 64 - 8);
127 assert!(buf.has_remaining());
128 assert_eq!(chunk, INPUT[..8]);
129
130 let chunk = buf.chunk();
131 assert!(chunk.len() <= 64 - 8);
132 assert!(INPUT[8..].starts_with(chunk));
133 }
134
135 #[test]
136 fn copy_to_slice_big() {
137 let mut buf = $make_input(INPUT);
138
139 let mut chunk = [0u8; 56];
140 buf.copy_to_slice(&mut chunk);
141 assert_eq!(buf.remaining(), 64 - 56);
142 assert!(buf.has_remaining());
143 assert_eq!(chunk, INPUT[..56]);
144
145 let chunk = buf.chunk();
146 assert!(chunk.len() <= 64 - 56);
147 assert!(INPUT[56..].starts_with(chunk));
148 }
149
150 #[test]
151 fn copy_to_slice_to_end() {
152 let mut buf = $make_input(INPUT);
153
154 let mut chunk = [0u8; 64];
155 buf.copy_to_slice(&mut chunk);
156 assert_eq!(buf.remaining(), 0);
157 assert!(!buf.has_remaining());
158 assert_eq!(chunk, INPUT);
159
160 assert!(buf.chunk().is_empty());
161 }
162
163 #[test]
164 #[should_panic]
165 fn copy_to_slice_overflow() {
166 let mut buf = $make_input(INPUT);
167
168 let mut chunk = [0u8; 65];
169 buf.copy_to_slice(&mut chunk);
170 }
171
172 #[test]
173 fn copy_to_bytes() {
174 let mut buf = $make_input(INPUT);
175
176 let chunk = buf.copy_to_bytes(8);
177 assert_eq!(buf.remaining(), 64 - 8);
178 assert!(buf.has_remaining());
179 assert_eq!(chunk, INPUT[..8]);
180
181 let chunk = buf.chunk();
182 assert!(chunk.len() <= 64 - 8);
183 assert!(INPUT[8..].starts_with(chunk));
184 }
185
186 #[test]
187 fn copy_to_bytes_big() {
188 let mut buf = $make_input(INPUT);
189
190 let chunk = buf.copy_to_bytes(56);
191 assert_eq!(buf.remaining(), 64 - 56);
192 assert!(buf.has_remaining());
193 assert_eq!(chunk, INPUT[..56]);
194
195 let chunk = buf.chunk();
196 assert!(chunk.len() <= 64 - 56);
197 assert!(INPUT[56..].starts_with(chunk));
198 }
199
200 #[test]
201 fn copy_to_bytes_to_end() {
202 let mut buf = $make_input(INPUT);
203
204 let chunk = buf.copy_to_bytes(64);
205 assert_eq!(buf.remaining(), 0);
206 assert!(!buf.has_remaining());
207 assert_eq!(chunk, INPUT);
208
209 assert!(buf.chunk().is_empty());
210 }
211
212 #[test]
213 #[should_panic]
214 fn copy_to_bytes_overflow() {
215 let mut buf = $make_input(INPUT);
216
217 let _ = buf.copy_to_bytes(65);
218 }
219
220 buf_tests!(number $make_input, get_u8, get_u8_overflow, u8, get_u8, 0xff);
221 buf_tests!(number $make_input, get_i8, get_i8_overflow, i8, get_i8, 0xffu8 as i8);
222 buf_tests!(number $make_input, get_u16_be, get_u16_be_overflow, u16, get_u16, 0xff46);
223 buf_tests!(number $make_input, get_u16_le, get_u16_le_overflow, u16, get_u16_le, 0x46ff);
224 buf_tests!(number $make_input, get_u16_ne, get_u16_ne_overflow, u16, get_u16_ne, e!(0xff46, 0x46ff));
225 buf_tests!(number $make_input, get_i16_be, get_i16_be_overflow, i16, get_i16, 0xff46u16 as i16);
226 buf_tests!(number $make_input, get_i16_le, get_i16_le_overflow, i16, get_i16_le, 0x46ff);
227 buf_tests!(number $make_input, get_i16_ne, get_i16_ne_overflow, i16, get_i16_ne, e!(0xff46u16 as i16, 0x46ff));
228 buf_tests!(number $make_input, get_u32_be, get_u32_be_overflow, u32, get_u32, 0xff467172);
229 buf_tests!(number $make_input, get_u32_le, get_u32_le_overflow, u32, get_u32_le, 0x727146ff);
230 buf_tests!(number $make_input, get_u32_ne, get_u32_ne_overflow, u32, get_u32_ne, e!(0xff467172, 0x727146ff));
231 buf_tests!(number $make_input, get_i32_be, get_i32_be_overflow, i32, get_i32, 0xff467172u32 as i32);
232 buf_tests!(number $make_input, get_i32_le, get_i32_le_overflow, i32, get_i32_le, 0x727146ff);
233 buf_tests!(number $make_input, get_i32_ne, get_i32_ne_overflow, i32, get_i32_ne, e!(0xff467172u32 as i32, 0x727146ff));
234 buf_tests!(number $make_input, get_u64_be, get_u64_be_overflow, u64, get_u64, 0xff4671726a724471);
235 buf_tests!(number $make_input, get_u64_le, get_u64_le_overflow, u64, get_u64_le, 0x7144726a727146ff);
236 buf_tests!(number $make_input, get_u64_ne, get_u64_ne_overflow, u64, get_u64_ne, e!(0xff4671726a724471, 0x7144726a727146ff));
237 buf_tests!(number $make_input, get_i64_be, get_i64_be_overflow, i64, get_i64, 0xff4671726a724471u64 as i64);
238 buf_tests!(number $make_input, get_i64_le, get_i64_le_overflow, i64, get_i64_le, 0x7144726a727146ff);
239 buf_tests!(number $make_input, get_i64_ne, get_i64_ne_overflow, i64, get_i64_ne, e!(0xff4671726a724471u64 as i64, 0x7144726a727146ff));
240 buf_tests!(number $make_input, get_u128_be, get_u128_be_overflow, u128, get_u128, 0xff4671726a7244715068765463343576);
241 buf_tests!(number $make_input, get_u128_le, get_u128_le_overflow, u128, get_u128_le, 0x76353463547668507144726a727146ff);
242 buf_tests!(number $make_input, get_u128_ne, get_u128_ne_overflow, u128, get_u128_ne, e!(0xff4671726a7244715068765463343576, 0x76353463547668507144726a727146ff));
243 buf_tests!(number $make_input, get_i128_be, get_i128_be_overflow, i128, get_i128, 0xff4671726a7244715068765463343576u128 as i128);
244 buf_tests!(number $make_input, get_i128_le, get_i128_le_overflow, i128, get_i128_le, 0x76353463547668507144726a727146ff);
245 buf_tests!(number $make_input, get_i128_ne, get_i128_ne_overflow, i128, get_i128_ne, e!(0xff4671726a7244715068765463343576u128 as i128, 0x76353463547668507144726a727146ff));
246 buf_tests!(number $make_input, get_f32_be, get_f32_be_overflow, f32, get_f32, f32::from_bits(0xff467172));
247 buf_tests!(number $make_input, get_f32_le, get_f32_le_overflow, f32, get_f32_le, f32::from_bits(0x727146ff));
248 buf_tests!(number $make_input, get_f32_ne, get_f32_ne_overflow, f32, get_f32_ne, f32::from_bits(e!(0xff467172, 0x727146ff)));
249 buf_tests!(number $make_input, get_f64_be, get_f64_be_overflow, f64, get_f64, f64::from_bits(0xff4671726a724471));
250 buf_tests!(number $make_input, get_f64_le, get_f64_le_overflow, f64, get_f64_le, f64::from_bits(0x7144726a727146ff));
251 buf_tests!(number $make_input, get_f64_ne, get_f64_ne_overflow, f64, get_f64_ne, f64::from_bits(e!(0xff4671726a724471, 0x7144726a727146ff)));
252
253 buf_tests!(var_number $make_input, get_uint_be, get_uint_be_overflow, u64, get_uint, 3, 0xff4671);
254 buf_tests!(var_number $make_input, get_uint_le, get_uint_le_overflow, u64, get_uint_le, 3, 0x7146ff);
255 buf_tests!(var_number $make_input, get_uint_ne, get_uint_ne_overflow, u64, get_uint_ne, 3, e!(0xff4671, 0x7146ff));
256 buf_tests!(var_number $make_input, get_int_be, get_int_be_overflow, i64, get_int, 3, 0xffffffffffff4671u64 as i64);
257 buf_tests!(var_number $make_input, get_int_le, get_int_le_overflow, i64, get_int_le, 3, 0x7146ff);
258 buf_tests!(var_number $make_input, get_int_ne, get_int_ne_overflow, i64, get_int_ne, 3, e!(0xffffffffffff4671u64 as i64, 0x7146ff));
259 };
260 (number $make_input:ident, $ok_name:ident, $panic_name:ident, $number:ty, $method:ident, $value:expr) => {
261 #[test]
262 fn $ok_name() {
263 let mut buf = $make_input(INPUT);
264
265 let value = buf.$method();
266 assert_eq!(buf.remaining(), 64 - mem::size_of::<$number>());
267 assert!(buf.has_remaining());
268 assert_eq!(value, $value);
269 }
270
271 #[test]
272 #[should_panic]
273 fn $panic_name() {
274 let mut buf = $make_input(&[]);
275
276 let _ = buf.$method();
277 }
278 };
279 (var_number $make_input:ident, $ok_name:ident, $panic_name:ident, $number:ty, $method:ident, $len:expr, $value:expr) => {
280 #[test]
281 fn $ok_name() {
282 let mut buf = $make_input(INPUT);
283
284 let value = buf.$method($len);
285 assert_eq!(buf.remaining(), 64 - $len);
286 assert!(buf.has_remaining());
287 assert_eq!(value, $value);
288 }
289
290 #[test]
291 #[should_panic]
292 fn $panic_name() {
293 let mut buf = $make_input(&[]);
294
295 let _ = buf.$method($len);
296 }
297 };
298 }
299
300 mod u8_slice {
301 fn make_input(buf: &'static [u8]) -> &'static [u8] {
302 buf
303 }
304
305 buf_tests!(make_input);
306 }
307
308 mod bytes {
309 fn make_input(buf: &'static [u8]) -> impl Buf {
310 Bytes::from_static(buf)
311 }
312
313 buf_tests!(make_input);
314 }
315
316 mod bytes_mut {
317 fn make_input(buf: &'static [u8]) -> impl Buf {
318 BytesMut::from(buf)
319 }
320
321 buf_tests!(make_input);
322 }
323
324 mod vec_deque {
325 fn make_input(buf: &'static [u8]) -> impl Buf {
326 let mut deque = VecDeque::new();
327
328 if !buf.is_empty() {
329 // Construct |b|some bytes|a| `VecDeque`
330 let mid = buf.len() / 2;
331 let (a, b) = buf.split_at(mid);
332
333 deque.reserve_exact(buf.len() + 1);
334
335 let extra_space = deque.capacity() - b.len() - 1;
336 deque.resize(extra_space, 0);
337
338 deque.extend(a);
339 deque.drain(..extra_space);
340 deque.extend(b);
341
342 let (a, b) = deque.as_slices();
343 assert!(
344 !a.is_empty(),
345 "could not setup test - attempt to create discontiguous VecDeque failed"
346 );
347 assert!(
348 !b.is_empty(),
349 "could not setup test - attempt to create discontiguous VecDeque failed"
350 );
351 }
352
353 deque
354 }
355
356 buf_tests!(make_input, true);
357 }
358
359 #[cfg(feature = "std")]
360 mod cursor {
361 use std::io::Cursor;
362
363 fn make_input(buf: &'static [u8]) -> impl Buf {
364 Cursor::new(buf)
365 }
366
367 buf_tests!(make_input);
368 }
369
370 mod box_bytes {
371 fn make_input(buf: &'static [u8]) -> impl Buf {
372 Box::new(Bytes::from_static(buf))
373 }
374
375 buf_tests!(make_input);
376 }
377
378 mod chain_u8_slice {
379 fn make_input(buf: &'static [u8]) -> impl Buf {
380 let (a, b) = buf.split_at(buf.len() / 2);
381 Buf::chain(a, b)
382 }
383
384 buf_tests!(make_input);
385 }
386
387 mod chain_small_big_u8_slice {
388 fn make_input(buf: &'static [u8]) -> impl Buf {
389 let mid = cmp::min(1, buf.len());
390 let (a, b) = buf.split_at(mid);
391 Buf::chain(a, b)
392 }
393
394 buf_tests!(make_input);
395 }
396
397 mod chain_limited_slices {
398 fn make_input(buf: &'static [u8]) -> impl Buf {
399 let buf3 = &buf[cmp::min(buf.len(), 3)..];
400 let a = Buf::take(buf3, 0);
401 let b = Buf::take(buf, 3);
402 let c = Buf::take(buf3, usize::MAX);
403 let d = buf;
404 Buf::take(Buf::chain(Buf::chain(a, b), Buf::chain(c, d)), buf.len())
405 }
406
407 buf_tests!(make_input, true);
408 }
409
410 #[allow(unused_allocation)] // This is intentional.
411 #[test]
412 fn test_deref_buf_forwards() {
413 struct Special;
414
415 impl Buf for Special {
416 fn remaining(&self) -> usize {
417 unreachable!("remaining");
418 }
419
420 fn chunk(&self) -> &[u8] {
421 unreachable!("chunk");
422 }
423
424 fn advance(&mut self, _: usize) {
425 unreachable!("advance");
426 }
427
428 fn get_u8(&mut self) -> u8 {
429 // specialized!
430 b'x'
431 }
432 }
433
434 // these should all use the specialized method
435 assert_eq!(Special.get_u8(), b'x');
436 assert_eq!((&mut Special as &mut dyn Buf).get_u8(), b'x');
437 assert_eq!((Box::new(Special) as Box<dyn Buf>).get_u8(), b'x');
438 assert_eq!(Box::new(Special).get_u8(), b'x');
439 }