1 #![deny(warnings, rust_2018_idioms)]
2
3 use bytes::{buf::IoSliceMut, BufMut, BytesMut};
4 use std::usize;
5 use std::fmt::Write;
6
7 #[test]
test_vec_as_mut_buf()8 fn test_vec_as_mut_buf() {
9 let mut buf = Vec::with_capacity(64);
10
11 assert_eq!(buf.remaining_mut(), usize::MAX);
12
13 assert!(buf.bytes_mut().len() >= 64);
14
15 buf.put(&b"zomg"[..]);
16
17 assert_eq!(&buf, b"zomg");
18
19 assert_eq!(buf.remaining_mut(), usize::MAX - 4);
20 assert_eq!(buf.capacity(), 64);
21
22 for _ in 0..16 {
23 buf.put(&b"zomg"[..]);
24 }
25
26 assert_eq!(buf.len(), 68);
27 }
28
29 #[test]
test_put_u8()30 fn test_put_u8() {
31 let mut buf = Vec::with_capacity(8);
32 buf.put_u8(33);
33 assert_eq!(b"\x21", &buf[..]);
34 }
35
36 #[test]
test_put_u16()37 fn test_put_u16() {
38 let mut buf = Vec::with_capacity(8);
39 buf.put_u16(8532);
40 assert_eq!(b"\x21\x54", &buf[..]);
41
42 buf.clear();
43 buf.put_u16_le(8532);
44 assert_eq!(b"\x54\x21", &buf[..]);
45 }
46
47 #[test]
test_vec_advance_mut()48 fn test_vec_advance_mut() {
49 // Regression test for carllerche/bytes#108.
50 let mut buf = Vec::with_capacity(8);
51 unsafe {
52 buf.advance_mut(12);
53 assert_eq!(buf.len(), 12);
54 assert!(buf.capacity() >= 12, "capacity: {}", buf.capacity());
55 }
56 }
57
58 #[test]
test_clone()59 fn test_clone() {
60 let mut buf = BytesMut::with_capacity(100);
61 buf.write_str("this is a test").unwrap();
62 let buf2 = buf.clone();
63
64 buf.write_str(" of our emergency broadcast system").unwrap();
65 assert!(buf != buf2);
66 }
67
68 #[test]
test_bufs_vec_mut()69 fn test_bufs_vec_mut() {
70 let b1: &mut [u8] = &mut [];
71 let b2: &mut [u8] = &mut [];
72 let mut dst = [IoSliceMut::from(b1), IoSliceMut::from(b2)];
73
74 // with no capacity
75 let mut buf = BytesMut::new();
76 assert_eq!(buf.capacity(), 0);
77 assert_eq!(1, buf.bytes_vectored_mut(&mut dst[..]));
78
79 // with capacity
80 let mut buf = BytesMut::with_capacity(64);
81 assert_eq!(1, buf.bytes_vectored_mut(&mut dst[..]));
82 }
83
84 #[test]
test_mut_slice()85 fn test_mut_slice() {
86 let mut v = vec![0, 0, 0, 0];
87 let mut s = &mut v[..];
88 s.put_u32(42);
89 }
90
91 #[test]
test_deref_bufmut_forwards()92 fn test_deref_bufmut_forwards() {
93 struct Special;
94
95 impl BufMut for Special {
96 fn remaining_mut(&self) -> usize {
97 unreachable!("remaining_mut");
98 }
99
100 fn bytes_mut(&mut self) -> &mut [std::mem::MaybeUninit<u8>] {
101 unreachable!("bytes_mut");
102 }
103
104 unsafe fn advance_mut(&mut self, _: usize) {
105 unreachable!("advance");
106 }
107
108 fn put_u8(&mut self, _: u8) {
109 // specialized!
110 }
111 }
112
113 // these should all use the specialized method
114 Special.put_u8(b'x');
115 (&mut Special as &mut dyn BufMut).put_u8(b'x');
116 (Box::new(Special) as Box<dyn BufMut>).put_u8(b'x');
117 Box::new(Special).put_u8(b'x');
118 }
119