Clarify chunk_mut documentation

Co-authored-by: Taiki Endo <[email protected]>

.github/workflows/ci.yml

@@ -11,6 +11,7 @@ on:
 env:
   RUSTFLAGS: -Dwarnings
   RUST_BACKTRACE: 1
+  nightly: nightly-2021-04-13
 
 defaults:
   run:
@@ -74,14 +75,11 @@ jobs:
   # Nightly
   nightly:
     name: nightly
-    env:
-      # Pin nightly to avoid being impacted by breakage
-      RUST_VERSION: nightly-2019-09-25
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
       - name: Install Rust
-        run: rustup update $RUST_VERSION && rustup default $RUST_VERSION
+        run: rustup update $nightly && rustup default $nightly
       - name: Test
         run: . ci/test-stable.sh test
 
@@ -96,7 +94,7 @@ jobs:
           - powerpc-unknown-linux-gnu
           - powerpc64-unknown-linux-gnu
           - wasm32-unknown-unknown
-    runs-on: ubuntu-16.04
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
       - name: Install Rust
@@ -120,23 +118,27 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - name: Install Rust
-        run: rustup update nightly && rustup default nightly
+        run: rustup update $nightly && rustup default $nightly
       - name: Install rust-src
         run: rustup component add rust-src
       - name: ASAN / TSAN
         run: . ci/tsan.sh
+  miri:
+    name: miri
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Miri
+        run: ci/miri.sh
 
   # Loom
   loom:
     name: loom
-    env:
-      # Pin nightly to avoid being impacted by breakage
-      RUST_VERSION: nightly-2020-05-19
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
       - name: Install Rust
-        run: rustup update $RUST_VERSION && rustup default $RUST_VERSION
+        run: rustup update $nightly && rustup default $nightly
       - name: Loom tests
         run: RUSTFLAGS="--cfg loom -Dwarnings" cargo test --lib
 
@@ -149,6 +151,8 @@ jobs:
       - nightly
       - minrust
       - cross
+      - tsan
+      - loom
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
@@ -156,6 +160,8 @@ jobs:
         run: rustup update stable && rustup default stable
       - name: Build documentation
         run: cargo doc --no-deps --all-features
+        env:
+          RUSTDOCFLAGS: --cfg docsrs
       - name: Publish documentation
         run: |
           cd target/doc

CHANGELOG.md

