BytesMut::unsplit: rename to join

.github/workflows/ci.yml

@@ -11,7 +11,6 @@ on:
 env:
   RUSTFLAGS: -Dwarnings
   RUST_BACKTRACE: 1
-  nightly: nightly-2021-04-13
 
 defaults:
   run:
@@ -75,11 +74,14 @@ 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 $nightly && rustup default $nightly
+        run: rustup update $RUST_VERSION && rustup default $RUST_VERSION
       - name: Test
         run: . ci/test-stable.sh test
 
@@ -94,7 +96,7 @@ jobs:
           - powerpc-unknown-linux-gnu
           - powerpc64-unknown-linux-gnu
           - wasm32-unknown-unknown
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-16.04
     steps:
       - uses: actions/checkout@v2
       - name: Install Rust
@@ -118,27 +120,23 @@ 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 $nightly && rustup default $nightly
+        run: rustup update $RUST_VERSION && rustup default $RUST_VERSION
       - name: Loom tests
         run: RUSTFLAGS="--cfg loom -Dwarnings" cargo test --lib
 
@@ -151,8 +149,6 @@ jobs:
       - nightly
       - minrust
       - cross
-      - tsan
-      - loom
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
@@ -160,8 +156,6 @@ 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,20 +1,3 @@
-# 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

@@ -5,15 +5,15 @@ name = "bytes"
 # - Update html_root_url.
 # - Update CHANGELOG.md.
 # - Update doc URL.
-# - Create "v1.0.x" git tag.
-version = "1.0.1"
+# - Create "v0.6.x" git tag.
+version = "0.6.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/1.0.1/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"]
@@ -26,13 +26,9 @@ std = []
 
 [dependencies]
 serde = { version = "1.0.60", optional = true, default-features = false, features = ["alloc"] }
-tracing = { version = "0.1.26", default-features = false }
 
 [dev-dependencies]
 serde_test = "1.0"
 
 [target.'cfg(loom)'.dev-dependencies]
-loom = "0.5"
-
-[package.metadata.docs.rs]
-rustdoc-args = ["--cfg", "docsrs"]
+loom = "0.3"

README.md

@@ -18,7 +18,7 @@ To use `bytes`, first add this to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-bytes = "1"
+bytes = "0.6"
 ```
 
 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 = "1", features = ["serde"] }
+bytes = { version = "0.6", features = ["serde"] }
 ```
 
 ## License

benches/buf.rs

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

ci/miri.sh

@@ -1,11 +0,0 @@
-#!/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

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
-            .chunk()
+            .bytes()
             .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 `chunk()`.
+    /// by `bytes`.
     ///
     /// # Examples
     ///
