WIP - Implement abstractions for working with bytes

test/test.rs

@@ -0,0 +1,15 @@
+#![feature(core)]
+
+use rand::random;
+
+extern crate bytes;
+extern crate rand;
+
+mod test_byte_buf;
+mod test_rope;
+mod test_seq_byte_str;
+mod test_small_byte_str;
+
+fn gen_bytes(n: usize) -> Vec<u8> {
+    (0..n).map(|_| random()).collect()
+}

test/test_byte_buf.rs

@@ -0,0 +1,46 @@
+use bytes::ByteBuf;
+use bytes::traits::*;
+
+#[test]
+pub fn test_initial_buf_empty() {
+    let buf = ByteBuf::mut_with_capacity(100);
+
+    assert!(buf.capacity() == 128);
+    assert!(buf.remaining() == 128);
+
+    let buf = buf.flip();
+
+    assert!(buf.remaining() == 0);
+
+    let buf = buf.flip();
+
+    assert!(buf.remaining() == 128);
+}
+
+#[test]
+pub fn test_byte_buf_read_write() {
+    let mut buf = ByteBuf::mut_with_capacity(32);
+
+    buf.write(b"hello world").unwrap();
+    assert_eq!(21, buf.remaining());
+
+    buf.write(b" goodbye").unwrap();
+    assert_eq!(13, buf.remaining());
+
+    let mut buf = buf.flip();
+    let mut dst = [0; 5];
+
+    assert_eq!(5, buf.read(dst.as_mut_slice()).unwrap());
+    assert_eq!(b"hello", dst);
+
+    assert_eq!(5, buf.read(dst.as_mut_slice()).unwrap());
+    assert_eq!(b" worl", dst);
+
+    let mut dst = [0; 2];
+    assert_eq!(2, buf.read(dst.as_mut_slice()).unwrap());
+    assert_eq!(b"d ", dst);
+
+    let mut dst = [0; 7];
+    assert_eq!(7, buf.read(dst.as_mut_slice()).unwrap());
+    assert_eq!(b"goodbye", dst);
+}

test/test_rope.rs

