Fix test fallout during merge

Cargo.toml

@@ -15,4 +15,6 @@ rustc-serialize = "0.3.*"
 byteorder = "0.3.*"
 num = "*"
 serde = "*"
+
+[dev-dependencies]
 serde_macros = "*"

src/reader_serde.rs

@@ -539,11 +539,11 @@ pub fn from_reader<R, T>(reader: &mut R, size_limit: SizeLimit) -> DeserializeRe
     serde::Deserialize::deserialize(&mut deserializer)
 }
 
-pub fn from_slice<T>(bytes: &[u8], size_limit: SizeLimit) -> DeserializeResult<T>
+pub fn from_slice<T>(bytes: &[u8]) -> DeserializeResult<T>
     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] = [

src/refbox.rs

@@ -140,6 +140,7 @@ impl <T> RefBox<'static, T>  {
     }
 }
 
+
 impl <'a, T: Encodable> Encodable for RefBox<'a, T> {
     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
         self.inner.encode(s)

tests/test_serde.rs

@@ -27,11 +27,11 @@ use bincode::{
 
 use bincode::SizeLimit::{self, Infinite, Bounded};
 
-fn proxy_encode<V>(element: V, size_limit: SizeLimit) -> Vec<u8>
+fn proxy_encode<V>(element: &V, size_limit: SizeLimit) -> Vec<u8>
     where V: Encodable + Decodable + serde::Serialize + serde::Deserialize + PartialEq + Debug + 'static
 {
-    let v1 = bincode::encode(&element, size_limit);
+    let v1 = bincode::encode(element, size_limit).unwrap();
-    let v2 = bincode::to_vec(&element, size_limit);
+    let v2 = bincode::to_vec(element, size_limit).unwrap();
     assert_eq!(v1, v2);
 
     v1
@@ -40,21 +40,21 @@ fn proxy_encode<V>(element: V, size_limit: SizeLimit) -> Vec<u8>
 fn proxy_decode<V>(slice: &[u8]) -> V
     where V: Encodable + Decodable + serde::Serialize + serde::Deserialize + PartialEq + Debug + 'static
 {
-    let e1 = bincode::decode(slice);
+    let e1 = bincode::decode(slice).unwrap();
-    let e2 = bincode::from_slice(slice);
+    let e2 = bincode::from_slice(slice).unwrap();
 
     assert_eq!(e1, e2);
 
     e1
 }
 
-fn proxy_encoded_size<V>(element: V, size_limit: SizeLimit) -> usize
+fn proxy_encoded_size<V>(element: &V) -> u64
     where V: Encodable+Decodable+serde::Serialize+serde::Deserialize+PartialEq+Debug+'static
 {
-    let ser_size = bincode::encoded_size(obj);
+    let ser_size = bincode::encoded_size(element);
-    let serde_size = bincode::serialized_size(obj);
+    let serde_size = bincode::serialized_size(element);
     assert_eq!(ser_size, serde_size);
-    ser_size;
+    ser_size
 }
 
 fn the_same<V>(element: V)
@@ -65,17 +65,16 @@ fn the_same<V>(element: V)
         where V: Encodable + Decodable + PartialEq + Debug + 'static
     {
         let rf = RefBox::new(v);
-
+        let encoded = encode(&rf, Infinite).unwrap();
-        let encoded = proxy_encode(&rf, Infinite).unwrap();
+        let decoded: RefBox<'static, V> = decode(&encoded[..]).unwrap();
-        let decoded: RefBox<'static, V> = proxy_decode(&encoded[..]).unwrap();
 
         decoded.take().deref() == v
     }
 
     let size = proxy_encoded_size(&element);
 
-    let encoded = proxy_encode(&element, Infinite).unwrap();
+    let encoded = proxy_encode(&element, Infinite);
-    let decoded = proxy_decode(&encoded[..]).unwrap();
+    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::<bool>(&vec![0xA][..], Infinite));
+    isize_invalid_deserialize(bincode::from_slice::<bool>(&vec![0xA][..]));
-    isize_invalid_deserialize(bincode::from_slice::<String>(&vec![0, 0, 0, 0, 0, 0, 0, 1, 0xFF][..], Infinite));
+    isize_invalid_deserialize(bincode::from_slice::<String>(&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::<Test>(&vec![0, 0, 0, 5][..], Infinite));
+    isize_invalid_deserialize(bincode::from_slice::<Test>(&vec![0, 0, 0, 5][..]));
-    isize_invalid_deserialize(bincode::from_slice::<Option<u8>>(&vec![5, 0][..], Infinite));
+    isize_invalid_deserialize(bincode::from_slice::<Option<u8>>(&vec![5, 0][..]));
 }
 
 #[test]
 fn too_big_decode() {
     let encoded = vec![0,0,0,3];
-    let mut encoded_ref = &encoded[..];
+    let decoded: Result<u32, _> = decode_from(&mut &encoded[..], Bounded(3));
-    let decoded: Result<u32, _> = decode_from(&mut encoded_ref, Bounded(3));
     assert!(decoded.is_err());
 
     let encoded = vec![0,0,0,3];
-    let mut encoded_ref = &encoded[..];
+    let decoded: Result<u32, _> = decode_from(&mut &encoded[..], Bounded(4));
-    let decoded: Result<u32, _> = decode_from(&mut encoded_ref, Bounded(4));
     assert!(decoded.is_ok());
 }
 
 #[test]
 fn too_big_deserialize() {
     let serialized = vec![0,0,0,3];
-    let deserialized: Result<u32, _> = bincode::from_slice(&serialized[..], Bounded(3));
+    let deserialized: Result<u32, _> = bincode::from_reader(&mut &serialized[..], Bounded(3));
     assert!(deserialized.is_err());
 
     let serialized = vec![0,0,0,3];
-    let deserialized: Result<u32, _> = bincode::from_slice(&serialized[..], Bounded(4));
+    let deserialized: Result<u32, _> = 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<char, _> = decode_from(&mut &encoded[..], Bounded(1));
-    let decoded: Result<char, _> = decode_from(&mut encoded_ref, 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<char, _> = bincode::from_slice(&serialized[..], Bounded(1));
+    let deserialized: Result<char, _> = 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);