@@ -1,3 +1,41 @@
+# 1.1.0 (August 25, 2021)
+
+### Added
+
+- `BufMut::put_bytes(self, val, cnt)` (#487)
+- Implement `From<Box<[u8]>>` for `Bytes` (#504)
+
+### Changed
+
+- Override `put_slice` for `&mut [u8]` (#483)
+- Panic on integer overflow in `Chain::remaining` (#482)
+- Add inline tags to `UninitSlice` methods (#443)
+- Override `copy_to_bytes` for Chain and Take (#481)
+- Keep capacity when unsplit on empty other buf (#502)
+
+### Documented
+
+- Clarify `BufMut` allocation guarantees (#501)
+- Clarify `BufMut::put_int` behavior (#486)
+- Clarify actions of `clear` and `truncate`. (#508)
+
+# 1.0.1 (January 11, 2021)
+
+### Changed
+- mark `Vec::put_slice` with `#[inline]` (#459)
+
+### Fixed
+- Fix deprecation warning (#457)
+- use `Box::into_raw` instead of `mem::forget`-in-disguise (#458)
+
+# 1.0.0 (December 22, 2020)
+
+### Changed
+- Rename `Buf`/`BufMut` methods `bytes()` and `bytes_mut()` to `chunk()` and `chunk_mut()` (#450)
+
+### Removed
+- remove unused Buf implementation. (#449)
+
 # 0.6.0 (October 21, 2020)
 
 API polish in preparation for a 1.0 release.

Cargo.toml

@@ -2,18 +2,15 @@
 
 name = "bytes"
 # When releasing to crates.io:
-# - Update html_root_url.
 # - Update CHANGELOG.md.
-# - Update doc URL.
-# - Create "v0.6.x" git tag.
-version = "0.6.0"
+# - Create "v1.x.y" git tag.
+version = "1.1.0"
 license = "MIT"
 authors = [
     "Carl Lerche <[email protected]>",
     "Sean McArthur <[email protected]>",
 ]
 description = "Types and traits for working with bytes"
-documentation = "https://docs.rs/bytes/0.6.0/bytes/"
 repository = "https://github.com/tokio-rs/bytes"
 readme = "README.md"
 keywords = ["buffers", "zero-copy", "io"]
@@ -31,4 +28,7 @@ serde = { version = "1.0.60", optional = true, default-features = false, feature
 serde_test = "1.0"
 
 [target.'cfg(loom)'.dev-dependencies]
-loom = "0.3"
+loom = "0.5"
+
+[package.metadata.docs.rs]
+rustdoc-args = ["--cfg", "docsrs"]

README.md

@@ -18,7 +18,7 @@ To use `bytes`, first add this to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-bytes = "0.5"
+bytes = "1"
 ```
 
 Next, add this to your crate:
@@ -33,7 +33,7 @@ Serde support is optional and disabled by default. To enable use the feature `se
 
 ```toml
 [dependencies]
-bytes = { version = "0.5", features = ["serde"] }
+bytes = { version = "1", features = ["serde"] }
 ```
 
 ## License

benches/buf.rs

@@ -53,7 +53,7 @@ impl Buf for TestBuf {
         assert!(self.pos <= self.buf.len());
         self.next_readlen();
     }
-    fn bytes(&self) -> &[u8] {
+    fn chunk(&self) -> &[u8] {
         if self.readlen == 0 {
             Default::default()
         } else {
@@ -87,8 +87,8 @@ impl Buf for TestBufC {
         self.inner.advance(cnt)
     }
     #[inline(never)]
-    fn bytes(&self) -> &[u8] {
-        self.inner.bytes()
+    fn chunk(&self) -> &[u8] {
+        self.inner.chunk()
     }
 }
 
@@ -159,7 +159,6 @@ macro_rules! bench_group {
 mod get_u8 {
     use super::*;
     bench_group!(get_u8);
-    bench!(option, option);
 }
 mod get_u16 {
     use super::*;

ci/miri.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+set -e
+
+MIRI_NIGHTLY=nightly-$(curl -s https://rust-lang.github.io/rustup-components-history/x86_64-unknown-linux-gnu/miri)
+echo "Installing latest nightly with Miri: $MIRI_NIGHTLY"
+rustup set profile minimal
+rustup default "$MIRI_NIGHTLY"
+rustup component add miri
+
+cargo miri test
+cargo miri test --target mips64-unknown-linux-gnuabi64

ci/test-stable.sh

@@ -5,7 +5,8 @@ set -ex
 cmd="${1:-test}"
 
 # Install cargo-hack for feature flag test
-cargo install cargo-hack
+host=$(rustc -Vv | grep host | sed 's/host: //')
+curl -LsSf https://github.com/taiki-e/cargo-hack/releases/latest/download/cargo-hack-$host.tar.gz | tar xzf - -C ~/.cargo/bin
 
 # Run with each feature
 # * --each-feature includes both default/no-default features

src/buf/buf_impl.rs

@@ -16,7 +16,7 @@ macro_rules! buf_get_impl {
         // this Option<ret> trick is to avoid keeping a borrow on self
         // when advance() is called (mut borrow) and to call bytes() only once
         let ret = $this
-            .bytes()
+            .chunk()
             .get(..SIZE)
             .map(|src| unsafe { $typ::$conv(*(src as *const _ as *const [_; SIZE])) });
 
@@ -78,7 +78,7 @@ pub trait Buf {
     /// the buffer.
     ///
     /// This value is greater than or equal to the length of the slice returned
-    /// by `bytes`.
+    /// by `chunk()`.
     ///
     /// # Examples
     ///
@@ -115,31 +115,34 @@ pub trait Buf {
     ///
     /// let mut buf = &b"hello world"[..];
     ///
-    /// assert_eq!(buf.bytes(), &b"hello world"[..]);
+    /// assert_eq!(buf.chunk(), &b"hello world"[..]);
     ///
     /// buf.advance(6);
     ///
-    /// assert_eq!(buf.bytes(), &b"world"[..]);
+    /// assert_eq!(buf.chunk(), &b"world"[..]);
     /// ```
     ///
     /// # Implementer notes
     ///
     /// This function should never panic. Once the end of the buffer is reached,
-    /// i.e., `Buf::remaining` returns 0, calls to `bytes` should return an
+    /// i.e., `Buf::remaining` returns 0, calls to `chunk()` should return an
     /// empty slice.
-    fn bytes(&self) -> &[u8];
+    // The `chunk` method was previously called `bytes`. This alias makes the rename
+    // more easily discoverable.
+    #[cfg_attr(docsrs, doc(alias = "bytes"))]
+    fn chunk(&self) -> &[u8];
 
     /// Fills `dst` with potentially multiple slices starting at `self`'s
     /// current position.
     ///
-    /// If the `Buf` is backed by disjoint slices of bytes, `bytes_vectored` enables
+    /// If the `Buf` is backed by disjoint slices of bytes, `chunk_vectored` enables
     /// fetching more than one slice at once. `dst` is a slice of `IoSlice`
     /// references, enabling the slice to be directly used with [`writev`]
     /// without any further conversion. The sum of the lengths of all the
     /// buffers in `dst` will be less than or equal to `Buf::remaining()`.
     ///
     /// The entries in `dst` will be overwritten, but the data **contained** by
-    /// the slices **will not** be modified. If `bytes_vectored` does not fill every
+    /// the slices **will not** be modified. If `chunk_vectored` does not fill every
     /// entry in `dst`, then `dst` is guaranteed to contain all remaining slices
     /// in `self.
     ///
@@ -149,7 +152,7 @@ pub trait Buf {
     /// # Implementer notes
     ///
     /// This function should never panic. Once the end of the buffer is reached,
-    /// i.e., `Buf::remaining` returns 0, calls to `bytes_vectored` must return 0
+    /// i.e., `Buf::remaining` returns 0, calls to `chunk_vectored` must return 0
     /// without mutating `dst`.
     ///
     /// Implementations should also take care to properly handle being called
@@ -157,13 +160,13 @@ pub trait Buf {
     ///
     /// [`writev`]: http://man7.org/linux/man-pages/man2/readv.2.html
     #[cfg(feature = "std")]
-    fn bytes_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {
+    fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {
         if dst.is_empty() {
             return 0;
         }
 
         if self.has_remaining() {
-            dst[0] = IoSlice::new(self.bytes());
+            dst[0] = IoSlice::new(self.chunk());
             1
         } else {
             0
@@ -172,7 +175,7 @@ pub trait Buf {
 
     /// Advance the internal cursor of the Buf
     ///
-    /// The next call to `bytes` will return a slice starting `cnt` bytes
+    /// The next call to `chunk()` will return a slice starting `cnt` bytes
     /// further into the underlying buffer.
     ///
     /// # Examples
@@ -182,11 +185,11 @@ pub trait Buf {
     ///
     /// let mut buf = &b"hello world"[..];
     ///
-    /// assert_eq!(buf.bytes(), &b"hello world"[..]);
+    /// assert_eq!(buf.chunk(), &b"hello world"[..]);
     ///
     /// buf.advance(6);
     ///
-    /// assert_eq!(buf.bytes(), &b"world"[..]);
+    /// assert_eq!(buf.chunk(), &b"world"[..]);
     /// ```
     ///
     /// # Panics
@@ -253,7 +256,7 @@ pub trait Buf {
             let cnt;
 
             unsafe {
-                let src = self.bytes();
+                let src = self.chunk();
                 cnt = cmp::min(src.len(), dst.len() - off);
 
                 ptr::copy_nonoverlapping(src.as_ptr(), dst[off..].as_mut_ptr(), cnt);
@@ -283,7 +286,7 @@ pub trait Buf {
     /// This function panics if there is no more remaining data in `self`.
     fn get_u8(&mut self) -> u8 {
         assert!(self.remaining() >= 1);
-        let ret = self.bytes()[0];
+        let ret = self.chunk()[0];
         self.advance(1);
         ret
     }
@@ -306,7 +309,7 @@ pub trait Buf {
     /// This function panics if there is no more remaining data in `self`.
     fn get_i8(&mut self) -> i8 {
         assert!(self.remaining() >= 1);
-        let ret = self.bytes()[0] as i8;
+        let ret = self.chunk()[0] as i8;
         self.advance(1);
         ret
     }
@@ -861,7 +864,7 @@ pub trait Buf {
     /// let mut chain = b"hello "[..].chain(&b"world"[..]);
     ///
     /// let full = chain.copy_to_bytes(11);
-    /// assert_eq!(full.bytes(), b"hello world");
+    /// assert_eq!(full.chunk(), b"hello world");
     /// ```
     fn chain<U: Buf>(self, next: U) -> Chain<Self, U>
     where
@@ -908,13 +911,13 @@ macro_rules! deref_forward_buf {
             (**self).remaining()
         }
 
-        fn bytes(&self) -> &[u8] {
-            (**self).bytes()
+        fn chunk(&self) -> &[u8] {
+            (**self).chunk()
         }
 
         #[cfg(feature = "std")]
-        fn bytes_vectored<'b>(&'b self, dst: &mut [IoSlice<'b>]) -> usize {
-            (**self).bytes_vectored(dst)
+        fn chunks_vectored<'b>(&'b self, dst: &mut [IoSlice<'b>]) -> usize {
+            (**self).chunks_vectored(dst)
         }
 
         fn advance(&mut self, cnt: usize) {
@@ -1022,7 +1025,7 @@ impl Buf for &[u8] {
     }
 
     #[inline]
-    fn bytes(&self) -> &[u8] {
+    fn chunk(&self) -> &[u8] {
         self
     }
 
@@ -1032,35 +1035,6 @@ impl Buf for &[u8] {
     }
 }
 
-impl Buf for Option<[u8; 1]> {
-    fn remaining(&self) -> usize {
-        if self.is_some() {
-            1
-        } else {
-            0
-        }
-    }
-
-    fn bytes(&self) -> &[u8] {
-        self.as_ref()
-            .map(AsRef::as_ref)
-            .unwrap_or(Default::default())
-    }
-
-    fn advance(&mut self, cnt: usize) {
-        if cnt == 0 {
-            return;
-        }
-
-        if self.is_none() {
-            panic!("overflow");
-        } else {
-            assert_eq!(1, cnt);
-            *self = None;
-        }
-    }
-}
-
 #[cfg(feature = "std")]
 impl<T: AsRef<[u8]>> Buf for std::io::Cursor<T> {
     fn remaining(&self) -> usize {
@@ -1074,7 +1048,7 @@ impl<T: AsRef<[u8]>> Buf for std::io::Cursor<T> {
         len - pos as usize
     }
 
-    fn bytes(&self) -> &[u8] {
+    fn chunk(&self) -> &[u8] {
         let len = self.get_ref().as_ref().len();
         let pos = self.position();
 

src/buf/buf_mut.rs

@@ -8,7 +8,7 @@ use alloc::{boxed::Box, vec::Vec};
 
 /// A trait for values that provide sequential write access to bytes.
 ///
-/// Write bytes to a buffer
+/// Write bytes to a buffer.
 ///
 /// A buffer stores bytes in memory such that write operations are infallible.
 /// The underlying storage may or may not be in contiguous memory. A `BufMut`
@@ -31,7 +31,11 @@ pub unsafe trait BufMut {
     /// position until the end of the buffer is reached.
     ///
     /// This value is greater than or equal to the length of the slice returned
-    /// by `bytes_mut`.
+    /// by `chunk_mut()`.
+    ///
+    /// Writing to a `BufMut` may involve allocating more memory on the fly.
+    /// Implementations may fail before reaching the number of bytes indicated
+    /// by this method if they encounter an allocation failure.
     ///
     /// # Examples
     ///
@@ -56,7 +60,7 @@ pub unsafe trait BufMut {
 
     /// Advance the internal cursor of the BufMut
     ///
-    /// The next call to `bytes_mut` will return a slice starting `cnt` bytes
+    /// The next call to `chunk_mut` will return a slice starting `cnt` bytes
     /// further into the underlying buffer.
     ///
     /// This function is unsafe because there is no guarantee that the bytes
@@ -70,11 +74,11 @@ pub unsafe trait BufMut {
     /// let mut buf = Vec::with_capacity(16);
     ///
     /// // Write some data
-    /// buf.bytes_mut()[0..2].copy_from_slice(b"he");
+    /// buf.chunk_mut()[0..2].copy_from_slice(b"he");
     /// unsafe { buf.advance_mut(2) };
     ///
     /// // write more bytes
-    /// buf.bytes_mut()[0..3].copy_from_slice(b"llo");
+    /// buf.chunk_mut()[0..3].copy_from_slice(b"llo");
     ///
     /// unsafe { buf.advance_mut(3); }
     ///
@@ -118,8 +122,14 @@ pub unsafe trait BufMut {
     }
 
     /// Returns a mutable slice starting at the current BufMut position and of
-    /// length between 0 and `BufMut::remaining_mut()`. Note that this *can* be shorter than the
-    /// whole remainder of the buffer (this allows non-continuous implementation).
+    /// length between 0 and `BufMut::remaining_mut()`. Note that this *can* be
+    /// shorter than the whole remainder of the buffer (this allows
+    /// non-continuous implementation).
+    ///
+    /// Writing to a `BufMut` may involve allocating more memory on the fly.
+    /// Generally, such allocations happen when this method is called on a
+    /// container that has run out of capacity. Containers that behave this way
+    /// include [`Vec<u8>`](std::vec::Vec) and [`BytesMut`](crate::BytesMut).
     ///
     /// This is a lower level function. Most operations are done with other
     /// functions.
@@ -135,14 +145,14 @@ pub unsafe trait BufMut {
     ///
     /// unsafe {
     ///     // MaybeUninit::as_mut_ptr
-    ///     buf.bytes_mut()[0..].as_mut_ptr().write(b'h');
-    ///     buf.bytes_mut()[1..].as_mut_ptr().write(b'e');
+    ///     buf.chunk_mut()[0..].as_mut_ptr().write(b'h');
+    ///     buf.chunk_mut()[1..].as_mut_ptr().write(b'e');
     ///
     ///     buf.advance_mut(2);
     ///
-    ///     buf.bytes_mut()[0..].as_mut_ptr().write(b'l');
-    ///     buf.bytes_mut()[1..].as_mut_ptr().write(b'l');
-    ///     buf.bytes_mut()[2..].as_mut_ptr().write(b'o');
+    ///     buf.chunk_mut()[0..].as_mut_ptr().write(b'l');
+    ///     buf.chunk_mut()[1..].as_mut_ptr().write(b'l');
+    ///     buf.chunk_mut()[2..].as_mut_ptr().write(b'o');
     ///
     ///     buf.advance_mut(3);
     /// }
@@ -153,12 +163,18 @@ pub unsafe trait BufMut {
     ///
     /// # Implementer notes
     ///
-    /// This function should never panic. `bytes_mut` should return an empty
-    /// slice **if and only if** `remaining_mut` returns 0. In other words,
-    /// `bytes_mut` returning an empty slice implies that `remaining_mut` will
-    /// return 0 and `remaining_mut` returning 0 implies that `bytes_mut` will
+    /// This function should never panic. `chunk_mut` should return an empty
+    /// slice **if and only if** `remaining_mut()` returns 0. In other words,
+    /// `chunk_mut()` returning an empty slice implies that `remaining_mut()` will
+    /// return 0 and `remaining_mut()` returning 0 implies that `chunk_mut()` will
     /// return an empty slice.
-    fn bytes_mut(&mut self) -> &mut UninitSlice;
+    ///
+    /// This function may trigger an out-of-memory abort if it tries to allocate
+    /// memory and fails to do so.
+    // The `chunk_mut` method was previously called `bytes_mut`. This alias makes the
+    // rename more easily discoverable.
+    #[cfg_attr(docsrs, doc(alias = "bytes_mut"))]
+    fn chunk_mut(&mut self) -> &mut UninitSlice;
 
     /// Transfer bytes into `self` from `src` and advance the cursor by the
     /// number of bytes written.
@@ -190,8 +206,8 @@ pub unsafe trait BufMut {
             let l;
 
             unsafe {
-                let s = src.bytes();
-                let d = self.bytes_mut();
+                let s = src.chunk();
+                let d = self.chunk_mut();
                 l = cmp::min(s.len(), d.len());
 
                 ptr::copy_nonoverlapping(s.as_ptr(), d.as_mut_ptr() as *mut u8, l);
@@ -237,7 +253,7 @@ pub unsafe trait BufMut {
             let cnt;
 
             unsafe {
-                let dst = self.bytes_mut();
+                let dst = self.chunk_mut();
                 cnt = cmp::min(dst.len(), src.len() - off);
 
                 ptr::copy_nonoverlapping(src[off..].as_ptr(), dst.as_mut_ptr() as *mut u8, cnt);
@@ -251,6 +267,37 @@ pub unsafe trait BufMut {
         }
     }
 
+    /// Put `cnt` bytes `val` into `self`.
+    ///
+    /// Logically equivalent to calling `self.put_u8(val)` `cnt` times, but may work faster.
+    ///
+    /// `self` must have at least `cnt` remaining capacity.
+    ///
+    /// ```
+    /// use bytes::BufMut;
+    ///
+    /// let mut dst = [0; 6];
+    ///
+    /// {
+    ///     let mut buf = &mut dst[..];
+    ///     buf.put_bytes(b'a', 4);
+    ///
+    ///     assert_eq!(2, buf.remaining_mut());
+    /// }
+    ///
+    /// assert_eq!(b"aaaa\0\0", &dst);
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if there is not enough remaining capacity in
+    /// `self`.
+    fn put_bytes(&mut self, val: u8, cnt: usize) {
+        for _ in 0..cnt {
+            self.put_u8(val);
+        }
+    }
+
     /// Writes an unsigned 8 bit integer to `self`.
     ///
     /// The current position is advanced by 1.
@@ -693,7 +740,7 @@ pub unsafe trait BufMut {
         self.put_slice(&n.to_le_bytes()[0..nbytes]);
     }
 
-    /// Writes a signed n-byte integer to `self` in big-endian byte order.
+    /// Writes low `nbytes` of a signed integer to `self` in big-endian byte order.
     ///
     /// The current position is advanced by `nbytes`.
     ///
@@ -703,19 +750,19 @@ pub unsafe trait BufMut {
     /// use bytes::BufMut;
     ///
     /// let mut buf = vec![];
-    /// buf.put_int(0x010203, 3);
+    /// buf.put_int(0x0504010203, 3);
     /// assert_eq!(buf, b"\x01\x02\x03");
     /// ```
     ///
     /// # Panics
     ///
     /// This function panics if there is not enough remaining capacity in
-    /// `self`.
+    /// `self` or if `nbytes` is greater than 8.
     fn put_int(&mut self, n: i64, nbytes: usize) {
         self.put_slice(&n.to_be_bytes()[mem::size_of_val(&n) - nbytes..]);
     }
 
-    /// Writes a signed n-byte integer to `self` in little-endian byte order.
+    /// Writes low `nbytes` of a signed integer to `self` in little-endian byte order.
     ///
     /// The current position is advanced by `nbytes`.
     ///
@@ -725,14 +772,14 @@ pub unsafe trait BufMut {
     /// use bytes::BufMut;
     ///
     /// let mut buf = vec![];
-    /// buf.put_int_le(0x010203, 3);
+    /// buf.put_int_le(0x0504010203, 3);
     /// assert_eq!(buf, b"\x03\x02\x01");
     /// ```
     ///
     /// # Panics
     ///
     /// This function panics if there is not enough remaining capacity in
-    /// `self`.
+    /// `self` or if `nbytes` is greater than 8.
     fn put_int_le(&mut self, n: i64, nbytes: usize) {
         self.put_slice(&n.to_le_bytes()[0..nbytes]);
     }
@@ -913,8 +960,8 @@ macro_rules! deref_forward_bufmut {
             (**self).remaining_mut()
         }
 
-        fn bytes_mut(&mut self) -> &mut UninitSlice {
-            (**self).bytes_mut()
+        fn chunk_mut(&mut self) -> &mut UninitSlice {
+            (**self).chunk_mut()
         }
 
         unsafe fn advance_mut(&mut self, cnt: usize) {
@@ -998,7 +1045,7 @@ unsafe impl BufMut for &mut [u8] {
     }
 
     #[inline]
-    fn bytes_mut(&mut self) -> &mut UninitSlice {
+    fn chunk_mut(&mut self) -> &mut UninitSlice {
         // UninitSlice is repr(transparent), so safe to transmute
         unsafe { &mut *(*self as *mut [u8] as *mut _) }
     }
@@ -1009,12 +1056,29 @@ unsafe impl BufMut for &mut [u8] {
         let (_, b) = core::mem::replace(self, &mut []).split_at_mut(cnt);
         *self = b;
     }
+
+    #[inline]
+    fn put_slice(&mut self, src: &[u8]) {
+        self[..src.len()].copy_from_slice(src);
+        unsafe {
+            self.advance_mut(src.len());
+        }
+    }
+
+    fn put_bytes(&mut self, val: u8, cnt: usize) {
+        assert!(self.remaining_mut() >= cnt);
+        unsafe {
+            ptr::write_bytes(self.as_mut_ptr(), val, cnt);
+            self.advance_mut(cnt);
+        }
+    }
 }
 
 unsafe impl BufMut for Vec<u8> {
     #[inline]
     fn remaining_mut(&self) -> usize {
-        usize::MAX - self.len()
+        // A vector can never have more than isize::MAX bytes
+        core::isize::MAX as usize - self.len()
     }
 
     #[inline]
@@ -1033,7 +1097,7 @@ unsafe impl BufMut for Vec<u8> {
     }
 
     #[inline]
-    fn bytes_mut(&mut self) -> &mut UninitSlice {
+    fn chunk_mut(&mut self) -> &mut UninitSlice {
         if self.capacity() == self.len() {
             self.reserve(64); // Grow the vec
         }
@@ -1047,7 +1111,6 @@ unsafe impl BufMut for Vec<u8> {
 
     // Specialize these methods so they can skip checking `remaining_mut`
     // and `advance_mut`.
-
     fn put<T: super::Buf>(&mut self, mut src: T)
     where
         Self: Sized,
@@ -1060,7 +1123,7 @@ unsafe impl BufMut for Vec<u8> {
 
             // a block to contain the src.bytes() borrow
             {
-                let s = src.bytes();
+                let s = src.chunk();
                 l = s.len();
                 self.extend_from_slice(s);
             }
@@ -1069,9 +1132,15 @@ unsafe impl BufMut for Vec<u8> {
         }
     }
 
+    #[inline]
     fn put_slice(&mut self, src: &[u8]) {
         self.extend_from_slice(src);
     }
+
+    fn put_bytes(&mut self, val: u8, cnt: usize) {
+        let new_len = self.len().checked_add(cnt).unwrap();
+        self.resize(new_len, val);
+    }
 }
 
 // The existence of this function makes the compiler catch if the BufMut

src/buf/chain.rs

@@ -1,5 +1,5 @@
 use crate::buf::{IntoIter, UninitSlice};
-use crate::{Buf, BufMut};
+use crate::{Buf, BufMut, Bytes};
 
 #[cfg(feature = "std")]
 use std::io::IoSlice;
@@ -135,14 +135,14 @@ where
     U: Buf,
 {
     fn remaining(&self) -> usize {
-        self.a.remaining() + self.b.remaining()
+        self.a.remaining().checked_add(self.b.remaining()).unwrap()
     }
 
-    fn bytes(&self) -> &[u8] {
+    fn chunk(&self) -> &[u8] {
         if self.a.has_remaining() {
-            self.a.bytes()
+            self.a.chunk()
         } else {
-            self.b.bytes()
+            self.b.chunk()
         }
     }
 
@@ -165,11 +165,29 @@ where
     }
 
     #[cfg(feature = "std")]
-    fn bytes_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {
-        let mut n = self.a.bytes_vectored(dst);
-        n += self.b.bytes_vectored(&mut dst[n..]);
+    fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {
+        let mut n = self.a.chunks_vectored(dst);
+        n += self.b.chunks_vectored(&mut dst[n..]);
         n
     }
+
+    fn copy_to_bytes(&mut self, len: usize) -> Bytes {
+        let a_rem = self.a.remaining();
+        if a_rem >= len {
+            self.a.copy_to_bytes(len)
+        } else if a_rem == 0 {
+            self.b.copy_to_bytes(len)
+        } else {
+            assert!(
+                len - a_rem <= self.b.remaining(),
+                "`len` greater than remaining"
+            );
+            let mut ret = crate::BytesMut::with_capacity(len);
+            ret.put(&mut self.a);
+            ret.put((&mut self.b).take(len - a_rem));
+            ret.freeze()
+        }
+    }
 }
 
 unsafe impl<T, U> BufMut for Chain<T, U>
@@ -178,14 +196,17 @@ where
     U: BufMut,
 {
     fn remaining_mut(&self) -> usize {
-        self.a.remaining_mut() + self.b.remaining_mut()
+        self.a
+            .remaining_mut()
+            .checked_add(self.b.remaining_mut())
+            .unwrap()
     }
 
-    fn bytes_mut(&mut self) -> &mut UninitSlice {
+    fn chunk_mut(&mut self) -> &mut UninitSlice {
         if self.a.has_remaining_mut() {
-            self.a.bytes_mut()
+            self.a.chunk_mut()
         } else {
-            self.b.bytes_mut()
+            self.b.chunk_mut()
         }
     }
 

src/buf/iter.rs

@@ -117,7 +117,7 @@ impl<T: Buf> Iterator for IntoIter<T> {
             return None;
         }
 
-        let b = self.inner.bytes()[0];
+        let b = self.inner.chunk()[0];
         self.inner.advance(1);
 
         Some(b)

src/buf/limit.rs

@@ -61,8 +61,8 @@ unsafe impl<T: BufMut> BufMut for Limit<T> {
         cmp::min(self.inner.remaining_mut(), self.limit)
     }
 
-    fn bytes_mut(&mut self) -> &mut UninitSlice {
-        let bytes = self.inner.bytes_mut();
+    fn chunk_mut(&mut self) -> &mut UninitSlice {
+        let bytes = self.inner.chunk_mut();
         let end = cmp::min(bytes.len(), self.limit);
         &mut bytes[..end]
     }

src/buf/reader.rs

@@ -73,7 +73,7 @@ impl<B: Buf + Sized> io::Read for Reader<B> {
 
 impl<B: Buf + Sized> io::BufRead for Reader<B> {
     fn fill_buf(&mut self) -> io::Result<&[u8]> {
-        Ok(self.buf.bytes())
+        Ok(self.buf.chunk())
     }
     fn consume(&mut self, amt: usize) {
         self.buf.advance(amt)

src/buf/take.rs

@@ -1,11 +1,11 @@
-use crate::Buf;
+use crate::{Buf, Bytes};
 
 use core::cmp;
 
 /// A `Buf` adapter which limits the bytes read from an underlying buffer.
 ///
 /// This struct is generally created by calling `take()` on `Buf`. See
-/// documentation of [`take()`](trait.BufExt.html#method.take) for more details.
+/// documentation of [`take()`](trait.Buf.html#method.take) for more details.
 #[derive(Debug)]
 pub struct Take<T> {
     inner: T,
@@ -134,8 +134,8 @@ impl<T: Buf> Buf for Take<T> {
         cmp::min(self.inner.remaining(), self.limit)
     }
 
-    fn bytes(&self) -> &[u8] {
-        let bytes = self.inner.bytes();
+    fn chunk(&self) -> &[u8] {
+        let bytes = self.inner.chunk();
         &bytes[..cmp::min(bytes.len(), self.limit)]
     }
 
@@ -144,4 +144,12 @@ impl<T: Buf> Buf for Take<T> {
         self.inner.advance(cnt);
         self.limit -= cnt;
     }
+
+    fn copy_to_bytes(&mut self, len: usize) -> Bytes {
+        assert!(len <= self.remaining(), "`len` greater than remaining");
+
+        let r = self.inner.copy_to_bytes(len);
+        self.limit -= len;
+        r
+    }
 }

src/buf/uninit_slice.rs

@@ -6,7 +6,7 @@ use core::ops::{
 
 /// Uninitialized byte slice.
 ///
-/// Returned by `BufMut::bytes_mut()`, the referenced byte slice may be
+/// Returned by `BufMut::chunk_mut()`, the referenced byte slice may be
 /// uninitialized. The wrapper provides safe access without introducing
 /// undefined behavior.
 ///
@@ -40,6 +40,7 @@ impl UninitSlice {
     ///
     /// let slice = unsafe { UninitSlice::from_raw_parts_mut(ptr, len) };
     /// ```
+    #[inline]
     pub unsafe fn from_raw_parts_mut<'a>(ptr: *mut u8, len: usize) -> &'a mut UninitSlice {
         let maybe_init: &mut [MaybeUninit<u8>] =
             core::slice::from_raw_parts_mut(ptr as *mut _, len);
@@ -64,6 +65,7 @@ impl UninitSlice {
     ///
     /// assert_eq!(b"boo", &data[..]);
     /// ```
+    #[inline]
     pub fn write_byte(&mut self, index: usize, byte: u8) {
         assert!(index < self.len());
 
@@ -90,6 +92,7 @@ impl UninitSlice {
     ///
     /// assert_eq!(b"bar", &data[..]);
     /// ```
+    #[inline]
     pub fn copy_from_slice(&mut self, src: &[u8]) {
         use core::ptr;
 
@@ -114,8 +117,9 @@ impl UninitSlice {
     ///
     /// let mut data = [0, 1, 2];
     /// let mut slice = &mut data[..];
-    /// let ptr = BufMut::bytes_mut(&mut slice).as_mut_ptr();
+    /// let ptr = BufMut::chunk_mut(&mut slice).as_mut_ptr();
     /// ```
+    #[inline]
     pub fn as_mut_ptr(&mut self) -> *mut u8 {
         self.0.as_mut_ptr() as *mut _
     }
@@ -129,10 +133,11 @@ impl UninitSlice {
     ///
     /// let mut data = [0, 1, 2];
     /// let mut slice = &mut data[..];
-    /// let len = BufMut::bytes_mut(&mut slice).len();
+    /// let len = BufMut::chunk_mut(&mut slice).len();
     ///
     /// assert_eq!(len, 3);
     /// ```
+    #[inline]
     pub fn len(&self) -> usize {
         self.0.len()
     }
@@ -150,6 +155,7 @@ macro_rules! impl_index {
             impl Index<$t> for UninitSlice {
                 type Output = UninitSlice;
 
+                #[inline]
                 fn index(&self, index: $t) -> &UninitSlice {
                     let maybe_uninit: &[MaybeUninit<u8>] = &self.0[index];
                     unsafe { &*(maybe_uninit as *const [MaybeUninit<u8>] as *const UninitSlice) }
@@ -157,6 +163,7 @@ macro_rules! impl_index {
             }
 
             impl IndexMut<$t> for UninitSlice {
+                #[inline]
                 fn index_mut(&mut self, index: $t) -> &mut UninitSlice {
                     let maybe_uninit: &mut [MaybeUninit<u8>] = &mut self.0[index];
                     unsafe { &mut *(maybe_uninit as *mut [MaybeUninit<u8>] as *mut UninitSlice) }

src/buf/vec_deque.rs

@@ -7,7 +7,7 @@ impl Buf for VecDeque<u8> {
         self.len()
     }
 
-    fn bytes(&self) -> &[u8] {
+    fn chunk(&self) -> &[u8] {
         let (s1, s2) = self.as_slices();
         if s1.is_empty() {
             s2

src/bytes.rs

@@ -530,7 +530,7 @@ impl Buf for Bytes {
     }
 
     #[inline]
-    fn bytes(&self) -> &[u8] {
+    fn chunk(&self) -> &[u8] {
         self.as_slice()
     }
 
@@ -797,17 +797,22 @@ impl From<&'static str> for Bytes {
 
 impl From<Vec<u8>> for Bytes {
     fn from(vec: Vec<u8>) -> Bytes {
-        // into_boxed_slice doesn't return a heap allocation for empty vectors,
+        let slice = vec.into_boxed_slice();
+        slice.into()
+    }
+}
+
+impl From<Box<[u8]>> for Bytes {
+    fn from(slice: Box<[u8]>) -> Bytes {
+        // Box<[u8]> doesn't contain a heap allocation for empty slices,
         // so the pointer isn't aligned enough for the KIND_VEC stashing to
         // work.
-        if vec.is_empty() {
+        if slice.is_empty() {
             return Bytes::new();
         }
 
-        let slice = vec.into_boxed_slice();
         let len = slice.len();
-        let ptr = slice.as_ptr();
-        drop(Box::into_raw(slice));
+        let ptr = Box::into_raw(slice) as *mut u8;
 
         if ptr as usize & 0x1 == 0 {
             let data = ptr as usize | KIND_VEC;
@@ -1023,33 +1028,35 @@ unsafe fn shallow_clone_vec(
     // `Release` is used synchronize with other threads that
     // will load the `arc` field.
     //
-    // If the `compare_and_swap` fails, then the thread lost the
+    // If the `compare_exchange` fails, then the thread lost the
     // race to promote the buffer to shared. The `Acquire`
-    // ordering will synchronize with the `compare_and_swap`
+    // ordering will synchronize with the `compare_exchange`
     // that happened in the other thread and the `Shared`
     // pointed to by `actual` will be visible.
-    let actual = atom.compare_and_swap(ptr as _, shared as _, Ordering::AcqRel);
+    match atom.compare_exchange(ptr as _, shared as _, Ordering::AcqRel, Ordering::Acquire) {
+        Ok(actual) => {
+            debug_assert!(actual as usize == ptr as usize);
+            // The upgrade was successful, the new handle can be
+            // returned.
+            Bytes {
+                ptr: offset,
+                len,
+                data: AtomicPtr::new(shared as _),
+                vtable: &SHARED_VTABLE,
+            }
+        }
+        Err(actual) => {
+            // The upgrade failed, a concurrent clone happened. Release
+            // the allocation that was made in this thread, it will not
+            // be needed.
+            let shared = Box::from_raw(shared);
+            mem::forget(*shared);
 
-    if actual as usize == ptr as usize {
-        // The upgrade was successful, the new handle can be
-        // returned.
-        return Bytes {
-            ptr: offset,
-            len,
-            data: AtomicPtr::new(shared as _),
-            vtable: &SHARED_VTABLE,
-        };
+            // Buffer already promoted to shared storage, so increment ref
+            // count.
+            shallow_clone_arc(actual as _, offset, len)
+        }
     }
-
-    // The upgrade failed, a concurrent clone happened. Release
-    // the allocation that was made in this thread, it will not
-    // be needed.
-    let shared = Box::from_raw(shared);
-    mem::forget(*shared);
-
-    // Buffer already promoted to shared storage, so increment ref
-    // count.
-    shallow_clone_arc(actual as _, offset, len)
 }
 
 unsafe fn release_shared(ptr: *mut Shared) {

src/bytes_mut.rs

@@ -380,6 +380,8 @@ impl BytesMut {
     /// If `len` is greater than the buffer's current length, this has no
     /// effect.
     ///
+    /// Existing underlying capacity is preserved.
+    ///
     /// The [`split_off`] method can emulate `truncate`, but this causes the
     /// excess bytes to be returned instead of dropped.
     ///
@@ -402,7 +404,7 @@ impl BytesMut {
         }
     }
 
-    /// Clears the buffer, removing all data.
+    /// Clears the buffer, removing all data. Existing capacity is preserved.
     ///
     /// # Examples
     ///
@@ -445,7 +447,7 @@ impl BytesMut {
             let additional = new_len - len;
             self.reserve(additional);
             unsafe {
-                let dst = self.bytes_mut().as_mut_ptr();
+                let dst = self.chunk_mut().as_mut_ptr();
                 ptr::write_bytes(dst, value, additional);
                 self.set_len(new_len);
             }
@@ -819,7 +821,7 @@ impl BytesMut {
     }
 
     fn try_unsplit(&mut self, other: BytesMut) -> Result<(), BytesMut> {
-        if other.is_empty() {
+        if other.capacity() == 0 {
             return Ok(());
         }
 
@@ -944,7 +946,7 @@ impl Buf for BytesMut {
     }
 
     #[inline]
-    fn bytes(&self) -> &[u8] {
+    fn chunk(&self) -> &[u8] {
         self.as_slice()
     }
 
@@ -985,7 +987,7 @@ unsafe impl BufMut for BytesMut {
     }
 
     #[inline]
-    fn bytes_mut(&mut self) -> &mut UninitSlice {
+    fn chunk_mut(&mut self) -> &mut UninitSlice {
         if self.capacity() == self.len() {
             self.reserve(64);
         }
@@ -1000,7 +1002,7 @@ unsafe impl BufMut for BytesMut {
         Self: Sized,
     {
         while src.has_remaining() {
-            let s = src.bytes();
+            let s = src.chunk();
             let l = s.len();
             self.extend_from_slice(s);
             src.advance(l);
@@ -1010,6 +1012,19 @@ unsafe impl BufMut for BytesMut {
     fn put_slice(&mut self, src: &[u8]) {
         self.extend_from_slice(src);
     }
+
+    fn put_bytes(&mut self, val: u8, cnt: usize) {
+        self.reserve(cnt);
+        unsafe {
+            let dst = self.uninit_slice();
+            // Reserved above
+            debug_assert!(dst.len() >= cnt);
+
+            ptr::write_bytes(dst.as_mut_ptr(), val, cnt);
+
+            self.advance_mut(cnt);
+        }
+    }
 }
 
 impl AsRef<[u8]> for BytesMut {
@@ -1250,6 +1265,7 @@ impl Shared {
     }
 }
 
+#[inline]
 fn original_capacity_to_repr(cap: usize) -> usize {
     let width = PTR_WIDTH - ((cap >> MIN_ORIGINAL_CAPACITY_WIDTH).leading_zeros() as usize);
     cmp::min(
@@ -1476,6 +1492,7 @@ impl PartialEq<Bytes> for BytesMut {
     }
 }
 
+#[inline]
 fn vptr(ptr: *mut u8) -> NonNull<u8> {
     if cfg!(debug_assertions) {
         NonNull::new(ptr).expect("Vec pointer should be non-null")

src/lib.rs

@@ -3,7 +3,6 @@
     no_crate_inject,
     attr(deny(warnings, rust_2018_idioms), allow(dead_code, unused_variables))
 ))]
-#![doc(html_root_url = "https://docs.rs/bytes/0.6.0")]
 #![no_std]
 
 //! Provides abstractions for working with bytes.

tests/test_buf.rs

@@ -9,17 +9,17 @@ fn test_fresh_cursor_vec() {
     let mut buf = &b"hello"[..];
 
     assert_eq!(buf.remaining(), 5);
-    assert_eq!(buf.bytes(), b"hello");
+    assert_eq!(buf.chunk(), b"hello");
 
     buf.advance(2);
 
     assert_eq!(buf.remaining(), 3);
-    assert_eq!(buf.bytes(), b"llo");
+    assert_eq!(buf.chunk(), b"llo");
 
     buf.advance(3);
 
     assert_eq!(buf.remaining(), 0);
-    assert_eq!(buf.bytes(), b"");
+    assert_eq!(buf.chunk(), b"");
 }
 
 #[test]
@@ -53,7 +53,7 @@ fn test_bufs_vec() {
 
     let mut dst = [IoSlice::new(b1), IoSlice::new(b2)];
 
-    assert_eq!(1, buf.bytes_vectored(&mut dst[..]));
+    assert_eq!(1, buf.chunks_vectored(&mut dst[..]));
 }
 
 #[test]
@@ -63,9 +63,9 @@ fn test_vec_deque() {
     let mut buffer: VecDeque<u8> = VecDeque::new();
     buffer.extend(b"hello world");
     assert_eq!(11, buffer.remaining());
-    assert_eq!(b"hello world", buffer.bytes());
+    assert_eq!(b"hello world", buffer.chunk());
     buffer.advance(6);
-    assert_eq!(b"world", buffer.bytes());
+    assert_eq!(b"world", buffer.chunk());
     buffer.extend(b" piece");
     let mut out = [0; 11];
     buffer.copy_to_slice(&mut out);
@@ -81,8 +81,8 @@ fn test_deref_buf_forwards() {
             unreachable!("remaining");
         }
 
-        fn bytes(&self) -> &[u8] {
-            unreachable!("bytes");
+        fn chunk(&self) -> &[u8] {
+            unreachable!("chunk");
         }
 
         fn advance(&mut self, _: usize) {

tests/test_buf_mut.rs

@@ -9,15 +9,15 @@ use core::usize;
 fn test_vec_as_mut_buf() {
     let mut buf = Vec::with_capacity(64);
 
-    assert_eq!(buf.remaining_mut(), usize::MAX);
+    assert_eq!(buf.remaining_mut(), isize::MAX as usize);
 
-    assert!(buf.bytes_mut().len() >= 64);
+    assert!(buf.chunk_mut().len() >= 64);
 
     buf.put(&b"zomg"[..]);
 
     assert_eq!(&buf, b"zomg");
 
-    assert_eq!(buf.remaining_mut(), usize::MAX - 4);
+    assert_eq!(buf.remaining_mut(), isize::MAX as usize - 4);
     assert_eq!(buf.capacity(), 64);
 
     for _ in 0..16 {
@@ -27,6 +27,14 @@ fn test_vec_as_mut_buf() {
     assert_eq!(buf.len(), 68);
 }
 
+#[test]
+fn test_vec_put_bytes() {
+    let mut buf = Vec::new();
+    buf.push(17);
+    buf.put_bytes(19, 2);
+    assert_eq!([17, 19, 19], &buf[..]);
+}
+
 #[test]
 fn test_put_u8() {
     let mut buf = Vec::with_capacity(8);
@@ -45,6 +53,34 @@ fn test_put_u16() {
     assert_eq!(b"\x54\x21", &buf[..]);
 }
 
+#[test]
+fn test_put_int() {
+    let mut buf = Vec::with_capacity(8);
+    buf.put_int(0x1020304050607080, 3);
+    assert_eq!(b"\x60\x70\x80", &buf[..]);
+}
+
+#[test]
+#[should_panic]
+fn test_put_int_nbytes_overflow() {
+    let mut buf = Vec::with_capacity(8);
+    buf.put_int(0x1020304050607080, 9);
+}
+
+#[test]
+fn test_put_int_le() {
+    let mut buf = Vec::with_capacity(8);
+    buf.put_int_le(0x1020304050607080, 3);
+    assert_eq!(b"\x80\x70\x60", &buf[..]);
+}
+
+#[test]
+#[should_panic]
+fn test_put_int_le_nbytes_overflow() {
+    let mut buf = Vec::with_capacity(8);
+    buf.put_int_le(0x1020304050607080, 9);
+}
+
 #[test]
 #[should_panic(expected = "cannot advance")]
 fn test_vec_advance_mut() {
@@ -70,6 +106,19 @@ fn test_mut_slice() {
     let mut v = vec![0, 0, 0, 0];
     let mut s = &mut v[..];
     s.put_u32(42);
+
+    assert_eq!(s.len(), 0);
+    assert_eq!(&v, &[0, 0, 0, 42]);
+}
+
+#[test]
+fn test_slice_put_bytes() {
+    let mut v = [0, 0, 0, 0];
+    let mut s = &mut v[..];
+    s.put_u8(17);
+    s.put_bytes(19, 2);
+    assert_eq!(1, s.remaining_mut());
+    assert_eq!(&[17, 19, 19, 0], &v[..]);
 }
 
 #[test]
@@ -81,8 +130,8 @@ fn test_deref_bufmut_forwards() {
             unreachable!("remaining_mut");
         }
 
-        fn bytes_mut(&mut self) -> &mut UninitSlice {
-            unreachable!("bytes_mut");
+        fn chunk_mut(&mut self) -> &mut UninitSlice {
+            unreachable!("chunk_mut");
         }
 
         unsafe fn advance_mut(&mut self, _: usize) {

tests/test_bytes.rs

@@ -461,6 +461,7 @@ fn reserve_allocates_at_least_original_capacity() {
 }
 
 #[test]
+#[cfg_attr(miri, ignore)] // Miri is too slow
 fn reserve_max_original_capacity_value() {
     const SIZE: usize = 128 * 1024;
 
@@ -608,15 +609,15 @@ fn advance_past_len() {
 
 #[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.
-#[cfg(target_endian = "little")]
+// big endian... and qemu doesn't really support threading all that well.
+#[cfg(any(miri, target_endian = "little"))]
 fn stress() {
     // Tests promoting a buffer from a vec -> shared in a concurrent situation
     use std::sync::{Arc, Barrier};
     use std::thread;
 
     const THREADS: usize = 8;
-    const ITERS: usize = 1_000;
+    const ITERS: usize = if cfg!(miri) { 100 } else { 1_000 };
 
     for i in 0..ITERS {
         let data = [i as u8; 256];
@@ -783,6 +784,31 @@ fn bytes_mut_unsplit_empty_self() {
     assert_eq!(b"aaabbbcccddd", &buf[..]);
 }
 
+#[test]
+fn bytes_mut_unsplit_other_keeps_capacity() {
+    let mut buf = BytesMut::with_capacity(64);
+    buf.extend_from_slice(b"aabb");
+
+    // non empty other created "from" buf
+    let mut other = buf.split_off(buf.len());
+    other.extend_from_slice(b"ccddee");
+    buf.unsplit(other);
+
+    assert_eq!(buf.capacity(), 64);
+}
+
+#[test]
+fn bytes_mut_unsplit_empty_other_keeps_capacity() {
+    let mut buf = BytesMut::with_capacity(64);
+    buf.extend_from_slice(b"aabbccddee");
+
+    // empty other created "from" buf
+    let other = buf.split_off(buf.len());
+    buf.unsplit(other);
+
+    assert_eq!(buf.capacity(), 64);
+}
+
 #[test]
 fn bytes_mut_unsplit_arc_different() {
     let mut buf = BytesMut::with_capacity(64);
@@ -912,20 +938,20 @@ fn bytes_buf_mut_advance() {
     let mut bytes = BytesMut::with_capacity(1024);
 
     unsafe {
-        let ptr = bytes.bytes_mut().as_mut_ptr();
-        assert_eq!(1024, bytes.bytes_mut().len());
+        let ptr = bytes.chunk_mut().as_mut_ptr();
+        assert_eq!(1024, bytes.chunk_mut().len());
 
         bytes.advance_mut(10);
 
-        let next = bytes.bytes_mut().as_mut_ptr();
-        assert_eq!(1024 - 10, bytes.bytes_mut().len());
+        let next = bytes.chunk_mut().as_mut_ptr();
+        assert_eq!(1024 - 10, bytes.chunk_mut().len());
         assert_eq!(ptr.offset(10), next);
 
         // advance to the end
         bytes.advance_mut(1024 - 10);
 
         // The buffer size is doubled
-        assert_eq!(1024, bytes.bytes_mut().len());
+        assert_eq!(1024, bytes.chunk_mut().len());
     }
 }
 
@@ -960,3 +986,19 @@ fn bytes_with_capacity_but_empty() {
     let vec = Vec::with_capacity(1);
     let _ = Bytes::from(vec);
 }
+
+#[test]
+fn bytes_put_bytes() {
+    let mut bytes = BytesMut::new();
+    bytes.put_u8(17);
+    bytes.put_bytes(19, 2);
+    assert_eq!([17, 19, 19], bytes.as_ref());
+}
+
+#[test]
+fn box_slice_empty() {
+    // See https://github.com/tokio-rs/bytes/issues/340
+    let empty: Box<[u8]> = Default::default();
+    let b = Bytes::from(empty);
+    assert!(b.is_empty());
+}

tests/test_bytes_odd_alloc.rs

@@ -1,6 +1,8 @@
 //! Test using `Bytes` with an allocator that hands out "odd" pointers for
 //! vectors (pointers where the LSB is set).
 
+#![cfg(not(miri))] // Miri does not support custom allocators (also, Miri is "odd" by default with 50% chance)
+
 use std::alloc::{GlobalAlloc, Layout, System};
 use std::ptr;
 

tests/test_chain.rs

@@ -62,7 +62,7 @@ fn vectored_read() {
             IoSlice::new(b4),
         ];
 
-        assert_eq!(2, buf.bytes_vectored(&mut iovecs));
+        assert_eq!(2, buf.chunks_vectored(&mut iovecs));
         assert_eq!(iovecs[0][..], b"hello"[..]);
         assert_eq!(iovecs[1][..], b"world"[..]);
         assert_eq!(iovecs[2][..], b""[..]);
@@ -83,7 +83,7 @@ fn vectored_read() {
             IoSlice::new(b4),
         ];
 
-        assert_eq!(2, buf.bytes_vectored(&mut iovecs));
+        assert_eq!(2, buf.chunks_vectored(&mut iovecs));
         assert_eq!(iovecs[0][..], b"llo"[..]);
         assert_eq!(iovecs[1][..], b"world"[..]);
         assert_eq!(iovecs[2][..], b""[..]);
@@ -104,7 +104,7 @@ fn vectored_read() {
             IoSlice::new(b4),
         ];
 
-        assert_eq!(1, buf.bytes_vectored(&mut iovecs));
+        assert_eq!(1, buf.chunks_vectored(&mut iovecs));
         assert_eq!(iovecs[0][..], b"world"[..]);
         assert_eq!(iovecs[1][..], b""[..]);
         assert_eq!(iovecs[2][..], b""[..]);
@@ -125,10 +125,31 @@ fn vectored_read() {
             IoSlice::new(b4),
         ];
 
-        assert_eq!(1, buf.bytes_vectored(&mut iovecs));
+        assert_eq!(1, buf.chunks_vectored(&mut iovecs));
         assert_eq!(iovecs[0][..], b"ld"[..]);
         assert_eq!(iovecs[1][..], b""[..]);
         assert_eq!(iovecs[2][..], b""[..]);
         assert_eq!(iovecs[3][..], b""[..]);
     }
 }
+
+#[test]
+fn chain_get_bytes() {
+    let mut ab = Bytes::copy_from_slice(b"ab");
+    let mut cd = Bytes::copy_from_slice(b"cd");
+    let ab_ptr = ab.as_ptr();
+    let cd_ptr = cd.as_ptr();
+    let mut chain = (&mut ab).chain(&mut cd);
+    let a = chain.copy_to_bytes(1);
+    let bc = chain.copy_to_bytes(2);
+    let d = chain.copy_to_bytes(1);
+
+    assert_eq!(Bytes::copy_from_slice(b"a"), a);
+    assert_eq!(Bytes::copy_from_slice(b"bc"), bc);
+    assert_eq!(Bytes::copy_from_slice(b"d"), d);
+
+    // assert `get_bytes` did not allocate
+    assert_eq!(ab_ptr, a.as_ptr());
+    // assert `get_bytes` did not allocate
+    assert_eq!(cd_ptr.wrapping_offset(1), d.as_ptr());
+}

tests/test_take.rs

@@ -1,6 +1,7 @@
 #![warn(rust_2018_idioms)]
 
 use bytes::buf::Buf;
+use bytes::Bytes;
 
 #[test]
 fn long_take() {
@@ -8,5 +9,24 @@ fn long_take() {
     // overrun the buffer. Regression test for #138.
     let buf = b"hello world".take(100);
     assert_eq!(11, buf.remaining());
-    assert_eq!(b"hello world", buf.bytes());
+    assert_eq!(b"hello world", buf.chunk());
+}
+
+#[test]
+fn take_copy_to_bytes() {
+    let mut abcd = Bytes::copy_from_slice(b"abcd");
+    let abcd_ptr = abcd.as_ptr();
+    let mut take = (&mut abcd).take(2);
+    let a = take.copy_to_bytes(1);
+    assert_eq!(Bytes::copy_from_slice(b"a"), a);
+    // assert `to_bytes` did not allocate
+    assert_eq!(abcd_ptr, a.as_ptr());
+    assert_eq!(Bytes::copy_from_slice(b"bcd"), abcd);
+}
+
+#[test]
+#[should_panic]
+fn take_copy_to_bytes_panics() {
+    let abcd = Bytes::copy_from_slice(b"abcd");
+    abcd.take(2).copy_to_bytes(3);
 }