@@ -0,0 +1,90 @@
+use bytes::Rope;
+use bytes::traits::*;
+use super::gen_bytes;
+
+const TEST_BYTES_1: &'static [u8] =
+    &b"dblm4ng7jp4v9rdn1w6hhssmluoqrrrqj59rccl9
+       nkv2tm1t2da4jyku51ge7f8hv581gkki8lekmf5f
+       1l44whp4aiwbvhkziw02292on4noyvuwjzsloqyc
+       5n0iyn4l6o6tgjhlek00mynfzb1wgcwj4mqp6zdr
+       3625yy7rj7xuisal7b1a7xgq271abvt5ssxuj39v
+       njtetokxxrgxzp7ik9adnypkmmcn4270yv9l46m7
+       9mu2zmqmkxdmgia210vkdytb7ywfcyt2bvcsg9eq
+       5yqizxl6888zrksvaxhzs2v355jxu8gr21m33t83
+       qvoian1ra7c6pvxabshgngldxa408p18l1fdet2h";
+
+const TEST_BYTES_2: &'static [u8] =
+    &b"jmh14t79mllzj1ohxfj6fun7idwbks8oh35f83g6
+       ryaowe86mmou5t1xa91uyg8e95wcu5mje1mswien
+       tt4clgj029cw0pyuvfbvsgzdg1x7sr9qsjkf2b1t
+       h43smgp1ea22lph17f78cel0cc2kjoht5281xuy8
+       0ex9uaqwj4330jrp30stsk15j9bpqezu3w78ktit
+       ev5g6xsngr35q7pemdm9hihf0ebrw5fbwhm530lo
+       e0zyj1bm7yfyk7f2i45jhr3wu3bvb4hj8jve6db0
+       iewmr9weecaon9vdnqo5hen9iaiox5vsaxuo461m
+       8336ugp20u4sfky3kfawr0ome1tiqyx8chkerrjh
+       a95s0gypcsgo9jqxasqkoj08t4uq5moxmay5plg5
+       tlh6f9omhn0ezvi0w2n8hx7n6qk7rn1s3mjpnpl6
+       hvilp8awaa4tvsis66q4e5b3xwy2z1h2klpa87h7";
+
+#[test]
+pub fn test_rope_round_trip() {
+    let rope = Rope::from_slice(b"zomg");
+
+    assert_eq!(4, rope.len());
+
+    let mut dst = vec![];
+    rope.buf().read(&mut dst).unwrap();
+
+    assert_eq!(b"zomg", dst.as_slice());
+}
+
+#[test]
+pub fn test_rope_slice() {
+    let mut dst = vec![];
+
+    let bytes = Rope::from_slice(TEST_BYTES_1);
+    assert_eq!(TEST_BYTES_1.len(), bytes.len());
+
+    bytes.buf().read(&mut dst).unwrap();
+    assert_eq!(dst.as_slice(), TEST_BYTES_1);
+
+    let left = bytes.slice_to(250);
+    assert_eq!(250, left.len());
+
+    left.buf().read(&mut dst).unwrap();
+    assert_eq!(dst.as_slice(), &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();
+    assert_eq!(dst.as_slice(), &TEST_BYTES_1[250..]);
+}
+
+#[test]
+pub fn test_rope_concat_two_byte_str() {
+    let mut dst = vec![];
+
+    let left = Rope::from_slice(TEST_BYTES_1);
+    let right = Rope::from_slice(TEST_BYTES_2);
+
+    let both = left.concat(right);
+
+    assert_eq!(both.len(), TEST_BYTES_1.len() + TEST_BYTES_2.len());
+
+    both.buf().read(&mut dst).unwrap();
+    assert_eq!(dst.as_slice(), TEST_BYTES_1.to_vec() + TEST_BYTES_2);
+}
+
+#[test]
+#[ignore]
+pub fn test_slice_parity() {
+    let bytes = gen_bytes(2048 * 1024);
+    let start = 512 * 1024 - 3333;
+    let end = 512 * 1024 + 7777;
+
+    let _ = Rope::from_slice(bytes.as_slice()).slice(start, end);
+
+    // stuff
+}

test/test_seq_byte_str.rs

@@ -0,0 +1,33 @@
+use bytes::SeqByteStr;
+use bytes::traits::*;
+use super::gen_bytes;
+
+#[test]
+pub fn test_slice_round_trip() {
+    let mut dst = vec![];
+    let src = gen_bytes(2000);
+
+    let s = SeqByteStr::from_slice(src.as_slice());
+    assert_eq!(2000, s.len());
+
+    s.buf().read(&mut dst).unwrap();
+    assert_eq!(dst, src);
+}
+
+#[test]
+pub fn test_index() {
+    let src = gen_bytes(2000);
+
+    let s = SeqByteStr::from_slice(src.as_slice());
+
+    for i in 0..2000 {
+        assert_eq!(src[i], s[i]);
+    }
+}
+
+#[test]
+#[should_fail]
+pub fn test_index_out_of_range() {
+    let s = SeqByteStr::from_slice(gen_bytes(2000).as_slice());
+    let _ = s[2001];
+}

test/test_small_byte_str.rs

@@ -0,0 +1,33 @@
+use bytes::SmallByteStr;
+use bytes::traits::*;
+use super::gen_bytes;
+
+#[test]
+pub fn test_slice_round_trip() {
+    let mut dst = vec![];
+    let src = gen_bytes(3);
+
+    let s = SmallByteStr::from_slice(src.as_slice()).unwrap();
+    assert_eq!(3, s.len());
+
+    s.buf().read(&mut dst).unwrap();
+    assert_eq!(dst, src);
+}
+
+#[test]
+pub fn test_index() {
+    let src = gen_bytes(3);
+
+    let s = SmallByteStr::from_slice(src.as_slice()).unwrap();
+
+    for i in 0..3 {
+        assert_eq!(src[i], s[i]);
+    }
+}
+
+#[test]
+#[should_fail]
+pub fn test_index_out_of_range() {
+    let s = SmallByteStr::from_slice(gen_bytes(3).as_slice()).unwrap();
+    let _ = s[2001];
+}