1 #![warn(rust_2018_idioms)]
2
3 use bytes::Buf;
4 #[cfg(feature = "std")]
5 use std::io::IoSlice;
6
7 #[test]
test_fresh_cursor_vec()8 fn test_fresh_cursor_vec() {
9 let mut buf = &b"hello"[..];
10
11 assert_eq!(buf.remaining(), 5);
12 assert_eq!(buf.chunk(), b"hello");
13
14 buf.advance(2);
15
16 assert_eq!(buf.remaining(), 3);
17 assert_eq!(buf.chunk(), b"llo");
18
19 buf.advance(3);
20
21 assert_eq!(buf.remaining(), 0);
22 assert_eq!(buf.chunk(), b"");
23 }
24
25 #[test]
test_get_u8()26 fn test_get_u8() {
27 let mut buf = &b"\x21zomg"[..];
28 assert_eq!(0x21, buf.get_u8());
29 }
30
31 #[test]
test_get_u16()32 fn test_get_u16() {
33 let mut buf = &b"\x21\x54zomg"[..];
34 assert_eq!(0x2154, buf.get_u16());
35 let mut buf = &b"\x21\x54zomg"[..];
36 assert_eq!(0x5421, buf.get_u16_le());
37 }
38
39 #[test]
test_get_int()40 fn test_get_int() {
41 let mut buf = &b"\xd6zomg"[..];
42 assert_eq!(-42, buf.get_int(1));
43 let mut buf = &b"\xd6zomg"[..];
44 assert_eq!(-42, buf.get_int_le(1));
45
46 let mut buf = &b"\xfe\x1d\xc0zomg"[..];
47 assert_eq!(0xffffffffffc01dfeu64 as i64, buf.get_int_le(3));
48 let mut buf = &b"\xfe\x1d\xc0zomg"[..];
49 assert_eq!(0xfffffffffffe1dc0u64 as i64, buf.get_int(3));
50 }
51
52 #[test]
53 #[should_panic]
test_get_u16_buffer_underflow()54 fn test_get_u16_buffer_underflow() {
55 let mut buf = &b"\x21"[..];
56 buf.get_u16();
57 }
58
59 #[cfg(feature = "std")]
60 #[test]
test_bufs_vec()61 fn test_bufs_vec() {
62 let buf = &b"hello world"[..];
63
64 let b1: &[u8] = &mut [];
65 let b2: &[u8] = &mut [];
66
67 let mut dst = [IoSlice::new(b1), IoSlice::new(b2)];
68
69 assert_eq!(1, buf.chunks_vectored(&mut dst[..]));
70 }
71
72 #[test]
test_vec_deque()73 fn test_vec_deque() {
74 use std::collections::VecDeque;
75
76 let mut buffer: VecDeque<u8> = VecDeque::new();
77 buffer.extend(b"hello world");
78 assert_eq!(11, buffer.remaining());
79 assert_eq!(b"hello world", buffer.chunk());
80 buffer.advance(6);
81 assert_eq!(b"world", buffer.chunk());
82 buffer.extend(b" piece");
83 let mut out = [0; 11];
84 buffer.copy_to_slice(&mut out);
85 assert_eq!(b"world piece", &out[..]);
86 }
87
88 #[allow(unused_allocation)] // This is intentional.
89 #[test]
test_deref_buf_forwards()90 fn test_deref_buf_forwards() {
91 struct Special;
92
93 impl Buf for Special {
94 fn remaining(&self) -> usize {
95 unreachable!("remaining");
96 }
97
98 fn chunk(&self) -> &[u8] {
99 unreachable!("chunk");
100 }
101
102 fn advance(&mut self, _: usize) {
103 unreachable!("advance");
104 }
105
106 fn get_u8(&mut self) -> u8 {
107 // specialized!
108 b'x'
109 }
110 }
111
112 // these should all use the specialized method
113 assert_eq!(Special.get_u8(), b'x');
114 assert_eq!((&mut Special as &mut dyn Buf).get_u8(), b'x');
115 assert_eq!((Box::new(Special) as Box<dyn Buf>).get_u8(), b'x');
116 assert_eq!(Box::new(Special).get_u8(), b'x');
117 }
118
119 #[test]
copy_to_bytes_less()120 fn copy_to_bytes_less() {
121 let mut buf = &b"hello world"[..];
122
123 let bytes = buf.copy_to_bytes(5);
124 assert_eq!(bytes, &b"hello"[..]);
125 assert_eq!(buf, &b" world"[..])
126 }
127
128 #[test]
129 #[should_panic]
copy_to_bytes_overflow()130 fn copy_to_bytes_overflow() {
131 let mut buf = &b"hello world"[..];
132
133 let _bytes = buf.copy_to_bytes(12);
134 }
135