diff --git a/src/lib.rs b/src/lib.rs index 49cc137..cb28e69 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -28,7 +28,6 @@ #![crate_type = "dylib"] #![doc(html_logo_url = "./icon.png")] -//`#![feature(unicode)] extern crate rustc_serialize; extern crate byteorder; diff --git a/src/writer_serde.rs b/src/writer_serde.rs index bfccddf..0fe44fb 100644 --- a/src/writer_serde.rs +++ b/src/writer_serde.rs @@ -462,149 +462,6 @@ impl serde::Serializer for SizeChecker { Ok(()) } - - - - - /* - type Error = SerializeError; - - fn emit_nil(&mut self) -> SerializeResult<()> { Ok(()) } - fn emit_usize(&mut self, v: usize) -> SerializeResult<()> { - self.add_value(v as u64) - } - fn emit_u64(&mut self, v: u64) -> SerializeResult<()> { - self.add_value(v) - } - fn emit_u32(&mut self, v: u32) -> SerializeResult<()> { - self.add_value(v) - } - fn emit_u16(&mut self, v: u16) -> SerializeResult<()> { - self.add_value(v) - } - fn emit_u8(&mut self, v: u8) -> SerializeResult<()> { - self.add_value(v) - } - fn emit_isize(&mut self, v: isize) -> SerializeResult<()> { - self.add_value(v as i64) - } - fn emit_i64(&mut self, v: i64) -> SerializeResult<()> { - self.add_value(v) - } - fn emit_i32(&mut self, v: i32) -> SerializeResult<()> { - self.add_value(v) - } - fn emit_i16(&mut self, v: i16) -> SerializeResult<()> { - self.add_value(v) - } - fn emit_i8(&mut self, v: i8) -> SerializeResult<()> { - self.add_value(v) - } - fn emit_bool(&mut self, _: bool) -> SerializeResult<()> { - self.add_value(0 as u8) - } - fn emit_f64(&mut self, v: f64) -> SerializeResult<()> { - self.add_value(v) - } - fn emit_f32(&mut self, v: f32) -> SerializeResult<()> { - self.add_value(v) - } - fn emit_char(&mut self, v: char) -> SerializeResult<()> { - self.add_raw(v.len_utf8()) - } - fn emit_str(&mut self, v: &str) -> SerializeResult<()> { - try!(self.add_value(0 as u64)); - self.add_raw(v.len()) - } - fn emit_enum(&mut self, __: &str, f: F) -> SerializeResult<()> where - F: FnOnce(&mut SizeChecker) -> SerializeResult<()> { - f(self) - } - fn emit_enum_variant(&mut self, _: &str, - v_id: usize, - _: usize, - f: F) -> SerializeResult<()> where - F: FnOnce(&mut SizeChecker) -> SerializeResult<()> { - try!(self.add_value(v_id as u32)); - f(self) - } - fn emit_enum_variant_arg(&mut self, _: usize, f: F) -> SerializeResult<()> where - F: FnOnce(&mut SizeChecker) -> SerializeResult<()> { - f(self) - } - fn emit_enum_struct_variant(&mut self, _: &str, - _: usize, - _: usize, - f: F) -> SerializeResult<()> where - F: FnOnce(&mut SizeChecker) -> SerializeResult<()> { - f(self) - } - fn emit_enum_struct_variant_field(&mut self, - _: &str, - _: usize, - f: F) -> SerializeResult<()> where - F: FnOnce(&mut SizeChecker) -> SerializeResult<()> { - f(self) - } - fn emit_struct(&mut self, _: &str, _: usize, f: F) -> SerializeResult<()> where - F: FnOnce(&mut SizeChecker) -> SerializeResult<()> { - f(self) - } - fn emit_struct_field(&mut self, _: &str, _: usize, f: F) -> SerializeResult<()> where - F: FnOnce(&mut SizeChecker) -> SerializeResult<()> { - f(self) - } - fn emit_tuple(&mut self, _: usize, f: F) -> SerializeResult<()> where - F: FnOnce(&mut SizeChecker) -> SerializeResult<()> { - f(self) - } - fn emit_tuple_arg(&mut self, _: usize, f: F) -> SerializeResult<()> where - F: FnOnce(&mut SizeChecker) -> SerializeResult<()> { - f(self) - } - fn emit_tuple_struct(&mut self, _: &str, len: usize, f: F) -> SerializeResult<()> where - F: FnOnce(&mut SizeChecker) -> SerializeResult<()> { - self.emit_tuple(len, f) - } - fn emit_tuple_struct_arg(&mut self, f_idx: usize, f: F) -> SerializeResult<()> where - F: FnOnce(&mut SizeChecker) -> SerializeResult<()> { - self.emit_tuple_arg(f_idx, f) - } - fn emit_option(&mut self, f: F) -> SerializeResult<()> where - F: FnOnce(&mut SizeChecker) -> SerializeResult<()> { - f(self) - } - fn emit_option_none(&mut self) -> SerializeResult<()> { - self.add_value(0 as u8) - } - fn emit_option_some(&mut self, f: F) -> SerializeResult<()> where - F: FnOnce(&mut SizeChecker) -> SerializeResult<()> { - try!(self.add_value(1 as u8)); - f(self) - } - fn emit_seq(&mut self, len: usize, f: F) -> SerializeResult<()> where - F: FnOnce(&mut SizeChecker) -> SerializeResult<()> { - try!(self.emit_usize(len)); - f(self) - } - fn emit_seq_elt(&mut self, _: usize, f: F) -> SerializeResult<()> where - F: FnOnce(&mut SizeChecker) -> SerializeResult<()> { - f(self) - } - fn emit_map(&mut self, len: usize, f: F) -> SerializeResult<()> where - F: FnOnce(&mut SizeChecker) -> SerializeResult<()> { - try!(self.emit_usize(len)); - f(self) - } - fn emit_map_elt_key(&mut self, _: usize, f: F) -> SerializeResult<()> where - F: FnOnce(&mut SizeChecker) -> SerializeResult<()> { - f(self) - } - fn emit_map_elt_val(&mut self, _: usize, f: F) -> SerializeResult<()> where - F: FnOnce(&mut SizeChecker) -> SerializeResult<()> { - f(self) - } - */ } pub fn to_writer(writer: &mut W, diff --git a/tests/test.rs b/tests/test.rs index e6ebd19..970ce23 100644 --- a/tests/test.rs +++ b/tests/test.rs @@ -1,6 +1,9 @@ -/* +#![feature(plugin, custom_derive)] +#![plugin(serde_macros)] + extern crate bincode; extern crate rustc_serialize; +extern crate serde; use std::fmt::Debug; use std::collections::HashMap; @@ -15,35 +18,67 @@ use bincode::{ encoded_size, DecodingError, DecodingResult, + DeserializeError, + DeserializeResult, RefBox, StrBox, SliceBox, }; -use bincode::SizeLimit::{Infinite, Bounded}; +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 +{ + 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 +{ + let e1 = bincode::decode(slice).unwrap(); + let e2 = bincode::from_slice(slice).unwrap(); + + assert_eq!(e1, e2); + + e1 +} + +fn proxy_encoded_size(element: &V) -> u64 + where V: Encodable+Decodable+serde::Serialize+serde::Deserialize+PartialEq+Debug+'static +{ + let ser_size = bincode::encoded_size(element); + let serde_size = bincode::serialized_size(element); + assert_eq!(ser_size, serde_size); + ser_size +} fn the_same(element: V) - where V: Encodable+Decodable+PartialEq+Debug+'static + where V: Encodable+Decodable+serde::Serialize+serde::Deserialize+PartialEq+Debug+'static { - // 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 = encode(&rf, Infinite).unwrap(); let decoded: RefBox<'static, V> = decode(&encoded[..]).unwrap(); decoded.take().deref() == v } - let size = encoded_size(&element); - let encoded = encode(&element, Infinite).unwrap(); - let decoded = decode(&encoded[..]).unwrap(); + let size = proxy_encoded_size(&element); + + let encoded = proxy_encode(&element, Infinite); + let decoded = proxy_decode(&encoded[..]); + assert_eq!(element, decoded); assert_eq!(size, encoded.len() as u64); - assert!(ref_box_correct(&element)) + assert!(ref_box_correct(&element)); } #[test] @@ -53,16 +88,19 @@ fn test_numbers() { the_same(5u16); the_same(5u32); the_same(5u64); + the_same(5usize); // signed positive the_same(5i8); the_same(5i16); the_same(5i32); the_same(5i64); + the_same(5isize); // signed negative the_same(-5i8); the_same(-5i16); the_same(-5i32); the_same(-5i64); + the_same(-5isize); // floating the_same(-100f32); the_same(0f32); @@ -86,7 +124,7 @@ fn test_tuple() { #[test] fn test_basic_struct() { - #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)] + #[derive(RustcEncodable, RustcDecodable, Serialize, Deserialize, PartialEq, Debug)] struct Easy { x: isize, s: String, @@ -97,13 +135,13 @@ fn test_basic_struct() { #[test] fn test_nested_struct() { - #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)] + #[derive(RustcEncodable, RustcDecodable, Serialize, Deserialize, PartialEq, Debug)] struct Easy { x: isize, s: String, y: usize } - #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)] + #[derive(RustcEncodable, RustcDecodable, Serialize, Deserialize, PartialEq, Debug)] struct Nest { f: Easy, b: usize, @@ -117,46 +155,42 @@ fn test_nested_struct() { }); } +#[test] +fn test_struct_newtype() { + #[derive(RustcEncodable, RustcDecodable, Serialize, Deserialize, PartialEq, Debug)] + struct NewtypeStr(usize); + + the_same(NewtypeStr(5)); +} + #[test] fn test_struct_tuple() { - #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)] + #[derive(RustcEncodable, RustcDecodable, Serialize, Deserialize, PartialEq, Debug)] struct TubStr(usize, String, f32); the_same(TubStr(5, "hello".to_string(), 3.2)); } #[test] -fn option() { +fn test_option() { the_same(Some(5usize)); the_same(Some("foo bar".to_string())); the_same(None::); } #[test] -fn enm() { - #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)] - enum TestEnum { - NoArg, - OneArg(usize), - AnotherNoArg - } - the_same(TestEnum::NoArg); - the_same(TestEnum::OneArg(4)); - the_same(TestEnum::AnotherNoArg); -} - - -#[test] -fn struct_enum() { - #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)] +fn test_enum() { + #[derive(RustcEncodable, RustcDecodable, Serialize, Deserialize, PartialEq, Debug)] enum TestEnum { NoArg, OneArg(usize), + Args(usize, usize), AnotherNoArg, StructLike{x: usize, y: f32} } the_same(TestEnum::NoArg); the_same(TestEnum::OneArg(4)); + the_same(TestEnum::Args(4, 5)); the_same(TestEnum::AnotherNoArg); the_same(TestEnum::StructLike{x: 4, y: 3.14159}); the_same(vec![TestEnum::NoArg, TestEnum::OneArg(5), TestEnum::AnotherNoArg, @@ -164,7 +198,7 @@ fn struct_enum() { } #[test] -fn many() { +fn test_vec() { let v: Vec = vec![]; the_same(v); the_same(vec![1u64]); @@ -172,7 +206,7 @@ fn many() { } #[test] -fn map() { +fn test_map() { let mut m = HashMap::new(); m.insert(4u64, "foo".to_string()); m.insert(0u64, "bar".to_string()); @@ -180,18 +214,17 @@ fn map() { } #[test] -fn boole() { +fn test_bool() { the_same(true); the_same(false); } #[test] -fn unicode() { +fn test_unicode() { the_same("å".to_string()); the_same("aåååååååa".to_string()); } - #[test] fn decoding_errors() { fn isize_invalid_encoding(res: DecodingResult) { @@ -206,7 +239,7 @@ fn decoding_errors() { isize_invalid_encoding(decode::(&vec![0xA][..])); isize_invalid_encoding(decode::(&vec![0, 0, 0, 0, 0, 0, 0, 1, 0xFF][..])); // Out-of-bounds variant - #[derive(RustcEncodable, RustcDecodable)] + #[derive(RustcEncodable, RustcDecodable, Serialize)] enum Test { One, Two, @@ -215,28 +248,66 @@ fn decoding_errors() { isize_invalid_encoding(decode::>(&vec![5, 0][..])); } +#[test] +fn deserializing_errors() { + fn isize_invalid_deserialize(res: DeserializeResult) { + match res { + Err(DeserializeError::InvalidEncoding(_)) => {}, + Err(DeserializeError::SyntaxError) => {}, + _ => panic!("Expecting InvalidEncoding, got {:?}", res), + } + } + + 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][..])); + 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_reader(&mut &serialized[..], Bounded(3)); + assert!(deserialized.is_err()); + + let serialized = vec![0,0,0,3]; + 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'); } +#[test] +fn too_big_char_deserialize() { + let serialized = vec![0x41]; + let deserialized: Result = bincode::from_reader(&mut &serialized[..], Bounded(1)); + assert!(deserialized.is_ok()); + assert_eq!(deserialized.unwrap(), 'A'); +} + #[test] fn too_big_encode() { assert!(encode(&0u32, Bounded(3)).is_err()); @@ -246,6 +317,15 @@ fn too_big_encode() { assert!(encode(&"abcde", Bounded(8 + 5)).is_ok()); } +#[test] +fn too_big_serialize() { + assert!(bincode::to_vec(&0u32, Bounded(3)).is_err()); + assert!(bincode::to_vec(&0u32, Bounded(4)).is_ok()); + + assert!(bincode::to_vec(&"abcde", Bounded(8 + 4)).is_err()); + assert!(bincode::to_vec(&"abcde", Bounded(8 + 5)).is_ok()); +} + #[test] fn test_encoded_size() { assert!(encoded_size(&0u8) == 1); @@ -258,6 +338,21 @@ fn test_encoded_size() { assert!(encoded_size(&"a") == 8 + 1); assert!(encoded_size(&vec![0u32, 1u32, 2u32]) == 8 + 3 * (4)) + +} + +#[test] +fn test_serialized_size() { + assert!(bincode::serialized_size(&0u8) == 1); + assert!(bincode::serialized_size(&0u16) == 2); + assert!(bincode::serialized_size(&0u32) == 4); + assert!(bincode::serialized_size(&0u64) == 8); + + // length isize stored as u64 + assert!(bincode::serialized_size(&"") == 8); + assert!(bincode::serialized_size(&"a") == 8 + 1); + + assert!(bincode::serialized_size(&vec![0u32, 1u32, 2u32]) == 8 + 3 * (4)) } #[test] @@ -266,7 +361,7 @@ fn encode_box() { } #[test] -fn test_refbox() { +fn test_refbox_encode() { let large_object = vec![1u32,2,3,4,5,6]; let mut large_map = HashMap::new(); large_map.insert(1, 2); @@ -302,7 +397,43 @@ fn test_refbox() { } #[test] -fn test_strbox() { +fn test_refbox_serialize() { + let large_object = vec![1u32,2,3,4,5,6]; + let mut large_map = HashMap::new(); + large_map.insert(1, 2); + + + #[derive(RustcEncodable, RustcDecodable, Serialize, Deserialize, Debug)] + enum Message<'a> { + M1(RefBox<'a, Vec>), + M2(RefBox<'a, HashMap>) + } + + // Test 1 + { + let serialized = bincode::to_vec(&Message::M1(RefBox::new(&large_object)), Infinite).unwrap(); + let deserialized: Message<'static> = bincode::from_reader(&mut &serialized[..], Infinite).unwrap(); + + match deserialized { + Message::M1(b) => assert!(b.take().deref() == &large_object), + _ => assert!(false) + } + } + + // Test 2 + { + let serialized = bincode::to_vec(&Message::M2(RefBox::new(&large_map)), Infinite).unwrap(); + let deserialized: Message<'static> = bincode::from_reader(&mut &serialized[..], Infinite).unwrap(); + + match deserialized { + Message::M2(b) => assert!(b.take().deref() == &large_map), + _ => assert!(false) + } + } +} + +#[test] +fn test_strbox_encode() { let strx: &'static str = "hello world"; let encoded = encode(&StrBox::new(strx), Infinite).unwrap(); let decoded: StrBox<'static> = decode(&encoded[..]).unwrap(); @@ -311,7 +442,16 @@ fn test_strbox() { } #[test] -fn test_slicebox() { +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_reader(&mut &serialized[..], Infinite).unwrap(); + let stringx: String = deserialized.take(); + assert!(strx == &stringx[..]); +} + +#[test] +fn test_slicebox_encode() { let slice = [1u32, 2, 3 ,4, 5]; let encoded = encode(&SliceBox::new(&slice), Infinite).unwrap(); let decoded: SliceBox<'static, u32> = decode(&encoded[..]).unwrap(); @@ -324,7 +464,24 @@ fn test_slicebox() { } #[test] -fn test_multi_strings() { +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_reader(&mut &serialized[..], Infinite).unwrap(); + { + let sb: &[u32] = &deserialized; + assert!(slice == sb); + } + let vecx: Vec = deserialized.take(); + assert!(slice == &vecx[..]); +} + +#[test] +fn test_multi_strings_encode() { assert!(encode(&("foo", "bar", "baz"), Infinite).is_ok()); } -*/ + +#[test] +fn test_multi_strings_serialize() { + assert!(bincode::to_vec(&("foo", "bar", "baz"), Infinite).is_ok()); +} diff --git a/tests/test_serde.rs b/tests/test_serde.rs deleted file mode 100644 index 970ce23..0000000 --- a/tests/test_serde.rs +++ /dev/null @@ -1,487 +0,0 @@ -#![feature(plugin, custom_derive)] -#![plugin(serde_macros)] - -extern crate bincode; -extern crate rustc_serialize; -extern crate serde; - -use std::fmt::Debug; -use std::collections::HashMap; -use std::ops::Deref; - -use rustc_serialize::{Encoder, Decoder, Encodable, Decodable}; - -use bincode::{ - encode, - decode, - decode_from, - encoded_size, - DecodingError, - DecodingResult, - DeserializeError, - DeserializeResult, - RefBox, - StrBox, - SliceBox, -}; - -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 -{ - 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 -{ - let e1 = bincode::decode(slice).unwrap(); - let e2 = bincode::from_slice(slice).unwrap(); - - assert_eq!(e1, e2); - - e1 -} - -fn proxy_encoded_size(element: &V) -> u64 - where V: Encodable+Decodable+serde::Serialize+serde::Deserialize+PartialEq+Debug+'static -{ - let ser_size = bincode::encoded_size(element); - let serde_size = bincode::serialized_size(element); - assert_eq!(ser_size, serde_size); - ser_size -} - -fn the_same(element: V) - where V: Encodable+Decodable+serde::Serialize+serde::Deserialize+PartialEq+Debug+'static -{ - // 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 - { - let rf = RefBox::new(v); - 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); - let decoded = proxy_decode(&encoded[..]); - - assert_eq!(element, decoded); - assert_eq!(size, encoded.len() as u64); - assert!(ref_box_correct(&element)); -} - -#[test] -fn test_numbers() { - // unsigned positive - the_same(5u8); - the_same(5u16); - the_same(5u32); - the_same(5u64); - the_same(5usize); - // signed positive - the_same(5i8); - the_same(5i16); - the_same(5i32); - the_same(5i64); - the_same(5isize); - // signed negative - the_same(-5i8); - the_same(-5i16); - the_same(-5i32); - the_same(-5i64); - the_same(-5isize); - // floating - the_same(-100f32); - the_same(0f32); - the_same(5f32); - the_same(-100f64); - the_same(5f64); -} - -#[test] -fn test_string() { - the_same("".to_string()); - the_same("a".to_string()); -} - -#[test] -fn test_tuple() { - the_same((1isize,)); - the_same((1isize,2isize,3isize)); - the_same((1isize,"foo".to_string(),())); -} - -#[test] -fn test_basic_struct() { - #[derive(RustcEncodable, RustcDecodable, Serialize, Deserialize, PartialEq, Debug)] - struct Easy { - x: isize, - s: String, - y: usize - } - the_same(Easy{x: -4, s: "foo".to_string(), y: 10}); -} - -#[test] -fn test_nested_struct() { - #[derive(RustcEncodable, RustcDecodable, Serialize, Deserialize, PartialEq, Debug)] - struct Easy { - x: isize, - s: String, - y: usize - } - #[derive(RustcEncodable, RustcDecodable, Serialize, Deserialize, PartialEq, Debug)] - struct Nest { - f: Easy, - b: usize, - s: Easy - } - - the_same(Nest { - f: Easy {x: -1, s: "foo".to_string(), y: 20}, - b: 100, - s: Easy {x: -100, s: "bar".to_string(), y: 20} - }); -} - -#[test] -fn test_struct_newtype() { - #[derive(RustcEncodable, RustcDecodable, Serialize, Deserialize, PartialEq, Debug)] - struct NewtypeStr(usize); - - the_same(NewtypeStr(5)); -} - -#[test] -fn test_struct_tuple() { - #[derive(RustcEncodable, RustcDecodable, Serialize, Deserialize, PartialEq, Debug)] - struct TubStr(usize, String, f32); - - the_same(TubStr(5, "hello".to_string(), 3.2)); -} - -#[test] -fn test_option() { - the_same(Some(5usize)); - the_same(Some("foo bar".to_string())); - the_same(None::); -} - -#[test] -fn test_enum() { - #[derive(RustcEncodable, RustcDecodable, Serialize, Deserialize, PartialEq, Debug)] - enum TestEnum { - NoArg, - OneArg(usize), - Args(usize, usize), - AnotherNoArg, - StructLike{x: usize, y: f32} - } - the_same(TestEnum::NoArg); - the_same(TestEnum::OneArg(4)); - the_same(TestEnum::Args(4, 5)); - the_same(TestEnum::AnotherNoArg); - the_same(TestEnum::StructLike{x: 4, y: 3.14159}); - the_same(vec![TestEnum::NoArg, TestEnum::OneArg(5), TestEnum::AnotherNoArg, - TestEnum::StructLike{x: 4, y:1.4}]); -} - -#[test] -fn test_vec() { - let v: Vec = vec![]; - the_same(v); - the_same(vec![1u64]); - the_same(vec![1u64,2,3,4,5,6]); -} - -#[test] -fn test_map() { - let mut m = HashMap::new(); - m.insert(4u64, "foo".to_string()); - m.insert(0u64, "bar".to_string()); - the_same(m); -} - -#[test] -fn test_bool() { - the_same(true); - the_same(false); -} - -#[test] -fn test_unicode() { - the_same("å".to_string()); - the_same("aåååååååa".to_string()); -} - -#[test] -fn decoding_errors() { - fn isize_invalid_encoding(res: DecodingResult) { - match res { - Ok(_) => panic!("Expecting error"), - Err(DecodingError::IoError(_)) => panic!("Expecting InvalidEncoding"), - Err(DecodingError::SizeLimit) => panic!("Expecting InvalidEncoding"), - Err(DecodingError::InvalidEncoding(_)) => {}, - } - } - - isize_invalid_encoding(decode::(&vec![0xA][..])); - isize_invalid_encoding(decode::(&vec![0, 0, 0, 0, 0, 0, 0, 1, 0xFF][..])); - // Out-of-bounds variant - #[derive(RustcEncodable, RustcDecodable, Serialize)] - enum Test { - One, - Two, - }; - isize_invalid_encoding(decode::(&vec![0, 0, 0, 5][..])); - isize_invalid_encoding(decode::>(&vec![5, 0][..])); -} - -#[test] -fn deserializing_errors() { - fn isize_invalid_deserialize(res: DeserializeResult) { - match res { - Err(DeserializeError::InvalidEncoding(_)) => {}, - Err(DeserializeError::SyntaxError) => {}, - _ => panic!("Expecting InvalidEncoding, got {:?}", res), - } - } - - 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][..])); - isize_invalid_deserialize(bincode::from_slice::>(&vec![5, 0][..])); -} - -#[test] -fn too_big_decode() { - let encoded = vec![0,0,0,3]; - let decoded: Result = decode_from(&mut &encoded[..], Bounded(3)); - assert!(decoded.is_err()); - - let encoded = vec![0,0,0,3]; - 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_reader(&mut &serialized[..], Bounded(3)); - assert!(deserialized.is_err()); - - let serialized = vec![0,0,0,3]; - 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 decoded: Result = decode_from(&mut &encoded[..], Bounded(1)); - assert!(decoded.is_ok()); - assert_eq!(decoded.unwrap(), 'A'); -} - -#[test] -fn too_big_char_deserialize() { - let serialized = vec![0x41]; - let deserialized: Result = bincode::from_reader(&mut &serialized[..], Bounded(1)); - assert!(deserialized.is_ok()); - assert_eq!(deserialized.unwrap(), 'A'); -} - -#[test] -fn too_big_encode() { - assert!(encode(&0u32, Bounded(3)).is_err()); - assert!(encode(&0u32, Bounded(4)).is_ok()); - - assert!(encode(&"abcde", Bounded(8 + 4)).is_err()); - assert!(encode(&"abcde", Bounded(8 + 5)).is_ok()); -} - -#[test] -fn too_big_serialize() { - assert!(bincode::to_vec(&0u32, Bounded(3)).is_err()); - assert!(bincode::to_vec(&0u32, Bounded(4)).is_ok()); - - assert!(bincode::to_vec(&"abcde", Bounded(8 + 4)).is_err()); - assert!(bincode::to_vec(&"abcde", Bounded(8 + 5)).is_ok()); -} - -#[test] -fn test_encoded_size() { - assert!(encoded_size(&0u8) == 1); - assert!(encoded_size(&0u16) == 2); - assert!(encoded_size(&0u32) == 4); - assert!(encoded_size(&0u64) == 8); - - // length isize stored as u64 - assert!(encoded_size(&"") == 8); - assert!(encoded_size(&"a") == 8 + 1); - - assert!(encoded_size(&vec![0u32, 1u32, 2u32]) == 8 + 3 * (4)) - -} - -#[test] -fn test_serialized_size() { - assert!(bincode::serialized_size(&0u8) == 1); - assert!(bincode::serialized_size(&0u16) == 2); - assert!(bincode::serialized_size(&0u32) == 4); - assert!(bincode::serialized_size(&0u64) == 8); - - // length isize stored as u64 - assert!(bincode::serialized_size(&"") == 8); - assert!(bincode::serialized_size(&"a") == 8 + 1); - - assert!(bincode::serialized_size(&vec![0u32, 1u32, 2u32]) == 8 + 3 * (4)) -} - -#[test] -fn encode_box() { - the_same(Box::new(5)); -} - -#[test] -fn test_refbox_encode() { - let large_object = vec![1u32,2,3,4,5,6]; - let mut large_map = HashMap::new(); - large_map.insert(1, 2); - - - #[derive(RustcEncodable, RustcDecodable, Debug)] - enum Message<'a> { - M1(RefBox<'a, Vec>), - M2(RefBox<'a, HashMap>) - } - - // Test 1 - { - let encoded = encode(&Message::M1(RefBox::new(&large_object)), Infinite).unwrap(); - let decoded: Message<'static> = decode(&encoded[..]).unwrap(); - - match decoded { - Message::M1(b) => assert!(b.take().deref() == &large_object), - _ => assert!(false) - } - } - - // Test 2 - { - let encoded = encode(&Message::M2(RefBox::new(&large_map)), Infinite).unwrap(); - let decoded: Message<'static> = decode(&encoded[..]).unwrap(); - - match decoded { - Message::M2(b) => assert!(b.take().deref() == &large_map), - _ => assert!(false) - } - } -} - -#[test] -fn test_refbox_serialize() { - let large_object = vec![1u32,2,3,4,5,6]; - let mut large_map = HashMap::new(); - large_map.insert(1, 2); - - - #[derive(RustcEncodable, RustcDecodable, Serialize, Deserialize, Debug)] - enum Message<'a> { - M1(RefBox<'a, Vec>), - M2(RefBox<'a, HashMap>) - } - - // Test 1 - { - let serialized = bincode::to_vec(&Message::M1(RefBox::new(&large_object)), Infinite).unwrap(); - let deserialized: Message<'static> = bincode::from_reader(&mut &serialized[..], Infinite).unwrap(); - - match deserialized { - Message::M1(b) => assert!(b.take().deref() == &large_object), - _ => assert!(false) - } - } - - // Test 2 - { - let serialized = bincode::to_vec(&Message::M2(RefBox::new(&large_map)), Infinite).unwrap(); - let deserialized: Message<'static> = bincode::from_reader(&mut &serialized[..], Infinite).unwrap(); - - match deserialized { - Message::M2(b) => assert!(b.take().deref() == &large_map), - _ => assert!(false) - } - } -} - -#[test] -fn test_strbox_encode() { - let strx: &'static str = "hello world"; - let encoded = encode(&StrBox::new(strx), Infinite).unwrap(); - let decoded: StrBox<'static> = decode(&encoded[..]).unwrap(); - let stringx: String = decoded.take(); - assert!(strx == &stringx[..]); -} - -#[test] -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_reader(&mut &serialized[..], Infinite).unwrap(); - let stringx: String = deserialized.take(); - assert!(strx == &stringx[..]); -} - -#[test] -fn test_slicebox_encode() { - let slice = [1u32, 2, 3 ,4, 5]; - let encoded = encode(&SliceBox::new(&slice), Infinite).unwrap(); - let decoded: SliceBox<'static, u32> = decode(&encoded[..]).unwrap(); - { - let sb: &[u32] = &decoded; - assert!(slice == sb); - } - let vecx: Vec = decoded.take(); - assert!(slice == &vecx[..]); -} - -#[test] -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_reader(&mut &serialized[..], Infinite).unwrap(); - { - let sb: &[u32] = &deserialized; - assert!(slice == sb); - } - let vecx: Vec = deserialized.take(); - assert!(slice == &vecx[..]); -} - -#[test] -fn test_multi_strings_encode() { - assert!(encode(&("foo", "bar", "baz"), Infinite).is_ok()); -} - -#[test] -fn test_multi_strings_serialize() { - assert!(bincode::to_vec(&("foo", "bar", "baz"), Infinite).is_ok()); -}