tokio-rs/bytes
1
0
Fork 0
mirror of https://github.com/tokio-rs/bytes.git synced 2026-08-15 00:00:18 +02:00
Code Issues Packages Projects Releases Wiki Activity

Freshen up buf API

Browse Source
This commit is contained in:
Carl Lerche
2016-06-08 14:48:49 -07:00
parent 12dfc417ce
commit 270d2e2844
16 changed files with 156 additions and 230 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/test_buf.rs
+3 -3
View File
@@ -1,4 +1,4 @@
use bytes::{Buf, MutBuf, MutBufExt};
use bytes::{Buf, MutBuf};
use std::usize;
use std::io::{Cursor};
@@ -35,7 +35,7 @@ pub fn test_vec_as_mut_buf() {
assert!(buf.mut_bytes().len() >= 64);
}
buf.write(&b"zomg"[..]).unwrap();
buf.copy_from(&b"zomg"[..]).unwrap();
assert_eq!(&buf, b"zomg");
@@ -43,7 +43,7 @@ pub fn test_vec_as_mut_buf() {
assert_eq!(buf.capacity(), 64);
for _ in 0..16 {
buf.write(&b"zomg"[..]).unwrap();
buf.copy_from(&b"zomg"[..]).unwrap();
}
assert_eq!(buf.len(), 68);
test/test_buf_fill.rs
+3 -3
View File
@@ -2,12 +2,12 @@ use bytes::*;
use std::io;
#[test]
pub fn test_filling_buf_from_reader() {
pub fn test_readijng_buf_from_reader() {
let mut reader = chunks(vec![b"foo", b"bar", b"baz"]);
let mut buf = ByteBuf::mut_with_capacity(1024);
assert_eq!(9, buf.write(&mut reader).unwrap());
assert_eq!(b"foobarbaz".to_bytes(), buf.flip().to_bytes());
assert_eq!(3, reader.read_buf(&mut buf).unwrap());
assert_eq!(b"foo".to_bytes(), buf.flip().to_bytes());
}
fn chunks(chunks: Vec<&'static [u8]>) -> Chunked {
test/test_buf_take.rs
+1 -1
View File
@@ -6,7 +6,7 @@ pub fn test_take_from_buf() {
let mut buf = Take::new(Cursor::new(b"hello world".to_vec()), 5);
let mut res = vec![];
buf.read_to_end(&mut res);
buf.read_to_end(&mut res).unwrap();
assert_eq!(&res, b"hello");
}
test/test_byte_buf.rs
+10 -10
View File
@@ -20,10 +20,10 @@ pub fn test_initial_buf_empty() {
#[test]
pub fn test_byte_buf_bytes() {
let mut buf = ByteBuf::mut_with_capacity(32);
buf.write(&b"hello "[..]).unwrap();
buf.copy_from(&b"hello "[..]).unwrap();
assert_eq!(&b"hello "[..], buf.bytes());
buf.write(&b"world"[..]).unwrap();
buf.copy_from(&b"world"[..]).unwrap();
assert_eq!(&b"hello world"[..], buf.bytes());
let buf = buf.flip();
assert_eq!(&b"hello world"[..], buf.bytes());
@@ -33,37 +33,37 @@ pub fn test_byte_buf_bytes() {
pub fn test_byte_buf_read_write() {
let mut buf = ByteBuf::mut_with_capacity(32);
buf.write(&b"hello world"[..]).unwrap();
buf.copy_from(&b"hello world"[..]).unwrap();
assert_eq!(21, buf.remaining());
buf.write(&b" goodbye"[..]).unwrap();
buf.copy_from(&b" goodbye"[..]).unwrap();
assert_eq!(13, buf.remaining());
let mut buf = buf.flip();
let mut dst = [0; 5];
buf.mark();
assert_eq!(5, buf.read(&mut dst[..]).unwrap());
assert_eq!(5, buf.copy_to(&mut dst[..]).unwrap());
assert_eq!(b"hello", &dst);
buf.reset();
assert_eq!(5, buf.read(&mut dst[..]).unwrap());
assert_eq!(5, buf.copy_to(&mut dst[..]).unwrap());
assert_eq!(b"hello", &dst);
assert_eq!(5, buf.read(&mut dst[..]).unwrap());
assert_eq!(5, buf.copy_to(&mut dst[..]).unwrap());
assert_eq!(b" worl", &dst);
let mut dst = [0; 2];
assert_eq!(2, buf.read(&mut dst[..]).unwrap());
assert_eq!(2, buf.copy_to(&mut dst[..]).unwrap());
assert_eq!(b"d ", &dst);
let mut dst = [0; 7];
assert_eq!(7, buf.read(&mut dst[..]).unwrap());
assert_eq!(7, buf.copy_to(&mut dst[..]).unwrap());
assert_eq!(b"goodbye", &dst);
let mut buf = buf.resume();
assert_eq!(13, buf.remaining());
buf.write(&b" have fun"[..]).unwrap();
buf.copy_from(&b" have fun"[..]).unwrap();
assert_eq!(4, buf.remaining());
let buf = buf.flip();
test/test_ring.rs
+24 -34
View File
@@ -1,18 +1,17 @@
use bytes::RingBuf;
use bytes::{RingBuf, Buf, MutBuf};
#[test]
pub fn test_initial_buf_empty() {
use bytes::traits::{Buf, BufExt, MutBuf, MutBufExt};
use bytes::traits::{Buf, MutBuf};
let mut buf = RingBuf::new(16);
assert_eq!(MutBuf::remaining(&buf), 16);
assert_eq!(Buf::remaining(&buf), 0);
let bytes_written = buf.write(&[1, 2, 3][..]).unwrap();
let bytes_written = buf.copy_from(&[1, 2, 3][..]).unwrap();
assert_eq!(bytes_written, 3);
let bytes_written = buf.write(&[][..]).unwrap();
let bytes_written = buf.copy_from(&[][..]).unwrap();
assert_eq!(bytes_written, 0);
assert_eq!(MutBuf::remaining(&buf), 13);
assert_eq!(Buf::remaining(&buf), 3);
@@ -21,11 +20,11 @@ pub fn test_initial_buf_empty() {
let mut out = [0u8; 3];
buf.mark();
let bytes_read = buf.read(&mut out[..]).unwrap();;
let bytes_read = buf.copy_to(&mut out[..]).unwrap();;
assert_eq!(bytes_read, 3);
assert_eq!(out, [1, 2, 3]);
buf.reset();
let bytes_read = buf.read(&mut out[..]).unwrap();;
let bytes_read = buf.copy_to(&mut out[..]).unwrap();;
assert_eq!(bytes_read, 3);
assert_eq!(out, [1, 2, 3]);
@@ -35,44 +34,41 @@ pub fn test_initial_buf_empty() {
#[test]
fn test_wrapping_write() {
use bytes::traits::{BufExt, MutBufExt};
let mut buf = RingBuf::new(16);
let mut out = [0;10];
buf.write(&[42;12][..]).unwrap();
let bytes_read = buf.read(&mut out[..]).unwrap();
buf.copy_from(&[42;12][..]).unwrap();
let bytes_read = buf.copy_to(&mut out[..]).unwrap();
assert_eq!(bytes_read, 10);
let bytes_written = buf.write(&[23;8][..]).unwrap();
let bytes_written = buf.copy_from(&[23;8][..]).unwrap();
assert_eq!(bytes_written, 8);
buf.mark();
let bytes_read = buf.read(&mut out[..]).unwrap();
let bytes_read = buf.copy_to(&mut out[..]).unwrap();
assert_eq!(bytes_read, 10);
assert_eq!(out, [42, 42, 23, 23, 23, 23, 23, 23, 23, 23]);
buf.reset();
let bytes_read = buf.read(&mut out[..]).unwrap();
let bytes_read = buf.copy_to(&mut out[..]).unwrap();
assert_eq!(bytes_read, 10);
assert_eq!(out, [42, 42, 23, 23, 23, 23, 23, 23, 23, 23]);
}
#[test]
fn test_io_write_and_read() {
use std::io::{Read, Write};
let mut buf = RingBuf::new(16);
let mut out = [0;8];
let mut out = [0u8;8];
let written = buf.write(&[1;8][..]).unwrap();
let written = buf.copy_from(&[1;8][..]).unwrap();
assert_eq!(written, 8);
buf.read(&mut out).unwrap();
buf.copy_to(&mut out[..]).unwrap();
assert_eq!(out, [1;8]);
let written = buf.write(&[2;8][..]).unwrap();
let written = buf.copy_from(&[2;8][..]).unwrap();
assert_eq!(written, 8);
let bytes_read = buf.read(&mut out).unwrap();
let bytes_read = buf.copy_to(&mut out[..]).unwrap();
assert_eq!(bytes_read, 8);
assert_eq!(out, [2;8]);
}
@@ -80,29 +76,25 @@ fn test_io_write_and_read() {
#[test]
#[should_panic]
fn test_wrap_reset() {
use std::io::{Read, Write};
let mut buf = RingBuf::new(8);
buf.write(&[1, 2, 3, 4, 5, 6, 7]).unwrap();
buf.copy_from(&[1, 2, 3, 4, 5, 6, 7][..]).unwrap();
buf.mark();
buf.read(&mut [0; 4]).unwrap();
buf.write(&[1, 2, 3, 4]).unwrap();
buf.copy_to(&mut [0; 4][..]).unwrap();
buf.copy_from(&[1, 2, 3, 4][..]).unwrap();
buf.reset();
}
#[test]
// Test that writes across a mark/reset are preserved.
fn test_mark_write() {
use std::io::{Read, Write};
let mut buf = RingBuf::new(8);
buf.write(&[1, 2, 3, 4, 5, 6, 7]).unwrap();
buf.copy_from(&[1, 2, 3, 4, 5, 6, 7][..]).unwrap();
buf.mark();
buf.write(&[8]).unwrap();
buf.copy_from(&[8][..]).unwrap();
buf.reset();
let mut buf2 = [0; 8];
buf.read(&mut buf2).unwrap();
buf.copy_to(&mut buf2[..]).unwrap();
assert_eq!(buf2, [1, 2, 3, 4, 5, 6, 7, 8]);
}
@@ -111,10 +103,9 @@ fn test_mark_write() {
// full buffer to zero.
fn test_reset_full() {
use bytes::traits::MutBuf;
use std::io::Write;
let mut buf = RingBuf::new(8);
buf.write(&[1, 2, 3, 4, 5, 6, 7, 8]).unwrap();
buf.copy_from(&[1, 2, 3, 4, 5, 6, 7, 8][..]).unwrap();
assert_eq!(MutBuf::remaining(&buf), 0);
buf.mark();
buf.reset();
@@ -126,10 +117,9 @@ fn test_reset_full() {
// Test that "RingBuf::clear" does the full reset
fn test_clear() {
use bytes::traits::{Buf, MutBuf};
use std::io::Write;
let mut buf = RingBuf::new(8);
buf.write(&[0; 8]).unwrap();
buf.copy_from(&[0; 8][..]).unwrap();
assert_eq!(MutBuf::remaining(&buf), 0);
assert_eq!(Buf::remaining(&buf), 8);
buf.clear();
test/test_rope.rs
+5 -5
View File
@@ -34,7 +34,7 @@ pub fn test_rope_round_trip() {
assert_eq!(4, rope.len());
let mut dst = vec![];
rope.buf().read(&mut dst).unwrap();
rope.buf().copy_to(&mut dst).unwrap();
assert_eq!(b"zomg", &dst[..]);
}
@@ -46,19 +46,19 @@ pub fn test_rope_slice() {
let bytes = Rope::from_slice(TEST_BYTES_1);
assert_eq!(TEST_BYTES_1.len(), bytes.len());
bytes.buf().read(&mut dst).unwrap();
bytes.buf().copy_to(&mut dst).unwrap();
assert_eq!(dst, TEST_BYTES_1);
let left = bytes.slice_to(250);
assert_eq!(250, left.len());
left.buf().read(&mut dst).unwrap();
left.buf().copy_to(&mut dst).unwrap();
assert_eq!(dst, &TEST_BYTES_1[..250]);
let right = bytes.slice_from(250);
assert_eq!(TEST_BYTES_1.len() - 250, right.len());
right.buf().read(&mut dst).unwrap();
right.buf().copy_to(&mut dst).unwrap();
assert_eq!(dst, &TEST_BYTES_1[250..]);
}
@@ -73,7 +73,7 @@ pub fn test_rope_concat_two_byte_str() {
assert_eq!(both.len(), TEST_BYTES_1.len() + TEST_BYTES_2.len());
both.buf().read(&mut dst).unwrap();
both.buf().copy_to(&mut dst).unwrap();
let mut expected = Vec::new();
expected.extend(TEST_BYTES_1.iter().cloned());
expected.extend(TEST_BYTES_2.iter().cloned());
test/test_seq_byte_str.rs
+1 -1
View File
@@ -10,7 +10,7 @@ pub fn test_slice_round_trip() {
let s = SeqByteStr::from_slice(&src);
assert_eq!(2000, s.len());
s.buf().read(&mut dst).unwrap();
s.buf().copy_to(&mut dst).unwrap();
assert_eq!(dst, src);
}
test/test_small_byte_str.rs
+1 -1
View File
@@ -10,7 +10,7 @@ pub fn test_slice_round_trip() {
let s = SmallByteStr::from_slice(&src).unwrap();
assert_eq!(3, s.len());
s.buf().read(&mut dst).unwrap();
s.buf().copy_to(&mut dst).unwrap();
assert_eq!(dst, src);
}