Bump version to v0.4.6

* Handle empty self and other for unsplit.
* Change extend() to extend_from_slice().

.travis.yml

@@ -33,6 +33,9 @@ matrix:
     - env: RUST_TEST_THREADS=1 TARGET=powerpc-unknown-linux-gnu
     - env: RUST_TEST_THREADS=1 TARGET=powerpc64-unknown-linux-gnu
 
+    # Serde implementation
+    - env: EXTRA_ARGS="--features serde"
+
 before_install: set -e
 
 install:

CHANGELOG.md

@@ -1,10 +1,33 @@
-# 0.4.3 (April, 30, 2017)
+# 0.4.6 (Janary 8, 2018)
+
+* Implement FromIterator for Bytes/BytesMut (#148).
+* Add `advance` fn to Bytes/BytesMut (#166).
+* Add `unsplit` fn to `BytesMut` (#162, #173).
+* Improvements to Bytes split fns (#92).
+
+# 0.4.5 (August 12, 2017)
+
+* Fix range bug in `Take::bytes`
+* Misc performance improvements
+* Add extra `PartialEq` implementations.
+* Add `Bytes::with_capacity`
+* Implement `AsMut[u8]` for `BytesMut`
+
+# 0.4.4 (May 26, 2017)
+
+* Add serde support behind feature flag
+* Add `extend_from_slice` on `Bytes` and `BytesMut`
+* Add `truncate` and `clear` on `Bytes`
+* Misc additional std trait implementations
+* Misc performance improvements
+
+# 0.4.3 (April 30, 2017)
 
 * Fix Vec::advance_mut bug
 * Bump minimum Rust version to 1.15
 * Misc performance tweaks
 
-# 0.4.2 (April, 5, 2017)
+# 0.4.2 (April 5, 2017)
 
 * Misc performance tweaks
 * Improved `Debug` implementation for `Bytes`

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 
 name          = "bytes"
-version       = "0.4.3"
-license       = "MIT"
+version       = "0.4.6" # don't forget to update html_root_url
+license       = "MIT/Apache-2.0"
 authors       = ["Carl Lerche <[email protected]>"]
 description   = "Types and traits for working with bytes"
 documentation = "https://carllerche.github.io/bytes/bytes"
@@ -22,6 +22,7 @@ categories = ["network-programming", "data-structures"]
 [dependencies]
 byteorder = "1.0.0"
 iovec = "0.1"
+serde = { version = "1.0", optional = true }
 
 [dev-dependencies]
-tokio-core = "0.1.0"
+serde_test = "1.0"

README.md

@@ -24,6 +24,15 @@ extern crate bytes;
 use bytes::{Bytes, BytesMut, Buf, BufMut};
 ```
 
+## Serde support
+
+Serde support is optional and disabled by default. To enable use the feature `serde`.
+
+```toml
+[dependencies]
+bytes = { version = "0.4", features = ["serde"] }
+```
+
 # License
 
 `bytes` is primarily distributed under the terms of both the MIT license and the

benches/bytes.rs

@@ -0,0 +1,217 @@
+#![feature(test)]
+
+extern crate bytes;
+extern crate test;
+
+use test::Bencher;
+use bytes::{Bytes, BytesMut, BufMut};
+
+#[bench]
+fn alloc_small(b: &mut Bencher) {
+    b.iter(|| {
+        for _ in 0..1024 {
+            test::black_box(BytesMut::with_capacity(12));
+        }
+    })
+}
+
+#[bench]
+fn alloc_mid(b: &mut Bencher) {
+    b.iter(|| {
+        test::black_box(BytesMut::with_capacity(128));
+    })
+}
+
+#[bench]
+fn alloc_big(b: &mut Bencher) {
+    b.iter(|| {
+        test::black_box(BytesMut::with_capacity(4096));
+    })
+}
+
+#[bench]
+fn split_off_and_drop(b: &mut Bencher) {
+    b.iter(|| {
+        for _ in 0..1024 {
+            let v = vec![10; 200];
+            let mut b = Bytes::from(v);
+            test::black_box(b.split_off(100));
+            test::black_box(b);
+        }
+    })
+}
+
+#[bench]
+fn deref_unique(b: &mut Bencher) {
+    let mut buf = BytesMut::with_capacity(4096);
+    buf.put(&[0u8; 1024][..]);
+
+    b.iter(|| {
+        for _ in 0..1024 {
+            test::black_box(&buf[..]);
+        }
+    })
+}
+
+#[bench]
+fn deref_unique_unroll(b: &mut Bencher) {
+    let mut buf = BytesMut::with_capacity(4096);
+    buf.put(&[0u8; 1024][..]);
+
+    b.iter(|| {
+        for _ in 0..128 {
+            test::black_box(&buf[..]);
+            test::black_box(&buf[..]);
+            test::black_box(&buf[..]);
+            test::black_box(&buf[..]);
+            test::black_box(&buf[..]);
+            test::black_box(&buf[..]);
+            test::black_box(&buf[..]);
+            test::black_box(&buf[..]);
+        }
+    })
+}
+
+#[bench]
+fn deref_shared(b: &mut Bencher) {
+    let mut buf = BytesMut::with_capacity(4096);
+    buf.put(&[0u8; 1024][..]);
+    let _b2 = buf.split_off(1024);
+
+    b.iter(|| {
+        for _ in 0..1024 {
+            test::black_box(&buf[..]);
+        }
+    })
+}
+
+#[bench]
+fn deref_inline(b: &mut Bencher) {
+    let mut buf = BytesMut::with_capacity(8);
+    buf.put(&[0u8; 8][..]);
+
+    b.iter(|| {
+        for _ in 0..1024 {
+            test::black_box(&buf[..]);
+        }
+    })
+}
+
+#[bench]
+fn deref_two(b: &mut Bencher) {
+    let mut buf1 = BytesMut::with_capacity(8);
+    buf1.put(&[0u8; 8][..]);
+
+    let mut buf2 = BytesMut::with_capacity(4096);
+    buf2.put(&[0u8; 1024][..]);
+
+    b.iter(|| {
+        for _ in 0..512 {
+            test::black_box(&buf1[..]);
+            test::black_box(&buf2[..]);
+        }
+    })
+}
+
+#[bench]
+fn alloc_write_split_to_mid(b: &mut Bencher) {
+    b.iter(|| {
+        let mut buf = BytesMut::with_capacity(128);
+        buf.put_slice(&[0u8; 64]);
+        test::black_box(buf.split_to(64));
+    })
+}
+
+#[bench]
+fn drain_write_drain(b: &mut Bencher) {
+    let data = [0u8; 128];
+
+    b.iter(|| {
+        let mut buf = BytesMut::with_capacity(1024);
+        let mut parts = Vec::with_capacity(8);
+
+        for _ in 0..8 {
+            buf.put(&data[..]);
+            parts.push(buf.split_to(128));
+        }
+
+        test::black_box(parts);
+    })
+}
+
+#[bench]
+fn fmt_write(b: &mut Bencher) {
+    use std::fmt::Write;
+    let mut buf = BytesMut::with_capacity(128);
+    let s = "foo bar baz quux lorem ipsum dolor et";
+
+    b.bytes = s.len() as u64;
+    b.iter(|| {
+        let _ = write!(buf, "{}", s);
+        test::black_box(&buf);
+        unsafe { buf.set_len(0); }
+    })
+}
+
+#[bench]
+fn from_long_slice(b: &mut Bencher) {
+    let data = [0u8; 128];
+    b.bytes = data.len() as u64;
+    b.iter(|| {
+        let buf = BytesMut::from(&data[..]);
+        test::black_box(buf);
+    })
+}
+
+#[bench]
+fn slice_empty(b: &mut Bencher) {
+    b.iter(|| {
+        let b = Bytes::from(vec![17; 1024]).clone();
+        for i in 0..1000 {
+            test::black_box(b.slice(i % 100, i % 100));
+        }
+    })
+}
+
+#[bench]
+fn slice_short_from_arc(b: &mut Bencher) {
+    b.iter(|| {
+        // `clone` is to convert to ARC
+        let b = Bytes::from(vec![17; 1024]).clone();
+        for i in 0..1000 {
+            test::black_box(b.slice(1, 2 + i % 10));
+        }
+    })
+}
+
+// Keep in sync with bytes.rs
+#[cfg(target_pointer_width = "64")]
+const INLINE_CAP: usize = 4 * 8 - 1;
+#[cfg(target_pointer_width = "32")]
+const INLINE_CAP: usize = 4 * 4 - 1;
+
+#[bench]
+fn slice_avg_le_inline_from_arc(b: &mut Bencher) {
+    b.iter(|| {
+        // `clone` is to convert to ARC
+        let b = Bytes::from(vec![17; 1024]).clone();
+        for i in 0..1000 {
+            // [1, INLINE_CAP]
+            let len = 1 + i % (INLINE_CAP - 1);
+            test::black_box(b.slice(i % 10, i % 10 + len));
+        }
+    })
+}
+
+#[bench]
+fn slice_large_le_inline_from_arc(b: &mut Bencher) {
+    b.iter(|| {
+        // `clone` is to convert to ARC
+        let b = Bytes::from(vec![17; 1024]).clone();
+        for i in 0..1000 {
+            // [INLINE_CAP - 10, INLINE_CAP]
+            let len = INLINE_CAP - 9 + i % 10;
+            test::black_box(b.slice(i % 10, i % 10 + len));
+        }
+    })
+}

benches/vs_easy_buf.rs

@@ -1,210 +0,0 @@
-#![feature(test)]
-
-extern crate tokio_core;
-extern crate bytes;
-extern crate test;
-
-mod bench_easy_buf {
-    use test::{self, Bencher};
-    use tokio_core::io::EasyBuf;
-
-    #[bench]
-    fn alloc_small(b: &mut Bencher) {
-        b.iter(|| {
-            for _ in 0..1024 {
-                test::black_box(EasyBuf::with_capacity(12));
-            }
-        })
-    }
-
-    #[bench]
-    fn alloc_mid(b: &mut Bencher) {
-        b.iter(|| {
-            test::black_box(EasyBuf::with_capacity(128));
-        })
-    }
-
-    #[bench]
-    fn alloc_big(b: &mut Bencher) {
-        b.iter(|| {
-            test::black_box(EasyBuf::with_capacity(4096));
-        })
-    }
-
-    #[bench]
-    fn deref_front(b: &mut Bencher) {
-        let mut buf = EasyBuf::with_capacity(4096);
-        buf.get_mut().extend_from_slice(&[0; 1024][..]);
-
-        b.iter(|| {
-            for _ in 0..1024 {
-                test::black_box(buf.as_slice());
-            }
-        })
-    }
-
-    #[bench]
-    fn deref_mid(b: &mut Bencher) {
-        let mut buf = EasyBuf::with_capacity(4096);
-        buf.get_mut().extend_from_slice(&[0; 1024][..]);
-        let _a = buf.drain_to(512);
-
-        b.iter(|| {
-            for _ in 0..1024 {
-                test::black_box(buf.as_slice());
-            }
-        })
-    }
-
-    #[bench]
-    fn alloc_write_drain_to_mid(b: &mut Bencher) {
-        b.iter(|| {
-            let mut buf = EasyBuf::with_capacity(128);
-            buf.get_mut().extend_from_slice(&[0u8; 64]);
-            test::black_box(buf.drain_to(64));
-        })
-    }
-
-    #[bench]
-    fn drain_write_drain(b: &mut Bencher) {
-        let data = [0u8; 128];
-
-        b.iter(|| {
-            let mut buf = EasyBuf::with_capacity(1024);
-            let mut parts = Vec::with_capacity(8);
-
-            for _ in 0..8 {
-                buf.get_mut().extend_from_slice(&data[..]);
-                parts.push(buf.drain_to(128));
-            }
-
-            test::black_box(parts);
-        })
-    }
-}
-
-mod bench_bytes {
-    use test::{self, Bencher};
-    use bytes::{BytesMut, BufMut};
-
-    #[bench]
-    fn alloc_small(b: &mut Bencher) {
-        b.iter(|| {
-            for _ in 0..1024 {
-                test::black_box(BytesMut::with_capacity(12));
-            }
-        })
-    }
-
-    #[bench]
-    fn alloc_mid(b: &mut Bencher) {
-        b.iter(|| {
-            test::black_box(BytesMut::with_capacity(128));
-        })
-    }
-
-    #[bench]
-    fn alloc_big(b: &mut Bencher) {
-        b.iter(|| {
-            test::black_box(BytesMut::with_capacity(4096));
-        })
-    }
-
-    #[bench]
-    fn deref_unique(b: &mut Bencher) {
-        let mut buf = BytesMut::with_capacity(4096);
-        buf.put(&[0u8; 1024][..]);
-
-        b.iter(|| {
-            for _ in 0..1024 {
-                test::black_box(&buf[..]);
-            }
-        })
-    }
-
-    #[bench]
-    fn deref_unique_unroll(b: &mut Bencher) {
-        let mut buf = BytesMut::with_capacity(4096);
-        buf.put(&[0u8; 1024][..]);
-
-        b.iter(|| {
-            for _ in 0..128 {
-                test::black_box(&buf[..]);
-                test::black_box(&buf[..]);
-                test::black_box(&buf[..]);
-                test::black_box(&buf[..]);
-                test::black_box(&buf[..]);
-                test::black_box(&buf[..]);
-                test::black_box(&buf[..]);
-                test::black_box(&buf[..]);
-            }
-        })
-    }
-
-    #[bench]
-    fn deref_shared(b: &mut Bencher) {
-        let mut buf = BytesMut::with_capacity(4096);
-        buf.put(&[0u8; 1024][..]);
-        let _b2 = buf.split_off(1024);
-
-        b.iter(|| {
-            for _ in 0..1024 {
-                test::black_box(&buf[..]);
-            }
-        })
-    }
-
-    #[bench]
-    fn deref_inline(b: &mut Bencher) {
-        let mut buf = BytesMut::with_capacity(8);
-        buf.put(&[0u8; 8][..]);
-
-        b.iter(|| {
-            for _ in 0..1024 {
-                test::black_box(&buf[..]);
-            }
-        })
-    }
-
-    #[bench]
-    fn deref_two(b: &mut Bencher) {
-        let mut buf1 = BytesMut::with_capacity(8);
-        buf1.put(&[0u8; 8][..]);
-
-        let mut buf2 = BytesMut::with_capacity(4096);
-        buf2.put(&[0u8; 1024][..]);
-
-        b.iter(|| {
-            for _ in 0..512 {
-                test::black_box(&buf1[..]);
-                test::black_box(&buf2[..]);
-            }
-        })
-    }
-
-    #[bench]
-    fn alloc_write_drain_to_mid(b: &mut Bencher) {
-        b.iter(|| {
-            let mut buf = BytesMut::with_capacity(128);
-            buf.put_slice(&[0u8; 64]);
-            test::black_box(buf.drain_to(64));
-        })
-    }
-
-    #[bench]
-    fn drain_write_drain(b: &mut Bencher) {
-        let data = [0u8; 128];
-
-        b.iter(|| {
-            let mut buf = BytesMut::with_capacity(1024);
-            let mut parts = Vec::with_capacity(8);
-
-            for _ in 0..8 {
-                buf.put(&data[..]);
-                parts.push(buf.drain_to(128));
-            }
-
-            test::black_box(parts);
-        })
-    }
-}

ci/script.sh

@@ -3,13 +3,13 @@
 set -ex
 
 main() {
-    cross build --target $TARGET
+    cross build --target $TARGET $EXTRA_ARGS
 
     if [ ! -z $DISABLE_TESTS ]; then
         return
     fi
 
-    cross test --target $TARGET
+    cross test --target $TARGET $EXTRA_ARGS
 }
 
 # we don't run the "test phase" when doing deploys

src/buf/iter.rs

@@ -112,3 +112,5 @@ impl<T: Buf> Iterator for Iter<T> {
         (rem, Some(rem))
     }
 }
+
+impl<T: Buf> ExactSizeIterator for Iter<T> { }

src/buf/take.rs

@@ -143,7 +143,8 @@ impl<T: Buf> Buf for Take<T> {
     }
 
     fn bytes(&self) -> &[u8] {
-        &self.inner.bytes()[..self.limit]
+        let bytes = self.inner.bytes();
+        &bytes[..cmp::min(bytes.len(), self.limit)]
     }
 
     fn advance(&mut self, cnt: usize) {

src/debug.rs

@@ -27,8 +27,8 @@ impl<'a> fmt::Debug for BsDebug<'a> {
                 try!(write!(fmt, "\\{}", c as char));
             } else if c == b'\0' {
                 try!(write!(fmt, "\\0"));
-            // ASCII printable except space
-            } else if c > 0x20 && c < 0x7f {
+            // ASCII printable
+            } else if c >= 0x20 && c < 0x7f {
                 try!(write!(fmt, "{}", c as char));
             } else {
                 try!(write!(fmt, "\\x{:02x}", c));

src/lib.rs

@@ -62,14 +62,14 @@
 //! ## Relation with `Read` and `Write`
 //!
 //! At first glance, it may seem that `Buf` and `BufMut` overlap in
-//! functionality with `std::io::Ready` and `std::io::Write`. However, they
+//! functionality with `std::io::Read` and `std::io::Write`. However, they
 //! serve different purposes. A buffer is the value that is provided as an
 //! argument to `Read::read` and `Write::write`. `Read` and `Write` may then
 //! perform a syscall, which has the potential of failing. Operations on `Buf`
 //! and `BufMut` are infallible.
 
 #![deny(warnings, missing_docs, missing_debug_implementations)]
-#![doc(html_root_url = "https://docs.rs/bytes/0.4")]
+#![doc(html_root_url = "https://docs.rs/bytes/0.4.6")]
 
 extern crate byteorder;
 extern crate iovec;
@@ -93,3 +93,8 @@ mod debug;
 pub use bytes::{Bytes, BytesMut};
 
 pub use byteorder::{ByteOrder, BigEndian, LittleEndian};
+
+// Optional Serde support
+#[cfg(feature = "serde")]
+#[doc(hidden)]
+pub mod serde;

src/serde.rs

@@ -0,0 +1,82 @@
+extern crate serde;
+
+use std::{cmp, fmt};
+use self::serde::{Serialize, Serializer, Deserialize, Deserializer, de};
+use super::{Bytes, BytesMut};
+
+macro_rules! serde_impl {
+    ($ty:ident, $visitor_ty:ident) => (
+        impl Serialize for $ty {
+            #[inline]
+            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+                where S: Serializer
+            {
+                serializer.serialize_bytes(&self)
+            }
+        }
+
+        struct $visitor_ty;
+
+        impl<'de> de::Visitor<'de> for $visitor_ty {
+            type Value = $ty;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("byte array")
+            }
+
+            #[inline]
+            fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
+                where V: de::SeqAccess<'de>
+            {
+                let len = cmp::min(seq.size_hint().unwrap_or(0), 4096);
+                let mut values = Vec::with_capacity(len);
+
+                while let Some(value) = try!(seq.next_element()) {
+                    values.push(value);
+                }
+
+                Ok(values.into())
+            }
+
+            #[inline]
+            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+                where E: de::Error
+            {
+                Ok($ty::from(v))
+            }
+
+            #[inline]
+            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
+                where E: de::Error
+            {
+                Ok($ty::from(v))
+            }
+
+            #[inline]
+            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+                where E: de::Error
+            {
+                Ok($ty::from(v))
+            }
+
+            #[inline]
+            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
+                where E: de::Error
+            {
+                Ok($ty::from(v))
+            }
+        }
+
+        impl<'de> Deserialize<'de> for $ty {
+            #[inline]
+            fn deserialize<D>(deserializer: D) -> Result<$ty, D::Error>
+                where D: Deserializer<'de>
+            {
+                deserializer.deserialize_byte_buf($visitor_ty)
+            }
+        }
+    );
+}
+
+serde_impl!(Bytes, BytesVisitor);
+serde_impl!(BytesMut, BytesMutVisitor);

tests/test_buf.rs

@@ -47,7 +47,12 @@ fn test_get_u16_buffer_underflow() {
 #[test]
 fn test_bufs_vec() {
     let buf = Cursor::new(b"hello world");
-    let mut dst: [&IoVec; 2] = Default::default();
+
+    let b1: &[u8] = &mut [0];
+    let b2: &[u8] = &mut [0];
+
+    let mut dst: [&IoVec; 2] =
+        [b1.into(), b2.into()];
 
     assert_eq!(1, buf.bytes_vec(&mut dst[..]));
 }

tests/test_bytes.rs

@@ -51,6 +51,28 @@ fn fmt() {
     assert_eq!(a, b);
 }
 
+#[test]
+fn fmt_write() {
+    use std::fmt::Write;
+    use std::iter::FromIterator;
+    let s = String::from_iter((0..10).map(|_| "abcdefg"));
+
+    let mut a = BytesMut::with_capacity(64);
+    write!(a, "{}", &s[..64]).unwrap();
+    assert_eq!(a, s[..64].as_bytes());
+
+
+    let mut b = BytesMut::with_capacity(64);
+    write!(b, "{}", &s[..32]).unwrap();
+    write!(b, "{}", &s[32..64]).unwrap();
+    assert_eq!(b, s[..64].as_bytes());
+
+
+    let mut c = BytesMut::with_capacity(64);
+    write!(c, "{}", s).unwrap_err();
+    assert!(c.is_empty());
+}
+
 #[test]
 fn len() {
     let a = Bytes::from(&b"abcdefg"[..]);
@@ -79,6 +101,15 @@ fn slice() {
     let b = a.slice(3, 5);
     assert_eq!(b, b"lo"[..]);
 
+    let b = a.slice(0, 0);
+    assert_eq!(b, b""[..]);
+
+    let b = a.slice(3, 3);
+    assert_eq!(b, b""[..]);
+
+    let b = a.slice(a.len(), a.len());
+    assert_eq!(b, b""[..]);
+
     let b = a.slice_to(5);
     assert_eq!(b, b"hello"[..]);
 
@@ -302,7 +333,7 @@ fn reserve_convert() {
     let a = bytes.split_to(30);
 
     bytes.reserve(128);
-    assert_eq!(bytes.capacity(), (bytes.len() + 128).next_power_of_two());
+    assert!(bytes.capacity() >= bytes.len() + 128);
 
     drop(a);
 }
@@ -319,16 +350,16 @@ fn reserve_growth() {
 
 #[test]
 fn reserve_allocates_at_least_original_capacity() {
-    let mut bytes = BytesMut::with_capacity(128);
+    let mut bytes = BytesMut::with_capacity(1024);
 
-    for i in 0..120 {
+    for i in 0..1020 {
         bytes.put(i as u8);
     }
 
     let _other = bytes.take();
 
     bytes.reserve(16);
-    assert_eq!(bytes.capacity(), 128);
+    assert_eq!(bytes.capacity(), 1024);
 }
 
 #[test]
@@ -347,6 +378,42 @@ fn reserve_max_original_capacity_value() {
     assert_eq!(bytes.capacity(), 64 * 1024);
 }
 
+#[test]
+fn reserve_in_arc_unique_does_not_overallocate() {
+    let mut bytes = BytesMut::with_capacity(1000);
+    bytes.take();
+
+    // now bytes is Arc and refcount == 1
+
+    assert_eq!(1000, bytes.capacity());
+    bytes.reserve(2001);
+    assert_eq!(2001, bytes.capacity());
+}
+
+#[test]
+fn reserve_in_arc_unique_doubles() {
+    let mut bytes = BytesMut::with_capacity(1000);
+    bytes.take();
+
+    // now bytes is Arc and refcount == 1
+
+    assert_eq!(1000, bytes.capacity());
+    bytes.reserve(1001);
+    assert_eq!(2000, bytes.capacity());
+}
+
+#[test]
+fn reserve_in_arc_nonunique_does_not_overallocate() {
+    let mut bytes = BytesMut::with_capacity(1000);
+    let _copy = bytes.take();
+
+    // now bytes is Arc and refcount == 2
+
+    assert_eq!(1000, bytes.capacity());
+    bytes.reserve(2001);
+    assert_eq!(2001, bytes.capacity());
+}
+
 #[test]
 fn inline_storage() {
     let mut bytes = BytesMut::with_capacity(inline_cap());
@@ -357,12 +424,39 @@ fn inline_storage() {
 }
 
 #[test]
-fn extend() {
+fn extend_mut() {
     let mut bytes = BytesMut::with_capacity(0);
     bytes.extend(LONG);
     assert_eq!(*bytes, LONG[..]);
 }
 
+#[test]
+fn extend_shr() {
+    let mut bytes = Bytes::new();
+    bytes.extend(LONG);
+    assert_eq!(*bytes, LONG[..]);
+}
+
+#[test]
+fn extend_from_slice_mut() {
+    for &i in &[3, 34] {
+        let mut bytes = BytesMut::new();
+        bytes.extend_from_slice(&LONG[..i]);
+        bytes.extend_from_slice(&LONG[i..]);
+        assert_eq!(LONG[..], *bytes);
+    }
+}
+
+#[test]
+fn extend_from_slice_shr() {
+    for &i in &[3, 34] {
+        let mut bytes = Bytes::new();
+        bytes.extend_from_slice(&LONG[..i]);
+        bytes.extend_from_slice(&LONG[i..]);
+        assert_eq!(LONG[..], *bytes);
+    }
+}
+
 #[test]
 fn from_static() {
     let mut a = Bytes::from_static(b"ab");
@@ -372,6 +466,44 @@ fn from_static() {
     assert_eq!(b, b"b"[..]);
 }
 
+#[test]
+fn advance_inline() {
+    let mut a = Bytes::from(&b"hello world"[..]);
+    a.advance(6);
+    assert_eq!(a, &b"world"[..]);
+}
+
+#[test]
+fn advance_static() {
+    let mut a = Bytes::from_static(b"hello world");
+    a.advance(6);
+    assert_eq!(a, &b"world"[..]);
+}
+
+#[test]
+fn advance_vec() {
+    let mut a = BytesMut::from(b"hello world boooo yah world zomg wat wat".to_vec());
+    a.advance(16);
+    assert_eq!(a, b"o yah world zomg wat wat"[..]);
+
+    a.advance(4);
+    assert_eq!(a, b"h world zomg wat wat"[..]);
+
+    // Reserve some space.
+    a.reserve(1024);
+    assert_eq!(a, b"h world zomg wat wat"[..]);
+
+    a.advance(6);
+    assert_eq!(a, b"d zomg wat wat"[..]);
+}
+
+#[test]
+#[should_panic]
+fn advance_past_len() {
+    let mut a = BytesMut::from(b"hello world".to_vec());
+    a.advance(20);
+}
+
 #[test]
 // Only run these tests on little endian systems. CI uses qemu for testing
 // little endian... and qemu doesn't really support threading all that well.
@@ -409,3 +541,136 @@ fn stress() {
         assert_eq!(*buf, data[..]);
     }
 }
+
+#[test]
+fn partial_eq_bytesmut() {
+    let bytes = Bytes::from(&b"The quick red fox"[..]);
+    let bytesmut = BytesMut::from(&b"The quick red fox"[..]);
+    assert!(bytes == bytesmut);
+    assert!(bytesmut == bytes);
+    let bytes2 = Bytes::from(&b"Jumped over the lazy brown dog"[..]);
+    assert!(bytes2 != bytesmut);
+    assert!(bytesmut != bytes2);
+}
+
+#[test]
+fn unsplit_basic() {
+    let mut buf = BytesMut::with_capacity(64);
+    buf.extend_from_slice(b"aaabbbcccddd");
+
+    let splitted = buf.split_off(6);
+    assert_eq!(b"aaabbb", &buf[..]);
+    assert_eq!(b"cccddd", &splitted[..]);
+
+    buf.unsplit(splitted);
+    assert_eq!(b"aaabbbcccddd", &buf[..]);
+}
+
+#[test]
+fn unsplit_empty_other() {
+    let mut buf = BytesMut::with_capacity(64);
+    buf.extend_from_slice(b"aaabbbcccddd");
+
+    // empty other
+    let other = BytesMut::new();
+
+    buf.unsplit(other);
+    assert_eq!(b"aaabbbcccddd", &buf[..]);
+}
+
+#[test]
+fn unsplit_empty_self() {
+    // empty self
+    let mut buf = BytesMut::new();
+
+    let mut other = BytesMut::with_capacity(64);
+    other.extend_from_slice(b"aaabbbcccddd");
+
+    buf.unsplit(other);
+    assert_eq!(b"aaabbbcccddd", &buf[..]);
+}
+
+#[test]
+fn unsplit_inline_arc() {
+    let mut buf = BytesMut::with_capacity(8); //inline
+    buf.extend_from_slice(b"aaaabbbb");
+
+    let mut buf2 = BytesMut::with_capacity(64);
+    buf2.extend_from_slice(b"ccccddddeeee");
+
+    buf2.split_off(8); //arc
+
+    buf.unsplit(buf2);
+    assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
+}
+
+#[test]
+fn unsplit_arc_inline() {
+    let mut buf = BytesMut::with_capacity(64);
+    buf.extend_from_slice(b"aaaabbbbeeee");
+
+    buf.split_off(8); //arc
+
+    let mut buf2 = BytesMut::with_capacity(8); //inline
+    buf2.extend_from_slice(b"ccccdddd");
+
+    buf.unsplit(buf2);
+    assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
+
+}
+
+#[test]
+fn unsplit_both_inline() {
+    let mut buf = BytesMut::with_capacity(16); //inline
+    buf.extend_from_slice(b"aaaabbbbccccdddd");
+
+    let splitted = buf.split_off(8); // both inline
+    assert_eq!(b"aaaabbbb", &buf[..]);
+    assert_eq!(b"ccccdddd", &splitted[..]);
+
+    buf.unsplit(splitted);
+    assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
+}
+
+
+#[test]
+fn unsplit_arc_different() {
+    let mut buf = BytesMut::with_capacity(64);
+    buf.extend_from_slice(b"aaaabbbbeeee");
+
+    buf.split_off(8); //arc
+
+    let mut buf2 = BytesMut::with_capacity(64);
+    buf2.extend_from_slice(b"ccccddddeeee");
+
+    buf2.split_off(8); //arc
+
+    buf.unsplit(buf2);
+    assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
+}
+
+#[test]
+fn unsplit_arc_non_contiguous() {
+    let mut buf = BytesMut::with_capacity(64);
+    buf.extend_from_slice(b"aaaabbbbeeeeccccdddd");
+
+    let mut buf2 = buf.split_off(8); //arc
+
+    let buf3 = buf2.split_off(4); //arc
+
+    buf.unsplit(buf3);
+    assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
+}
+
+#[test]
+fn unsplit_two_split_offs() {
+    let mut buf = BytesMut::with_capacity(64);
+    buf.extend_from_slice(b"aaaabbbbccccdddd");
+
+    let mut buf2 = buf.split_off(8); //arc
+    let buf3 = buf2.split_off(4); //arc
+
+    buf2.unsplit(buf3);
+    buf.unsplit(buf2);
+    assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
+}

tests/test_chain.rs

@@ -55,48 +55,68 @@ fn vectored_read() {
     let mut buf = a.chain(b);
 
     {
-        let mut iovecs: [&IoVec; 4] = Default::default();
+        let b1: &[u8] = &mut [0];
+        let b2: &[u8] = &mut [0];
+        let b3: &[u8] = &mut [0];
+        let b4: &[u8] = &mut [0];
+        let mut iovecs: [&IoVec; 4] =
+            [b1.into(), b2.into(), b3.into(), b4.into()];
 
         assert_eq!(2, buf.bytes_vec(&mut iovecs));
         assert_eq!(iovecs[0][..], b"hello"[..]);
         assert_eq!(iovecs[1][..], b"world"[..]);
-        assert!(iovecs[2].is_empty());
-        assert!(iovecs[3].is_empty());
+        assert_eq!(iovecs[2][..], b"\0"[..]);
+        assert_eq!(iovecs[3][..], b"\0"[..]);
     }
 
     buf.advance(2);
 
     {
-        let mut iovecs: [&IoVec; 4] = Default::default();
+        let b1: &[u8] = &mut [0];
+        let b2: &[u8] = &mut [0];
+        let b3: &[u8] = &mut [0];
+        let b4: &[u8] = &mut [0];
+        let mut iovecs: [&IoVec; 4] =
+            [b1.into(), b2.into(), b3.into(), b4.into()];
 
         assert_eq!(2, buf.bytes_vec(&mut iovecs));
         assert_eq!(iovecs[0][..], b"llo"[..]);
         assert_eq!(iovecs[1][..], b"world"[..]);
-        assert!(iovecs[2].is_empty());
-        assert!(iovecs[3].is_empty());
+        assert_eq!(iovecs[2][..], b"\0"[..]);
+        assert_eq!(iovecs[3][..], b"\0"[..]);
     }
 
     buf.advance(3);
 
     {
-        let mut iovecs: [&IoVec; 4] = Default::default();
+        let b1: &[u8] = &mut [0];
+        let b2: &[u8] = &mut [0];
+        let b3: &[u8] = &mut [0];
+        let b4: &[u8] = &mut [0];
+        let mut iovecs: [&IoVec; 4] =
+            [b1.into(), b2.into(), b3.into(), b4.into()];
 
         assert_eq!(1, buf.bytes_vec(&mut iovecs));
         assert_eq!(iovecs[0][..], b"world"[..]);
-        assert!(iovecs[1].is_empty());
-        assert!(iovecs[2].is_empty());
-        assert!(iovecs[3].is_empty());
+        assert_eq!(iovecs[1][..], b"\0"[..]);
+        assert_eq!(iovecs[2][..], b"\0"[..]);
+        assert_eq!(iovecs[3][..], b"\0"[..]);
     }
 
     buf.advance(3);
 
     {
-        let mut iovecs: [&IoVec; 4] = Default::default();
+        let b1: &[u8] = &mut [0];
+        let b2: &[u8] = &mut [0];
+        let b3: &[u8] = &mut [0];
+        let b4: &[u8] = &mut [0];
+        let mut iovecs: [&IoVec; 4] =
+            [b1.into(), b2.into(), b3.into(), b4.into()];
 
         assert_eq!(1, buf.bytes_vec(&mut iovecs));
         assert_eq!(iovecs[0][..], b"ld"[..]);
-        assert!(iovecs[1].is_empty());
-        assert!(iovecs[2].is_empty());
-        assert!(iovecs[3].is_empty());
+        assert_eq!(iovecs[1][..], b"\0"[..]);
+        assert_eq!(iovecs[2][..], b"\0"[..]);
+        assert_eq!(iovecs[3][..], b"\0"[..]);
     }
 }

tests/test_debug.rs

@@ -11,7 +11,7 @@ fn fmt() {
         \\x08\\t\\n\\x0b\\x0c\\r\\x0e\\x0f\
         \\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\
         \\x18\\x19\\x1a\\x1b\\x1c\\x1d\\x1e\\x1f\
-        \\x20!\\\"#$%&'()*+,-./0123456789:;<=>?\
+        \x20!\\\"#$%&'()*+,-./0123456789:;<=>?\
         @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_\
         `abcdefghijklmnopqrstuvwxyz{|}~\\x7f\
         \\x80\\x81\\x82\\x83\\x84\\x85\\x86\\x87\

tests/test_iter.rs

@@ -0,0 +1,22 @@
+extern crate bytes;
+
+use bytes::{Buf, IntoBuf, Bytes};
+
+#[test]
+fn iter_len() {
+    let buf = Bytes::from(&b"hello world"[..]).into_buf();
+    let iter = buf.iter();
+
+    assert_eq!(iter.size_hint(), (11, Some(11)));
+    assert_eq!(iter.len(), 11);
+}
+
+
+#[test]
+fn empty_iter_len() {
+    let buf = Bytes::from(&b""[..]).into_buf();
+    let iter = buf.iter();
+
+    assert_eq!(iter.size_hint(), (0, Some(0)));
+    assert_eq!(iter.len(), 0);
+}

tests/test_serde.rs

@@ -0,0 +1,21 @@
+#![cfg(feature = "serde")]
+
+extern crate bytes;
+extern crate serde_test;
+use serde_test::{Token, assert_tokens};
+
+#[test]
+fn test_ser_de_empty() {
+    let b = bytes::Bytes::new();
+    assert_tokens(&b, &[Token::Bytes(b"")]);
+    let b = bytes::BytesMut::with_capacity(0);
+    assert_tokens(&b, &[Token::Bytes(b"")]);
+}
+
+#[test]
+fn test_ser_de() {
+    let b = bytes::Bytes::from(&b"bytes"[..]);
+    assert_tokens(&b, &[Token::Bytes(b"bytes")]);
+    let b = bytes::BytesMut::from(&b"bytes"[..]);
+    assert_tokens(&b, &[Token::Bytes(b"bytes")]);
+}

tests/test_take.rs

@@ -0,0 +1,13 @@
+extern crate bytes;
+
+use bytes::Buf;
+use std::io::Cursor;
+
+#[test]
+fn long_take() {
+    // Tests that take with a size greater than the buffer length will not
+    // overrun the buffer. Regression test for #138.
+    let buf = Cursor::new(b"hello world").take(100);
+    assert_eq!(11, buf.remaining());
+    assert_eq!(b"hello world", buf.bytes());
+}