diff --git a/testing/tests/test_annotations.rs b/testing/tests/test_annotations.rs index ba77f8f9..50754f56 100644 --- a/testing/tests/test_annotations.rs +++ b/testing/tests/test_annotations.rs @@ -20,7 +20,7 @@ trait ShouldSkip: Sized { } trait SerializeWith: Sized { - fn serialize_with(&self, ser: &mut S) -> Result<(), S::Error> + fn serialize_with(&self, ser: S) -> Result where S: Serializer; } @@ -38,7 +38,7 @@ impl ShouldSkip for i32 { } impl SerializeWith for i32 { - fn serialize_with(&self, ser: &mut S) -> Result<(), S::Error> + fn serialize_with(&self, ser: S) -> Result where S: Serializer { if *self == 123 { @@ -642,7 +642,7 @@ struct NotSerializeStruct(i8); enum NotSerializeEnum { Trouble } impl SerializeWith for NotSerializeEnum { - fn serialize_with(&self, ser: &mut S) -> Result<(), S::Error> + fn serialize_with(&self, ser: S) -> Result where S: Serializer { "trouble".serialize(ser) diff --git a/testing/tests/test_bytes.rs b/testing/tests/test_bytes.rs index a0e5fbcc..6968f900 100644 --- a/testing/tests/test_bytes.rs +++ b/testing/tests/test_bytes.rs @@ -1,312 +1,20 @@ -use std::fmt; -use std::error; - -use serde::{Serialize, Serializer}; use serde::bytes::{ByteBuf, Bytes}; -use serde::ser; -use serde::de; - -use serde_test::{assert_de_tokens, Token}; - -/////////////////////////////////////////////////////////////////////////////// - -#[derive(Debug, PartialEq)] -struct Error; - -impl ser::Error for Error { - fn custom>(_: T) -> Error { Error } -} - -impl de::Error for Error { - fn custom>(_: T) -> Error { Error } - - fn end_of_stream() -> Error { Error } -} - -impl fmt::Display for Error { - fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> { - formatter.write_str(format!("{:?}", self).as_ref()) - } -} - -impl error::Error for Error { - fn description(&self) -> &str { - "Serde Deserialization Error" - } - - fn cause(&self) -> Option<&error::Error> { - None - } -} - -/////////////////////////////////////////////////////////////////////////////// - -struct BytesSerializer { - bytes: Vec, -} - -impl BytesSerializer { - fn new(bytes: Vec) -> Self { - BytesSerializer { - bytes: bytes, - } - } -} - -impl Serializer for BytesSerializer { - type Error = Error; - type SeqState = (); - type MapState = (); - type TupleState = (); - type TupleStructState = (); - type TupleVariantState = (); - type StructState = (); - type StructVariantState = (); - - fn serialize_unit(&mut self) -> Result<(), Error> { - Err(Error) - } - - fn serialize_unit_struct(&mut self, _name: &'static str) -> Result<(), Error> { - Err(Error) - } - - fn serialize_unit_variant(&mut self, _: &'static str, _: usize, _: &'static str) -> Result<(), Error> { - Err(Error) - } - - fn serialize_bool(&mut self, _v: bool) -> Result<(), Error> { - Err(Error) - } - - fn serialize_isize(&mut self, _v: isize) -> Result<(), Error> { - Err(Error) - } - - fn serialize_usize(&mut self, _v: usize) -> Result<(), Error> { - Err(Error) - } - - fn serialize_i8(&mut self, _v: i8) -> Result<(), Error> { - Err(Error) - } - - fn serialize_u8(&mut self, _v: u8) -> Result<(), Error> { - Err(Error) - } - - fn serialize_i16(&mut self, _v: i16) -> Result<(), Error> { - Err(Error) - } - - fn serialize_u16(&mut self, _v: u16) -> Result<(), Error> { - Err(Error) - } - - fn serialize_i32(&mut self, _v: i32) -> Result<(), Error> { - Err(Error) - } - - fn serialize_u32(&mut self, _v: u32) -> Result<(), Error> { - Err(Error) - } - - fn serialize_i64(&mut self, _v: i64) -> Result<(), Error> { - Err(Error) - } - - fn serialize_u64(&mut self, _v: u64) -> Result<(), Error> { - Err(Error) - } - - fn serialize_f32(&mut self, _v: f32) -> Result<(), Error> { - Err(Error) - } - - fn serialize_f64(&mut self, _v: f64) -> Result<(), Error> { - Err(Error) - } - - fn serialize_char(&mut self, _v: char) -> Result<(), Error> { - Err(Error) - } - - fn serialize_str(&mut self, _v: &str) -> Result<(), Error> { - Err(Error) - } - - fn serialize_none(&mut self) -> Result<(), Error> { - Err(Error) - } - - fn serialize_some(&mut self, _value: V) -> Result<(), Error> - where V: Serialize, - { - Err(Error) - } - - fn serialize_newtype_struct(&mut self, _: &'static str, _value: V) -> Result<(), Error> - where V: Serialize, - { - Err(Error) - } - - fn serialize_newtype_variant(&mut self, _: &'static str, _: usize, _: &'static str, _value: V) -> Result<(), Error> - where V: Serialize, - { - Err(Error) - } - - fn serialize_seq(&mut self, _len: Option) -> Result<(), Error> - { - Err(Error) - } - - fn serialize_seq_fixed_size(&mut self, _len: usize) -> Result<(), Error> - { - Err(Error) - } - - fn serialize_seq_elt(&mut self, _: &mut (), _value: T) -> Result<(), Error> - where T: Serialize - { - Err(Error) - } - - fn serialize_seq_end(&mut self, _: ()) -> Result<(), Error> - { - Err(Error) - } - - fn serialize_tuple(&mut self, _len: usize) -> Result<(), Error> - { - Err(Error) - } - - fn serialize_tuple_elt(&mut self, _: &mut (), _value: T) -> Result<(), Error> - where T: Serialize - { - Err(Error) - } - - fn serialize_tuple_end(&mut self, _: ()) -> Result<(), Error> - { - Err(Error) - } - - fn serialize_tuple_struct(&mut self, _: &'static str, _len: usize) -> Result<(), Error> - { - Err(Error) - } - - fn serialize_tuple_struct_elt(&mut self, _: &mut (), _value: T) -> Result<(), Error> - where T: Serialize - { - Err(Error) - } - - fn serialize_tuple_struct_end(&mut self, _: ()) -> Result<(), Error> - { - Err(Error) - } - - fn serialize_tuple_variant(&mut self, _: &'static str, _: usize, _: &'static str, _len: usize) -> Result<(), Error> - { - Err(Error) - } - - fn serialize_tuple_variant_elt(&mut self, _: &mut (), _value: T) -> Result<(), Error> - where T: Serialize - { - Err(Error) - } - - fn serialize_tuple_variant_end(&mut self, _: ()) -> Result<(), Error> - { - Err(Error) - } - - fn serialize_map(&mut self, _: Option) -> Result<(), Error> - { - Err(Error) - } - - fn serialize_map_key(&mut self, _: &mut (), _key: T) -> Result<(), Error> - where T: Serialize - { - Err(Error) - } - - fn serialize_map_value(&mut self, _: &mut (), _value: T) -> Result<(), Error> - where T: Serialize - { - Err(Error) - } - - fn serialize_map_end(&mut self, _: ()) -> Result<(), Error> - { - Err(Error) - } - - fn serialize_struct(&mut self, _: &'static str, _: usize) -> Result<(), Error> - { - Err(Error) - } - - fn serialize_struct_elt(&mut self, _: &mut (), _key: &'static str, _value: V) -> Result<(), Error> - where V: Serialize, - { - Err(Error) - } - - fn serialize_struct_end(&mut self, _: ()) -> Result<(), Error> - { - Err(Error) - } - - fn serialize_struct_variant(&mut self, _: &'static str, _: usize, _: &'static str, _: usize) -> Result<(), Error> - { - Err(Error) - } - - fn serialize_struct_variant_elt(&mut self, _: &mut (), _key: &'static str, _value: V) -> Result<(), Error> - where V: Serialize, - { - Err(Error) - } - - fn serialize_struct_variant_end(&mut self, _: ()) -> Result<(), Error> - { - Err(Error) - } - - fn serialize_bytes(&mut self, bytes: &[u8]) -> Result<(), Error> { - assert_eq!(self.bytes, bytes); - Ok(()) - } -} - -/////////////////////////////////////////////////////////////////////////////// +use serde_test::{assert_tokens, assert_ser_tokens, assert_de_tokens, Token}; #[test] -fn test_bytes_ser_bytes() { - let buf = vec![]; - let bytes = Bytes::from(&buf); - let mut ser = BytesSerializer::new(vec![]); - bytes.serialize(&mut ser).unwrap(); +fn test_bytes() { + let empty = Bytes::new(&[]); + assert_ser_tokens(&empty, &[Token::Bytes(b"")]); - let buf = vec![1, 2, 3]; - let bytes = Bytes::from(&buf); - let mut ser = BytesSerializer::new(vec![1, 2, 3]); - bytes.serialize(&mut ser).unwrap(); + let buf = vec![65, 66, 67]; + let bytes = Bytes::new(&buf); + assert_ser_tokens(&bytes, &[Token::Bytes(b"ABC")]); } -/////////////////////////////////////////////////////////////////////////////// - #[test] -fn test_byte_buf_de() { +fn test_byte_buf() { let empty = ByteBuf::new(); - assert_de_tokens(&empty, &[Token::Bytes(b""),]); + assert_tokens(&empty, &[Token::Bytes(b"")]); assert_de_tokens(&empty, &[Token::Str("")]); assert_de_tokens(&empty, &[Token::String(String::new())]); assert_de_tokens(&empty, &[ @@ -319,7 +27,7 @@ fn test_byte_buf_de() { ]); let buf = ByteBuf::from(vec![65, 66, 67]); - assert_de_tokens(&buf, &[Token::Bytes(b"ABC")]); + assert_tokens(&buf, &[Token::Bytes(b"ABC")]); assert_de_tokens(&buf, &[Token::Str("ABC")]); assert_de_tokens(&buf, &[Token::String("ABC".to_owned())]); assert_de_tokens(&buf, &[ diff --git a/testing/tests/test_gen.rs b/testing/tests/test_gen.rs index 24338312..a07f6f81 100644 --- a/testing/tests/test_gen.rs +++ b/testing/tests/test_gen.rs @@ -295,7 +295,7 @@ fn assert() {} fn assert_ser() {} trait SerializeWith { - fn serialize_with(_: &Self, _: &mut S) -> StdResult<(), S::Error>; + fn serialize_with(_: &Self, _: S) -> StdResult; } trait DeserializeWith: Sized { @@ -305,7 +305,7 @@ trait DeserializeWith: Sized { // Implements neither Serialize nor Deserialize struct X; -fn ser_x(_: &X, _: &mut S) -> StdResult<(), S::Error> { +fn ser_x(_: &X, _: S) -> StdResult { unimplemented!() } @@ -314,7 +314,7 @@ fn de_x(_: &mut D) -> StdResult { } impl SerializeWith for X { - fn serialize_with(_: &Self, _: &mut S) -> StdResult<(), S::Error> { + fn serialize_with(_: &Self, _: S) -> StdResult { unimplemented!() } }