From 3de218537f2d9ae65c0c6c90bf28b6a039d48f57 Mon Sep 17 00:00:00 2001 From: Ty Overby Date: Fri, 7 Aug 2015 16:16:42 -0700 Subject: [PATCH] Fix test fallout during merge --- Cargo.toml | 2 ++ src/reader_serde.rs | 10 +++---- src/refbox.rs | 3 ++- tests/test_serde.rs | 64 +++++++++++++++++++++------------------------ 4 files changed, 39 insertions(+), 40 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 89a7844..2374a3e 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -15,4 +15,6 @@ rustc-serialize = "0.3.*" byteorder = "0.3.*" num = "*" serde = "*" + +[dev-dependencies] serde_macros = "*" diff --git a/src/reader_serde.rs b/src/reader_serde.rs index d675a42..2406397 100644 --- a/src/reader_serde.rs +++ b/src/reader_serde.rs @@ -361,7 +361,7 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> { where V: serde::de::Visitor, { struct TupleVisitor<'a, 'b: 'a, R: Read + 'b>(&'a mut Deserializer<'b, R>); - + impl<'a, 'b: 'a, R: Read + 'b> serde::de::SeqVisitor for TupleVisitor<'a, 'b, R> { type Error = DeserializeError; @@ -401,7 +401,7 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> { deserializer: &'a mut Deserializer<'b, R>, len: usize, } - + impl<'a, 'b: 'a, R: Read + 'b> serde::de::SeqVisitor for SeqVisitor<'a, 'b, R> { type Error = DeserializeError; @@ -438,7 +438,7 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> { deserializer: &'a mut Deserializer<'b, R>, len: usize, } - + impl<'a, 'b: 'a, R: Read + 'b> serde::de::MapVisitor for MapVisitor<'a, 'b, R> { type Error = DeserializeError; @@ -539,11 +539,11 @@ pub fn from_reader(reader: &mut R, size_limit: SizeLimit) -> DeserializeRe serde::Deserialize::deserialize(&mut deserializer) } -pub fn from_slice(bytes: &[u8], size_limit: SizeLimit) -> DeserializeResult +pub fn from_slice(bytes: &[u8]) -> DeserializeResult where T: serde::Deserialize, { let mut reader = bytes; - from_reader(&mut reader, size_limit) + from_reader(&mut reader, SizeLimit::Infinite) } static UTF8_CHAR_WIDTH: [u8; 256] = [ diff --git a/src/refbox.rs b/src/refbox.rs index 5bcf6cf..503d607 100644 --- a/src/refbox.rs +++ b/src/refbox.rs @@ -140,6 +140,7 @@ impl RefBox<'static, T> { } } + impl <'a, T: Encodable> Encodable for RefBox<'a, T> { fn encode(&self, s: &mut S) -> Result<(), S::Error> { self.inner.encode(s) @@ -362,7 +363,7 @@ impl <'a, A: Encodable + ?Sized, B: Encodable> Encodable for RefBoxInner<'a, A, } } -impl<'a, A: ?Sized, B> serde::Serialize for RefBoxInner<'a, A, B> +impl<'a, A: ?Sized, B> serde::Serialize for RefBoxInner<'a, A, B> where A: serde::Serialize, B: serde::Serialize, { diff --git a/tests/test_serde.rs b/tests/test_serde.rs index a6576a5..970ce23 100644 --- a/tests/test_serde.rs +++ b/tests/test_serde.rs @@ -27,34 +27,34 @@ use bincode::{ use bincode::SizeLimit::{self, Infinite, Bounded}; -fn proxy_encode(element: V, size_limit: SizeLimit) -> Vec - where V: Encodable+Decodable+serde::Serialize+serde::Deserialize+PartialEq+Debug+'static +fn proxy_encode(element: &V, size_limit: SizeLimit) -> Vec + where V: Encodable + Decodable + serde::Serialize + serde::Deserialize + PartialEq + Debug + 'static { - let v1 = bincode::encode(&element, size_limit); - let v2 = bincode::to_vec(&element, size_limit); + let v1 = bincode::encode(element, size_limit).unwrap(); + let v2 = bincode::to_vec(element, size_limit).unwrap(); assert_eq!(v1, v2); v1 } fn proxy_decode(slice: &[u8]) -> V - where V: Encodable+Decodable+serde::Serialize+serde::Deserialize+PartialEq+Debug+'static + where V: Encodable + Decodable + serde::Serialize + serde::Deserialize + PartialEq + Debug + 'static { - let e1 = bincode::decode(slice); - let e2 = bincode::from_slice(slice); + let e1 = bincode::decode(slice).unwrap(); + let e2 = bincode::from_slice(slice).unwrap(); assert_eq!(e1, e2); e1 } -fn proxy_encoded_size(element: V, size_limit: SizeLimit) -> usize +fn proxy_encoded_size(element: &V) -> u64 where V: Encodable+Decodable+serde::Serialize+serde::Deserialize+PartialEq+Debug+'static { - let ser_size = bincode::encoded_size(obj); - let serde_size = bincode::serialized_size(obj); + let ser_size = bincode::encoded_size(element); + let serde_size = bincode::serialized_size(element); assert_eq!(ser_size, serde_size); - ser_size; + ser_size } fn the_same(element: V) @@ -62,20 +62,19 @@ fn the_same(element: V) { // Make sure that the bahavior isize correct when wrapping with a RefBox. fn ref_box_correct(v: &V) -> bool - where V: Encodable+Decodable+PartialEq+Debug+'static + where V: Encodable + Decodable + PartialEq + Debug + 'static { let rf = RefBox::new(v); - - let encoded = proxy_encode(&rf, Infinite).unwrap(); - let decoded: RefBox<'static, V> = proxy_decode(&encoded[..]).unwrap(); + let encoded = encode(&rf, Infinite).unwrap(); + let decoded: RefBox<'static, V> = decode(&encoded[..]).unwrap(); decoded.take().deref() == v } let size = proxy_encoded_size(&element); - let encoded = proxy_encode(&element, Infinite).unwrap(); - let decoded = proxy_decode(&encoded[..]).unwrap(); + let encoded = proxy_encode(&element, Infinite); + let decoded = proxy_decode(&encoded[..]); assert_eq!(element, decoded); assert_eq!(size, encoded.len() as u64); @@ -259,47 +258,44 @@ fn deserializing_errors() { } } - isize_invalid_deserialize(bincode::from_slice::(&vec![0xA][..], Infinite)); - isize_invalid_deserialize(bincode::from_slice::(&vec![0, 0, 0, 0, 0, 0, 0, 1, 0xFF][..], Infinite)); + isize_invalid_deserialize(bincode::from_slice::(&vec![0xA][..])); + isize_invalid_deserialize(bincode::from_slice::(&vec![0, 0, 0, 0, 0, 0, 0, 1, 0xFF][..])); // Out-of-bounds variant #[derive(RustcEncodable, RustcDecodable, Serialize, Deserialize, Debug)] enum Test { One, Two, }; - isize_invalid_deserialize(bincode::from_slice::(&vec![0, 0, 0, 5][..], Infinite)); - isize_invalid_deserialize(bincode::from_slice::>(&vec![5, 0][..], Infinite)); + isize_invalid_deserialize(bincode::from_slice::(&vec![0, 0, 0, 5][..])); + isize_invalid_deserialize(bincode::from_slice::>(&vec![5, 0][..])); } #[test] fn too_big_decode() { let encoded = vec![0,0,0,3]; - let mut encoded_ref = &encoded[..]; - let decoded: Result = decode_from(&mut encoded_ref, Bounded(3)); + let decoded: Result = decode_from(&mut &encoded[..], Bounded(3)); assert!(decoded.is_err()); let encoded = vec![0,0,0,3]; - let mut encoded_ref = &encoded[..]; - let decoded: Result = decode_from(&mut encoded_ref, Bounded(4)); + let decoded: Result = decode_from(&mut &encoded[..], Bounded(4)); assert!(decoded.is_ok()); } #[test] fn too_big_deserialize() { let serialized = vec![0,0,0,3]; - let deserialized: Result = bincode::from_slice(&serialized[..], Bounded(3)); + let deserialized: Result = bincode::from_reader(&mut &serialized[..], Bounded(3)); assert!(deserialized.is_err()); let serialized = vec![0,0,0,3]; - let deserialized: Result = bincode::from_slice(&serialized[..], Bounded(4)); + let deserialized: Result = bincode::from_reader(&mut &serialized[..], Bounded(4)); assert!(deserialized.is_ok()); } #[test] fn too_big_char_decode() { let encoded = vec![0x41]; - let mut encoded_ref = &encoded[..]; - let decoded: Result = decode_from(&mut encoded_ref, Bounded(1)); + let decoded: Result = decode_from(&mut &encoded[..], Bounded(1)); assert!(decoded.is_ok()); assert_eq!(decoded.unwrap(), 'A'); } @@ -307,7 +303,7 @@ fn too_big_char_decode() { #[test] fn too_big_char_deserialize() { let serialized = vec![0x41]; - let deserialized: Result = bincode::from_slice(&serialized[..], Bounded(1)); + let deserialized: Result = bincode::from_reader(&mut &serialized[..], Bounded(1)); assert!(deserialized.is_ok()); assert_eq!(deserialized.unwrap(), 'A'); } @@ -416,7 +412,7 @@ fn test_refbox_serialize() { // Test 1 { let serialized = bincode::to_vec(&Message::M1(RefBox::new(&large_object)), Infinite).unwrap(); - let deserialized: Message<'static> = bincode::from_slice(&serialized[..], Infinite).unwrap(); + let deserialized: Message<'static> = bincode::from_reader(&mut &serialized[..], Infinite).unwrap(); match deserialized { Message::M1(b) => assert!(b.take().deref() == &large_object), @@ -427,7 +423,7 @@ fn test_refbox_serialize() { // Test 2 { let serialized = bincode::to_vec(&Message::M2(RefBox::new(&large_map)), Infinite).unwrap(); - let deserialized: Message<'static> = bincode::from_slice(&serialized[..], Infinite).unwrap(); + let deserialized: Message<'static> = bincode::from_reader(&mut &serialized[..], Infinite).unwrap(); match deserialized { Message::M2(b) => assert!(b.take().deref() == &large_map), @@ -449,7 +445,7 @@ fn test_strbox_encode() { fn test_strbox_serialize() { let strx: &'static str = "hello world"; let serialized = bincode::to_vec(&StrBox::new(strx), Infinite).unwrap(); - let deserialized: StrBox<'static> = bincode::from_slice(&serialized[..], Infinite).unwrap(); + let deserialized: StrBox<'static> = bincode::from_reader(&mut &serialized[..], Infinite).unwrap(); let stringx: String = deserialized.take(); assert!(strx == &stringx[..]); } @@ -471,7 +467,7 @@ fn test_slicebox_encode() { fn test_slicebox_serialize() { let slice = [1u32, 2, 3 ,4, 5]; let serialized = bincode::to_vec(&SliceBox::new(&slice), Infinite).unwrap(); - let deserialized: SliceBox<'static, u32> = bincode::from_slice(&serialized[..], Infinite).unwrap(); + let deserialized: SliceBox<'static, u32> = bincode::from_reader(&mut &serialized[..], Infinite).unwrap(); { let sb: &[u32] = &deserialized; assert!(slice == sb);