chore: update bytes dependency to git master (#1796)

Tokio will track changes to bytes until 0.5 is released.

tokio-util/tests/codecs.rs

@@ -45,14 +45,14 @@ fn lines_decoder() {
     let mut codec = LinesCodec::new();
     let buf = &mut BytesMut::new();
     buf.reserve(200);
-    buf.put("line 1\nline 2\r\nline 3\n\r\n\r");
+    buf.put_slice(b"line 1\nline 2\r\nline 3\n\r\n\r");
     assert_eq!("line 1", codec.decode(buf).unwrap().unwrap());
     assert_eq!("line 2", codec.decode(buf).unwrap().unwrap());
     assert_eq!("line 3", codec.decode(buf).unwrap().unwrap());
     assert_eq!("", codec.decode(buf).unwrap().unwrap());
     assert_eq!(None, codec.decode(buf).unwrap());
     assert_eq!(None, codec.decode_eof(buf).unwrap());
-    buf.put("k");
+    buf.put_slice(b"k");
     assert_eq!(None, codec.decode(buf).unwrap());
     assert_eq!("\rk", codec.decode_eof(buf).unwrap().unwrap());
     assert_eq!(None, codec.decode(buf).unwrap());
@@ -67,7 +67,7 @@ fn lines_decoder_max_length() {
     let buf = &mut BytesMut::new();
 
     buf.reserve(200);
-    buf.put("line 1 is too long\nline 2\nline 3\r\nline 4\n\r\n\r");
+    buf.put_slice(b"line 1 is too long\nline 2\nline 3\r\nline 4\n\r\n\r");
 
     assert!(codec.decode(buf).is_err());
 
@@ -102,7 +102,7 @@ fn lines_decoder_max_length() {
 
     assert_eq!(None, codec.decode(buf).unwrap());
     assert_eq!(None, codec.decode_eof(buf).unwrap());
-    buf.put("k");
+    buf.put_slice(b"k");
     assert_eq!(None, codec.decode(buf).unwrap());
 
     let line = codec.decode_eof(buf).unwrap().unwrap();
@@ -119,7 +119,7 @@ fn lines_decoder_max_length() {
 
     // Line that's one character too long. This could cause an out of bounds
     // error if we peek at the next characters using slice indexing.
-    buf.put("aaabbbc");
+    buf.put_slice(b"aaabbbc");
     assert!(codec.decode(buf).is_err());
 }
 
@@ -131,16 +131,16 @@ fn lines_decoder_max_length_underrun() {
     let buf = &mut BytesMut::new();
 
     buf.reserve(200);
-    buf.put("line ");
+    buf.put_slice(b"line ");
     assert_eq!(None, codec.decode(buf).unwrap());
-    buf.put("too l");
+    buf.put_slice(b"too l");
     assert!(codec.decode(buf).is_err());
-    buf.put("ong\n");
+    buf.put_slice(b"ong\n");
     assert_eq!(None, codec.decode(buf).unwrap());
 
-    buf.put("line 2");
+    buf.put_slice(b"line 2");
     assert_eq!(None, codec.decode(buf).unwrap());
-    buf.put("\n");
+    buf.put_slice(b"\n");
     assert_eq!("line 2", codec.decode(buf).unwrap().unwrap());
 }
 
@@ -152,11 +152,11 @@ fn lines_decoder_max_length_bursts() {
     let buf = &mut BytesMut::new();
 
     buf.reserve(200);
-    buf.put("line ");
+    buf.put_slice(b"line ");
     assert_eq!(None, codec.decode(buf).unwrap());
-    buf.put("too l");
+    buf.put_slice(b"too l");
     assert_eq!(None, codec.decode(buf).unwrap());
-    buf.put("ong\n");
+    buf.put_slice(b"ong\n");
     assert!(codec.decode(buf).is_err());
 }
 
@@ -168,9 +168,9 @@ fn lines_decoder_max_length_big_burst() {
     let buf = &mut BytesMut::new();
 
     buf.reserve(200);
-    buf.put("line ");
+    buf.put_slice(b"line ");
     assert_eq!(None, codec.decode(buf).unwrap());
-    buf.put("too long!\n");
+    buf.put_slice(b"too long!\n");
     assert!(codec.decode(buf).is_err());
 }
 
@@ -182,10 +182,10 @@ fn lines_decoder_max_length_newline_between_decodes() {
     let buf = &mut BytesMut::new();
 
     buf.reserve(200);
-    buf.put("hello");
+    buf.put_slice(b"hello");
     assert_eq!(None, codec.decode(buf).unwrap());
 
-    buf.put("\nworld");
+    buf.put_slice(b"\nworld");
     assert_eq!("hello", codec.decode(buf).unwrap().unwrap());
 }
 
@@ -198,9 +198,9 @@ fn lines_decoder_discard_repeat() {
     let buf = &mut BytesMut::new();
 
     buf.reserve(200);
-    buf.put("aa");
+    buf.put_slice(b"aa");
     assert!(codec.decode(buf).is_err());
-    buf.put("a");
+    buf.put_slice(b"a");
     assert!(codec.decode(buf).is_err());
 }
 

tokio-util/tests/framed.rs

@@ -4,7 +4,7 @@ use tokio::prelude::*;
 use tokio_test::assert_ok;
 use tokio_util::codec::{Decoder, Encoder, Framed, FramedParts};
 
-use bytes::{Buf, BufMut, BytesMut, IntoBuf};
+use bytes::{Buf, BufMut, BytesMut};
 use futures::StreamExt;
 use std::io::{self, Read};
 use std::pin::Pin;
@@ -24,7 +24,7 @@ impl Decoder for U32Codec {
             return Ok(None);
         }
 
-        let n = buf.split_to(4).into_buf().get_u32_be();
+        let n = buf.split_to(4).get_u32();
         Ok(Some(n))
     }
 }
@@ -36,7 +36,7 @@ impl Encoder for U32Codec {
     fn encode(&mut self, item: u32, dst: &mut BytesMut) -> io::Result<()> {
         // Reserve space
         dst.reserve(4);
-        dst.put_u32_be(item);
+        dst.put_u32(item);
         Ok(())
     }
 }
@@ -66,7 +66,7 @@ impl AsyncRead for DontReadIntoThis {
 #[tokio::test]
 async fn can_read_from_existing_buf() {
     let mut parts = FramedParts::new(DontReadIntoThis, U32Codec);
-    parts.read_buf = vec![0, 0, 0, 42].into();
+    parts.read_buf = BytesMut::from(&[0, 0, 0, 42][..]);
 
     let mut framed = Framed::from_parts(parts);
     let num = assert_ok!(framed.next().await.unwrap());
@@ -77,7 +77,7 @@ async fn can_read_from_existing_buf() {
 #[test]
 fn external_buf_grows_to_init() {
     let mut parts = FramedParts::new(DontReadIntoThis, U32Codec);
-    parts.read_buf = vec![0, 0, 0, 42].into();
+    parts.read_buf = BytesMut::from(&[0, 0, 0, 42][..]);
 
     let framed = Framed::from_parts(parts);
     let FramedParts { read_buf, .. } = framed.into_parts();
@@ -88,7 +88,7 @@ fn external_buf_grows_to_init() {
 #[test]
 fn external_buf_does_not_shrink() {
     let mut parts = FramedParts::new(DontReadIntoThis, U32Codec);
-    parts.read_buf = vec![0; INITIAL_CAPACITY * 2].into();
+    parts.read_buf = BytesMut::from(&vec![0; INITIAL_CAPACITY * 2][..]);
 
     let framed = Framed::from_parts(parts);
     let FramedParts { read_buf, .. } = framed.into_parts();

tokio-util/tests/framed_read.rs

@@ -5,7 +5,7 @@ use tokio_test::assert_ready;
 use tokio_test::task;
 use tokio_util::codec::{Decoder, FramedRead};
 
-use bytes::{Buf, BytesMut, IntoBuf};
+use bytes::{Buf, BytesMut};
 use futures::Stream;
 use std::collections::VecDeque;
 use std::io;
@@ -45,7 +45,7 @@ impl Decoder for U32Decoder {
             return Ok(None);
         }
 
-        let n = buf.split_to(4).into_buf().get_u32_be();
+        let n = buf.split_to(4).get_u32();
         Ok(Some(n))
     }
 }

tokio-util/tests/framed_write.rs

@@ -35,7 +35,7 @@ impl Encoder for U32Encoder {
     fn encode(&mut self, item: u32, dst: &mut BytesMut) -> io::Result<()> {
         // Reserve space
         dst.reserve(4);
-        dst.put_u32_be(item);
+        dst.put_u32(item);
         Ok(())
     }
 }
@@ -78,7 +78,7 @@ fn write_hits_backpressure() {
 
     for i in 0..=ITER {
         let mut b = BytesMut::with_capacity(4);
-        b.put_u32_be(i as u32);
+        b.put_u32(i as u32);
 
         // Append to the end
         match mock.calls.back_mut().unwrap() {

tokio-util/tests/udp.rs

@@ -73,7 +73,7 @@ impl Encoder for ByteCodec {
 
     fn encode(&mut self, data: Vec<u8>, buf: &mut BytesMut) -> Result<(), io::Error> {
         buf.reserve(data.len());
-        buf.put(data);
+        buf.put_slice(&data);
         Ok(())
     }
 }