@@ -115,34 +115,31 @@ pub trait Buf {
     ///
     /// let mut buf = &b"hello world"[..];
     ///
-    /// assert_eq!(buf.chunk(), &b"hello world"[..]);
+    /// assert_eq!(buf.bytes(), &b"hello world"[..]);
     ///
     /// buf.advance(6);
     ///
-    /// assert_eq!(buf.chunk(), &b"world"[..]);
+    /// assert_eq!(buf.bytes(), &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 `chunk()` should return an
+    /// i.e., `Buf::remaining` returns 0, calls to `bytes` should return an
     /// empty slice.
-    // 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];
+    fn bytes(&self) -> &[u8];
 
     /// Fills `dst` with potentially multiple slices starting at `self`'s
     /// current position.
     ///
-    /// If the `Buf` is backed by disjoint slices of bytes, `chunk_vectored` enables
+    /// If the `Buf` is backed by disjoint slices of bytes, `bytes_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 `chunk_vectored` does not fill every
+    /// the slices **will not** be modified. If `bytes_vectored` does not fill every
     /// entry in `dst`, then `dst` is guaranteed to contain all remaining slices
     /// in `self.
     ///
@@ -152,7 +149,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 `chunk_vectored` must return 0
+    /// i.e., `Buf::remaining` returns 0, calls to `bytes_vectored` must return 0
     /// without mutating `dst`.
     ///
     /// Implementations should also take care to properly handle being called
@@ -160,13 +157,13 @@ pub trait Buf {
     ///
     /// [`writev`]: http://man7.org/linux/man-pages/man2/readv.2.html
     #[cfg(feature = "std")]
-    fn chunks_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {
+    fn bytes_vectored<'a>(&'a self, dst: &mut [IoSlice<'a>]) -> usize {
         if dst.is_empty() {
             return 0;
         }
 
         if self.has_remaining() {
-            dst[0] = IoSlice::new(self.chunk());
+            dst[0] = IoSlice::new(self.bytes());
             1
         } else {
             0
@@ -175,7 +172,7 @@ pub trait Buf {
 
     /// Advance the internal cursor of the Buf
     ///
-    /// The next call to `chunk()` will return a slice starting `cnt` bytes
+    /// The next call to `bytes` will return a slice starting `cnt` bytes
     /// further into the underlying buffer.
     ///
     /// # Examples
@@ -185,11 +182,11 @@ pub trait Buf {
     ///
     /// let mut buf = &b"hello world"[..];
     ///
-    /// assert_eq!(buf.chunk(), &b"hello world"[..]);
+    /// assert_eq!(buf.bytes(), &b"hello world"[..]);
     ///
     /// buf.advance(6);
     ///
-    /// assert_eq!(buf.chunk(), &b"world"[..]);
+    /// assert_eq!(buf.bytes(), &b"world"[..]);
     /// ```
     ///
     /// # Panics
@@ -256,7 +253,7 @@ pub trait Buf {
             let cnt;
 
             unsafe {
-                let src = self.chunk();
+                let src = self.bytes();
                 cnt = cmp::min(src.len(), dst.len() - off);
 
                 ptr::copy_nonoverlapping(src.as_ptr(), dst[off..].as_mut_ptr(), cnt);
@@ -286,7 +283,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.chunk()[0];
+        let ret = self.bytes()[0];
         self.advance(1);
         ret
     }
@@ -309,7 +306,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.chunk()[0] as i8;
+        let ret = self.bytes()[0] as i8;
         self.advance(1);
         ret
     }
@@ -864,7 +861,7 @@ pub trait Buf {
     /// let mut chain = b"hello "[..].chain(&b"world"[..]);
     ///
     /// let full = chain.copy_to_bytes(11);
-    /// assert_eq!(full.chunk(), b"hello world");
+    /// assert_eq!(full.bytes(), b"hello world");
     /// ```
     fn chain<U: Buf>(self, next: U) -> Chain<Self, U>
     where
@@ -911,13 +908,13 @@ macro_rules! deref_forward_buf {
             (**self).remaining()
         }
 
-        fn chunk(&self) -> &[u8] {
-            (**self).chunk()
+        fn bytes(&self) -> &[u8] {
+            (**self).bytes()
         }
 
         #[cfg(feature = "std")]
-        fn chunks_vectored<'b>(&'b self, dst: &mut [IoSlice<'b>]) -> usize {
-            (**self).chunks_vectored(dst)
+        fn bytes_vectored<'b>(&'b self, dst: &mut [IoSlice<'b>]) -> usize {
+            (**self).bytes_vectored(dst)
         }
 
         fn advance(&mut self, cnt: usize) {
@@ -1025,7 +1022,7 @@ impl Buf for &[u8] {
     }
 
     #[inline]
-    fn chunk(&self) -> &[u8] {
+    fn bytes(&self) -> &[u8] {
         self
     }
 
@@ -1035,6 +1032,35 @@ 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 {
@@ -1048,7 +1074,7 @@ impl<T: AsRef<[u8]>> Buf for std::io::Cursor<T> {
         len - pos as usize
     }
 
-    fn chunk(&self) -> &[u8] {
+    fn bytes(&self) -> &[u8] {
         let len = self.get_ref().as_ref().len();
         let pos = self.position();
 

src/buf/buf_mut.rs

@@ -31,7 +31,7 @@ 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 `chunk_mut()`.
+    /// by `bytes_mut`.
     ///
     /// # Examples
     ///
@@ -56,7 +56,7 @@ pub unsafe trait BufMut {
 
     /// Advance the internal cursor of the BufMut
     ///
-    /// The next call to `chunk_mut` will return a slice starting `cnt` bytes
+    /// The next call to `bytes_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 +70,11 @@ pub unsafe trait BufMut {
     /// let mut buf = Vec::with_capacity(16);
     ///
     /// // Write some data
-    /// buf.chunk_mut()[0..2].copy_from_slice(b"he");
+    /// buf.bytes_mut()[0..2].copy_from_slice(b"he");
     /// unsafe { buf.advance_mut(2) };
     ///
     /// // write more bytes
-    /// buf.chunk_mut()[0..3].copy_from_slice(b"llo");
+    /// buf.bytes_mut()[0..3].copy_from_slice(b"llo");
     ///
     /// unsafe { buf.advance_mut(3); }
     ///
@@ -135,14 +135,14 @@ pub unsafe trait BufMut {
     ///
     /// unsafe {
     ///     // MaybeUninit::as_mut_ptr
-    ///     buf.chunk_mut()[0..].as_mut_ptr().write(b'h');
-    ///     buf.chunk_mut()[1..].as_mut_ptr().write(b'e');
+    ///     buf.bytes_mut()[0..].as_mut_ptr().write(b'h');
+    ///     buf.bytes_mut()[1..].as_mut_ptr().write(b'e');
     ///
     ///     buf.advance_mut(2);
     ///
-    ///     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.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.advance_mut(3);
     /// }
@@ -153,15 +153,12 @@ pub unsafe trait BufMut {
     ///
     /// # Implementer notes
     ///
-    /// 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
+    /// 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
     /// return an empty slice.
-    // 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;
+    fn bytes_mut(&mut self) -> &mut UninitSlice;
 
     /// Transfer bytes into `self` from `src` and advance the cursor by the
     /// number of bytes written.
@@ -193,8 +190,8 @@ pub unsafe trait BufMut {
             let l;
 
             unsafe {
-                let s = src.chunk();
-                let d = self.chunk_mut();
+                let s = src.bytes();
+                let d = self.bytes_mut();
                 l = cmp::min(s.len(), d.len());
 
                 ptr::copy_nonoverlapping(s.as_ptr(), d.as_mut_ptr() as *mut u8, l);
@@ -240,7 +237,7 @@ pub unsafe trait BufMut {
             let cnt;
 
             unsafe {
-                let dst = self.chunk_mut();
+                let dst = self.bytes_mut();
                 cnt = cmp::min(dst.len(), src.len() - off);
 
                 ptr::copy_nonoverlapping(src[off..].as_ptr(), dst.as_mut_ptr() as *mut u8, cnt);
@@ -916,8 +913,8 @@ macro_rules! deref_forward_bufmut {
             (**self).remaining_mut()
         }
 
-        fn chunk_mut(&mut self) -> &mut UninitSlice {
-            (**self).chunk_mut()
+        fn bytes_mut(&mut self) -> &mut UninitSlice {
+            (**self).bytes_mut()
         }
 
         unsafe fn advance_mut(&mut self, cnt: usize) {
@@ -1001,7 +998,7 @@ unsafe impl BufMut for &mut [u8] {
     }
 
     #[inline]
-    fn chunk_mut(&mut self) -> &mut UninitSlice {
+    fn bytes_mut(&mut self) -> &mut UninitSlice {
         // UninitSlice is repr(transparent), so safe to transmute
         unsafe { &mut *(*self as *mut [u8] as *mut _) }
     }
@@ -1012,14 +1009,6 @@ 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());
-        }
-    }
 }
 
 unsafe impl BufMut for Vec<u8> {
@@ -1044,7 +1033,7 @@ unsafe impl BufMut for Vec<u8> {
     }
 
     #[inline]
-    fn chunk_mut(&mut self) -> &mut UninitSlice {
+    fn bytes_mut(&mut self) -> &mut UninitSlice {
         if self.capacity() == self.len() {
             self.reserve(64); // Grow the vec
         }
@@ -1058,6 +1047,7 @@ 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,
@@ -1070,7 +1060,7 @@ unsafe impl BufMut for Vec<u8> {
 
             // a block to contain the src.bytes() borrow
             {
-                let s = src.chunk();
+                let s = src.bytes();
                 l = s.len();
                 self.extend_from_slice(s);
             }
@@ -1079,7 +1069,6 @@ unsafe impl BufMut for Vec<u8> {
         }
     }
 
-    #[inline]
     fn put_slice(&mut self, src: &[u8]) {
         self.extend_from_slice(src);
     }

src/buf/chain.rs

@@ -1,5 +1,5 @@
 use crate::buf::{IntoIter, UninitSlice};
-use crate::{Buf, BufMut, Bytes};
+use crate::{Buf, BufMut};
 
 #[cfg(feature = "std")]
 use std::io::IoSlice;
@@ -135,14 +135,14 @@ where
     U: Buf,
 {
     fn remaining(&self) -> usize {
-        self.a.remaining().checked_add(self.b.remaining()).unwrap()
+        self.a.remaining() + self.b.remaining()
     }
 
-    fn chunk(&self) -> &[u8] {
+    fn bytes(&self) -> &[u8] {
         if self.a.has_remaining() {
-            self.a.chunk()
+            self.a.bytes()
         } else {
-            self.b.chunk()
+            self.b.bytes()
         }
     }
 
@@ -165,29 +165,11 @@ where
     }
 
     #[cfg(feature = "std")]
-    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..]);
+    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..]);
         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>
@@ -196,17 +178,14 @@ where
     U: BufMut,
 {
     fn remaining_mut(&self) -> usize {
-        self.a
-            .remaining_mut()
-            .checked_add(self.b.remaining_mut())
-            .unwrap()
+        self.a.remaining_mut() + self.b.remaining_mut()
     }
 
-    fn chunk_mut(&mut self) -> &mut UninitSlice {
+    fn bytes_mut(&mut self) -> &mut UninitSlice {
         if self.a.has_remaining_mut() {
-            self.a.chunk_mut()
+            self.a.bytes_mut()
         } else {
-            self.b.chunk_mut()
+            self.b.bytes_mut()
         }
     }
 

src/buf/iter.rs

@@ -117,7 +117,7 @@ impl<T: Buf> Iterator for IntoIter<T> {
             return None;
         }
 
-        let b = self.inner.chunk()[0];
+        let b = self.inner.bytes()[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 chunk_mut(&mut self) -> &mut UninitSlice {
-        let bytes = self.inner.chunk_mut();
+    fn bytes_mut(&mut self) -> &mut UninitSlice {
+        let bytes = self.inner.bytes_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.chunk())
+        Ok(self.buf.bytes())
     }
     fn consume(&mut self, amt: usize) {
         self.buf.advance(amt)

src/buf/take.rs

@@ -1,11 +1,11 @@
-use crate::{Buf, Bytes};
+use crate::Buf;
 
 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.Buf.html#method.take) for more details.
+/// documentation of [`take()`](trait.BufExt.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 chunk(&self) -> &[u8] {
-        let bytes = self.inner.chunk();
+    fn bytes(&self) -> &[u8] {
+        let bytes = self.inner.bytes();
         &bytes[..cmp::min(bytes.len(), self.limit)]
     }
 
@@ -144,12 +144,4 @@ 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::chunk_mut()`, the referenced byte slice may be
+/// Returned by `BufMut::bytes_mut()`, the referenced byte slice may be
 /// uninitialized. The wrapper provides safe access without introducing
 /// undefined behavior.
 ///
@@ -40,7 +40,6 @@ 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);
@@ -65,7 +64,6 @@ impl UninitSlice {
     ///
     /// assert_eq!(b"boo", &data[..]);
     /// ```
-    #[inline]
     pub fn write_byte(&mut self, index: usize, byte: u8) {
         assert!(index < self.len());
 
@@ -92,7 +90,6 @@ impl UninitSlice {
     ///
     /// assert_eq!(b"bar", &data[..]);
     /// ```
-    #[inline]
     pub fn copy_from_slice(&mut self, src: &[u8]) {
         use core::ptr;
 
@@ -117,9 +114,8 @@ impl UninitSlice {
     ///
     /// let mut data = [0, 1, 2];
     /// let mut slice = &mut data[..];
-    /// let ptr = BufMut::chunk_mut(&mut slice).as_mut_ptr();
+    /// let ptr = BufMut::bytes_mut(&mut slice).as_mut_ptr();
     /// ```
-    #[inline]
     pub fn as_mut_ptr(&mut self) -> *mut u8 {
         self.0.as_mut_ptr() as *mut _
     }
@@ -133,11 +129,10 @@ impl UninitSlice {
     ///
     /// let mut data = [0, 1, 2];
     /// let mut slice = &mut data[..];
-    /// let len = BufMut::chunk_mut(&mut slice).len();
+    /// let len = BufMut::bytes_mut(&mut slice).len();
     ///
     /// assert_eq!(len, 3);
     /// ```
-    #[inline]
     pub fn len(&self) -> usize {
         self.0.len()
     }
@@ -155,7 +150,6 @@ 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) }
@@ -163,7 +157,6 @@ 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 chunk(&self) -> &[u8] {
+    fn bytes(&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 chunk(&self) -> &[u8] {
+    fn bytes(&self) -> &[u8] {
         self.as_slice()
     }
 
@@ -806,7 +806,8 @@ impl From<Vec<u8>> for Bytes {
 
         let slice = vec.into_boxed_slice();
         let len = slice.len();
-        let ptr = Box::into_raw(slice) as *mut u8;
+        let ptr = slice.as_ptr();
+        drop(Box::into_raw(slice));
 
         if ptr as usize & 0x1 == 0 {
             let data = ptr as usize | KIND_VEC;
@@ -968,7 +969,7 @@ unsafe fn shared_drop(data: &mut AtomicPtr<()>, _ptr: *const u8, _len: usize) {
 
 unsafe fn shallow_clone_arc(shared: *mut Shared, ptr: *const u8, len: usize) -> Bytes {
     let old_size = (*shared).ref_cnt.fetch_add(1, Ordering::Relaxed);
-    tracing::trace!(shared.addr = %format_args!("{:p}", shared), shared.refs = old_size, "shallow_clone_arc");
+
     if old_size > usize::MAX >> 1 {
         crate::abort();
     }
@@ -1022,42 +1023,38 @@ unsafe fn shallow_clone_vec(
     // `Release` is used synchronize with other threads that
     // will load the `arc` field.
     //
-    // If the `compare_exchange` fails, then the thread lost the
+    // If the `compare_and_swap` fails, then the thread lost the
     // race to promote the buffer to shared. The `Acquire`
-    // ordering will synchronize with the `compare_exchange`
+    // ordering will synchronize with the `compare_and_swap`
     // that happened in the other thread and the `Shared`
     // pointed to by `actual` will be visible.
-    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);
+    let actual = atom.compare_and_swap(ptr as _, shared as _, Ordering::AcqRel);
 
-            // Buffer already promoted to shared storage, so increment ref
-            // count.
-            shallow_clone_arc(actual as _, offset, len)
-        }
+    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,
+        };
     }
+
+    // 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) {
     // `Shared` storage... follow the drop steps from Arc.
-    let ref_cnt = (*ptr).ref_cnt.fetch_sub(1, Ordering::Release);
-    tracing::trace!(shared.addr = %format_args!("{:p}", ptr), shared.refs = ref_cnt, "release_shared");
-    if ref_cnt != 1 {
+    if (*ptr).ref_cnt.fetch_sub(1, Ordering::Release) != 1 {
         return;
     }
 
@@ -1082,8 +1079,6 @@ unsafe fn release_shared(ptr: *mut Shared) {
 
     // Drop the data
     Box::from_raw(ptr);
-
-    tracing::trace!(shared.addr = %format_args!("{:p}", ptr), "release_shared: dropped");
 }
 
 // compile-fails

src/bytes_mut.rs

@@ -445,7 +445,7 @@ impl BytesMut {
             let additional = new_len - len;
             self.reserve(additional);
             unsafe {
-                let dst = self.chunk_mut().as_mut_ptr();
+                let dst = self.bytes_mut().as_mut_ptr();
                 ptr::write_bytes(dst, value, additional);
                 self.set_len(new_len);
             }
@@ -716,16 +716,16 @@ impl BytesMut {
     /// assert_eq!(b"aaabbb", &buf[..]);
     /// assert_eq!(b"cccddd", &split[..]);
     ///
-    /// buf.unsplit(split);
+    /// buf.join(split);
     /// assert_eq!(b"aaabbbcccddd", &buf[..]);
     /// ```
-    pub fn unsplit(&mut self, other: BytesMut) {
+    pub fn join(&mut self, other: BytesMut) {
         if self.is_empty() {
             *self = other;
             return;
         }
 
-        if let Err(other) = self.try_unsplit(other) {
+        if let Err(other) = self.try_join(other) {
             self.extend_from_slice(other.as_ref());
         }
     }
@@ -818,7 +818,7 @@ impl BytesMut {
         self.len = cmp::min(self.len, end);
     }
 
-    fn try_unsplit(&mut self, other: BytesMut) -> Result<(), BytesMut> {
+    fn try_join(&mut self, other: BytesMut) -> Result<(), BytesMut> {
         if other.is_empty() {
             return Ok(());
         }
@@ -944,7 +944,7 @@ impl Buf for BytesMut {
     }
 
     #[inline]
-    fn chunk(&self) -> &[u8] {
+    fn bytes(&self) -> &[u8] {
         self.as_slice()
     }
 
@@ -985,7 +985,7 @@ unsafe impl BufMut for BytesMut {
     }
 
     #[inline]
-    fn chunk_mut(&mut self) -> &mut UninitSlice {
+    fn bytes_mut(&mut self) -> &mut UninitSlice {
         if self.capacity() == self.len() {
             self.reserve(64);
         }
@@ -1000,7 +1000,7 @@ unsafe impl BufMut for BytesMut {
         Self: Sized,
     {
         while src.has_remaining() {
-            let s = src.chunk();
+            let s = src.bytes();
             let l = s.len();
             self.extend_from_slice(s);
             src.advance(l);
@@ -1250,7 +1250,6 @@ 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(
@@ -1477,7 +1476,6 @@ 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,7 @@
     no_crate_inject,
     attr(deny(warnings, rust_2018_idioms), allow(dead_code, unused_variables))
 ))]
-#![doc(html_root_url = "https://docs.rs/bytes/1.0.1")]
+#![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.chunk(), b"hello");
+    assert_eq!(buf.bytes(), b"hello");
 
     buf.advance(2);
 
     assert_eq!(buf.remaining(), 3);
-    assert_eq!(buf.chunk(), b"llo");
+    assert_eq!(buf.bytes(), b"llo");
 
     buf.advance(3);
 
     assert_eq!(buf.remaining(), 0);
-    assert_eq!(buf.chunk(), b"");
+    assert_eq!(buf.bytes(), b"");
 }
 
 #[test]
@@ -53,7 +53,7 @@ fn test_bufs_vec() {
 
     let mut dst = [IoSlice::new(b1), IoSlice::new(b2)];
 
-    assert_eq!(1, buf.chunks_vectored(&mut dst[..]));
+    assert_eq!(1, buf.bytes_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.chunk());
+    assert_eq!(b"hello world", buffer.bytes());
     buffer.advance(6);
-    assert_eq!(b"world", buffer.chunk());
+    assert_eq!(b"world", buffer.bytes());
     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 chunk(&self) -> &[u8] {
-            unreachable!("chunk");
+        fn bytes(&self) -> &[u8] {
+            unreachable!("bytes");
         }
 
         fn advance(&mut self, _: usize) {

tests/test_buf_mut.rs

@@ -11,7 +11,7 @@ fn test_vec_as_mut_buf() {
 
     assert_eq!(buf.remaining_mut(), usize::MAX);
 
-    assert!(buf.chunk_mut().len() >= 64);
+    assert!(buf.bytes_mut().len() >= 64);
 
     buf.put(&b"zomg"[..]);
 
@@ -70,9 +70,6 @@ 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]
@@ -84,8 +81,8 @@ fn test_deref_bufmut_forwards() {
             unreachable!("remaining_mut");
         }
 
-        fn chunk_mut(&mut self) -> &mut UninitSlice {
-            unreachable!("chunk_mut");
+        fn bytes_mut(&mut self) -> &mut UninitSlice {
+            unreachable!("bytes_mut");
         }
 
         unsafe fn advance_mut(&mut self, _: usize) {

tests/test_bytes.rs

@@ -461,7 +461,6 @@ 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;
 
@@ -609,15 +608,15 @@ fn advance_past_len() {
 
 #[test]
 // Only run these tests on little endian systems. CI uses qemu for testing
-// big endian... and qemu doesn't really support threading all that well.
-#[cfg(any(miri, target_endian = "little"))]
+// little endian... and qemu doesn't really support threading all that well.
+#[cfg(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 = if cfg!(miri) { 100 } else { 1_000 };
+    const ITERS: usize = 1_000;
 
     for i in 0..ITERS {
         let data = [i as u8; 256];
@@ -658,42 +657,42 @@ fn partial_eq_bytesmut() {
 
 /*
 #[test]
-fn bytes_unsplit_basic() {
+fn bytes_join_basic() {
     let buf = Bytes::from(&b"aaabbbcccddd"[..]);
 
     let splitted = buf.split_off(6);
     assert_eq!(b"aaabbb", &buf[..]);
     assert_eq!(b"cccddd", &splitted[..]);
 
-    buf.unsplit(splitted);
+    buf.join(splitted);
     assert_eq!(b"aaabbbcccddd", &buf[..]);
 }
 
 #[test]
-fn bytes_unsplit_empty_other() {
+fn bytes_join_empty_other() {
     let buf = Bytes::from(&b"aaabbbcccddd"[..]);
 
     // empty other
     let other = Bytes::new();
 
-    buf.unsplit(other);
+    buf.join(other);
     assert_eq!(b"aaabbbcccddd", &buf[..]);
 }
 
 #[test]
-fn bytes_unsplit_empty_self() {
+fn bytes_join_empty_self() {
     // empty self
     let mut buf = Bytes::new();
 
     let mut other = Bytes::with_capacity(64);
     other.extend_from_slice(b"aaabbbcccddd");
 
-    buf.unsplit(other);
+    buf.join(other);
     assert_eq!(b"aaabbbcccddd", &buf[..]);
 }
 
 #[test]
-fn bytes_unsplit_arc_different() {
+fn bytes_join_arc_different() {
     let mut buf = Bytes::with_capacity(64);
     buf.extend_from_slice(b"aaaabbbbeeee");
 
@@ -704,12 +703,12 @@ fn bytes_unsplit_arc_different() {
 
     buf2.split_off(8); //arc
 
-    buf.unsplit(buf2);
+    buf.join(buf2);
     assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
 }
 
 #[test]
-fn bytes_unsplit_arc_non_contiguous() {
+fn bytes_join_arc_non_contiguous() {
     let mut buf = Bytes::with_capacity(64);
     buf.extend_from_slice(b"aaaabbbbeeeeccccdddd");
 
@@ -717,38 +716,38 @@ fn bytes_unsplit_arc_non_contiguous() {
 
     let buf3 = buf2.split_off(4); //arc
 
-    buf.unsplit(buf3);
+    buf.join(buf3);
     assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
 }
 
 #[test]
-fn bytes_unsplit_two_split_offs() {
+fn bytes_join_two_split_offs() {
     let mut buf = Bytes::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);
+    buf2.join(buf3);
+    buf.join(buf2);
     assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
 }
 
 #[test]
-fn bytes_unsplit_overlapping_references() {
+fn bytes_join_overlapping_references() {
     let mut buf = Bytes::with_capacity(64);
     buf.extend_from_slice(b"abcdefghijklmnopqrstuvwxyz");
     let mut buf0010 = buf.slice(0..10);
     let buf1020 = buf.slice(10..20);
     let buf0515 = buf.slice(5..15);
-    buf0010.unsplit(buf1020);
+    buf0010.join(buf1020);
     assert_eq!(b"abcdefghijklmnopqrst", &buf0010[..]);
     assert_eq!(b"fghijklmno", &buf0515[..]);
 }
 */
 
 #[test]
-fn bytes_mut_unsplit_basic() {
+fn bytes_mut_join_basic() {
     let mut buf = BytesMut::with_capacity(64);
     buf.extend_from_slice(b"aaabbbcccddd");
 
@@ -756,36 +755,36 @@ fn bytes_mut_unsplit_basic() {
     assert_eq!(b"aaabbb", &buf[..]);
     assert_eq!(b"cccddd", &splitted[..]);
 
-    buf.unsplit(splitted);
+    buf.join(splitted);
     assert_eq!(b"aaabbbcccddd", &buf[..]);
 }
 
 #[test]
-fn bytes_mut_unsplit_empty_other() {
+fn bytes_mut_join_empty_other() {
     let mut buf = BytesMut::with_capacity(64);
     buf.extend_from_slice(b"aaabbbcccddd");
 
     // empty other
     let other = BytesMut::new();
 
-    buf.unsplit(other);
+    buf.join(other);
     assert_eq!(b"aaabbbcccddd", &buf[..]);
 }
 
 #[test]
-fn bytes_mut_unsplit_empty_self() {
+fn bytes_mut_join_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);
+    buf.join(other);
     assert_eq!(b"aaabbbcccddd", &buf[..]);
 }
 
 #[test]
-fn bytes_mut_unsplit_arc_different() {
+fn bytes_mut_join_arc_different() {
     let mut buf = BytesMut::with_capacity(64);
     buf.extend_from_slice(b"aaaabbbbeeee");
 
@@ -796,12 +795,12 @@ fn bytes_mut_unsplit_arc_different() {
 
     let _ = buf2.split_off(8); //arc
 
-    buf.unsplit(buf2);
+    buf.join(buf2);
     assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
 }
 
 #[test]
-fn bytes_mut_unsplit_arc_non_contiguous() {
+fn bytes_mut_join_arc_non_contiguous() {
     let mut buf = BytesMut::with_capacity(64);
     buf.extend_from_slice(b"aaaabbbbeeeeccccdddd");
 
@@ -809,20 +808,20 @@ fn bytes_mut_unsplit_arc_non_contiguous() {
 
     let buf3 = buf2.split_off(4); //arc
 
-    buf.unsplit(buf3);
+    buf.join(buf3);
     assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
 }
 
 #[test]
-fn bytes_mut_unsplit_two_split_offs() {
+fn bytes_mut_join_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);
+    buf2.join(buf3);
+    buf.join(buf2);
     assert_eq!(b"aaaabbbbccccdddd", &buf[..]);
 }
 
@@ -913,20 +912,20 @@ fn bytes_buf_mut_advance() {
     let mut bytes = BytesMut::with_capacity(1024);
 
     unsafe {
-        let ptr = bytes.chunk_mut().as_mut_ptr();
-        assert_eq!(1024, bytes.chunk_mut().len());
+        let ptr = bytes.bytes_mut().as_mut_ptr();
+        assert_eq!(1024, bytes.bytes_mut().len());
 
         bytes.advance_mut(10);
 
-        let next = bytes.chunk_mut().as_mut_ptr();
-        assert_eq!(1024 - 10, bytes.chunk_mut().len());
+        let next = bytes.bytes_mut().as_mut_ptr();
+        assert_eq!(1024 - 10, bytes.bytes_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.chunk_mut().len());
+        assert_eq!(1024, bytes.bytes_mut().len());
     }
 }
 

tests/test_bytes_odd_alloc.rs

@@ -1,8 +1,6 @@
 //! 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.chunks_vectored(&mut iovecs));
+        assert_eq!(2, buf.bytes_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.chunks_vectored(&mut iovecs));
+        assert_eq!(2, buf.bytes_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.chunks_vectored(&mut iovecs));
+        assert_eq!(1, buf.bytes_vectored(&mut iovecs));
         assert_eq!(iovecs[0][..], b"world"[..]);
         assert_eq!(iovecs[1][..], b""[..]);
         assert_eq!(iovecs[2][..], b""[..]);
@@ -125,31 +125,10 @@ fn vectored_read() {
             IoSlice::new(b4),
         ];
 
-        assert_eq!(1, buf.chunks_vectored(&mut iovecs));
+        assert_eq!(1, buf.bytes_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,7 +1,6 @@
 #![warn(rust_2018_idioms)]
 
 use bytes::buf::Buf;
-use bytes::Bytes;
 
 #[test]
 fn long_take() {
@@ -9,24 +8,5 @@ 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.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);
+    assert_eq!(b"hello world", buf.bytes());
 }