From 93860d064331c1c22ece53d3278ca7b1c2a5014a Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Wed, 5 Apr 2017 00:27:30 -0700 Subject: [PATCH] Require slice of tokens in serde_test::Serializer --- serde_test/src/assert.rs | 4 +- serde_test/src/ser.rs | 141 +++++++++++++++++---------------------- 2 files changed, 63 insertions(+), 82 deletions(-) diff --git a/serde_test/src/assert.rs b/serde_test/src/assert.rs index edfadf0d..ccfa4c26 100644 --- a/serde_test/src/assert.rs +++ b/serde_test/src/assert.rs @@ -19,7 +19,7 @@ pub fn assert_tokens<'de, T>(value: &T, tokens: &'de [Token]) pub fn assert_ser_tokens(value: &T, tokens: &[Token]) where T: Serialize { - let mut ser = Serializer::new(tokens.iter()); + let mut ser = Serializer::new(tokens); assert_eq!(Serialize::serialize(value, &mut ser), Ok(())); assert_eq!(ser.next_token(), None); } @@ -28,7 +28,7 @@ pub fn assert_ser_tokens(value: &T, tokens: &[Token]) pub fn assert_ser_tokens_error(value: &T, tokens: &[Token], error: Error) where T: Serialize + PartialEq + Debug { - let mut ser = Serializer::new(tokens.iter()); + let mut ser = Serializer::new(tokens); let v: Result<(), Error> = Serialize::serialize(value, &mut ser); assert_eq!(v.as_ref(), Err(&error)); assert_eq!(ser.next_token(), None); diff --git a/serde_test/src/ser.rs b/serde_test/src/ser.rs index c38b1a04..2ad6ffce 100644 --- a/serde_test/src/ser.rs +++ b/serde_test/src/ser.rs @@ -1,38 +1,35 @@ -use std::marker::PhantomData; - use serde::{ser, Serialize}; use error::Error; use token::Token; /// A `Serializer` that ensures that a value serializes to a given list of tokens. -pub struct Serializer<'a, I> - where I: Iterator -{ - tokens: I, - phantom: PhantomData<&'a Token>, +pub struct Serializer<'a> { + tokens: &'a [Token], } -impl<'a, I> Serializer<'a, I> - where I: Iterator -{ +impl<'a> Serializer<'a> { /// Creates the serializer. - pub fn new(tokens: I) -> Serializer<'a, I> { + pub fn new(tokens: &'a [Token]) -> Self { Serializer { tokens: tokens, - phantom: PhantomData, } } /// Pulls the next token off of the serializer, ignoring it. - pub fn next_token(&mut self) -> Option<&'a Token> { - self.tokens.next() + pub fn next_token(&mut self) -> Option<&Token> { + if let Some((first, rest)) = self.tokens.split_first() { + self.tokens = rest; + Some(first) + } else { + None + } } } macro_rules! assert_next_token { ($self:ident, $expected:ident($arg:expr)) => { - match $self.tokens.next() { + match $self.next_token() { Some(&Token::$expected(v)) if v == $arg => {} Some(other) => { panic!("expected {}({:?}) but serialized as {:?}", stringify!($expected), $arg, other); @@ -44,9 +41,7 @@ macro_rules! assert_next_token { } } -impl<'s, 'a, I> ser::Serializer for &'s mut Serializer<'a, I> - where I: Iterator -{ +impl<'s, 'a> ser::Serializer for &'s mut Serializer<'a> { type Ok = (); type Error = Error; @@ -59,62 +54,62 @@ impl<'s, 'a, I> ser::Serializer for &'s mut Serializer<'a, I> type SerializeStructVariant = Self; fn serialize_bool(self, v: bool) -> Result<(), Error> { - assert_eq!(self.tokens.next(), Some(&Token::Bool(v))); + assert_eq!(self.next_token(), Some(&Token::Bool(v))); Ok(()) } fn serialize_i8(self, v: i8) -> Result<(), Error> { - assert_eq!(self.tokens.next(), Some(&Token::I8(v))); + assert_eq!(self.next_token(), Some(&Token::I8(v))); Ok(()) } fn serialize_i16(self, v: i16) -> Result<(), Error> { - assert_eq!(self.tokens.next(), Some(&Token::I16(v))); + assert_eq!(self.next_token(), Some(&Token::I16(v))); Ok(()) } fn serialize_i32(self, v: i32) -> Result<(), Error> { - assert_eq!(self.tokens.next(), Some(&Token::I32(v))); + assert_eq!(self.next_token(), Some(&Token::I32(v))); Ok(()) } fn serialize_i64(self, v: i64) -> Result<(), Error> { - assert_eq!(self.tokens.next(), Some(&Token::I64(v))); + assert_eq!(self.next_token(), Some(&Token::I64(v))); Ok(()) } fn serialize_u8(self, v: u8) -> Result<(), Error> { - assert_eq!(self.tokens.next(), Some(&Token::U8(v))); + assert_eq!(self.next_token(), Some(&Token::U8(v))); Ok(()) } fn serialize_u16(self, v: u16) -> Result<(), Error> { - assert_eq!(self.tokens.next(), Some(&Token::U16(v))); + assert_eq!(self.next_token(), Some(&Token::U16(v))); Ok(()) } fn serialize_u32(self, v: u32) -> Result<(), Error> { - assert_eq!(self.tokens.next(), Some(&Token::U32(v))); + assert_eq!(self.next_token(), Some(&Token::U32(v))); Ok(()) } fn serialize_u64(self, v: u64) -> Result<(), Error> { - assert_eq!(self.tokens.next(), Some(&Token::U64(v))); + assert_eq!(self.next_token(), Some(&Token::U64(v))); Ok(()) } fn serialize_f32(self, v: f32) -> Result<(), Error> { - assert_eq!(self.tokens.next(), Some(&Token::F32(v))); + assert_eq!(self.next_token(), Some(&Token::F32(v))); Ok(()) } fn serialize_f64(self, v: f64) -> Result<(), Error> { - assert_eq!(self.tokens.next(), Some(&Token::F64(v))); + assert_eq!(self.next_token(), Some(&Token::F64(v))); Ok(()) } fn serialize_char(self, v: char) -> Result<(), Error> { - assert_eq!(self.tokens.next(), Some(&Token::Char(v))); + assert_eq!(self.next_token(), Some(&Token::Char(v))); Ok(()) } @@ -129,12 +124,12 @@ impl<'s, 'a, I> ser::Serializer for &'s mut Serializer<'a, I> } fn serialize_unit(self) -> Result<(), Error> { - assert_eq!(self.tokens.next(), Some(&Token::Unit)); + assert_eq!(self.next_token(), Some(&Token::Unit)); Ok(()) } fn serialize_unit_struct(self, name: &'static str) -> Result<(), Error> { - assert_eq!(self.tokens.next(), Some(&Token::UnitStruct(name))); + assert_eq!(self.next_token(), Some(&Token::UnitStruct(name))); Ok(()) } @@ -143,14 +138,14 @@ impl<'s, 'a, I> ser::Serializer for &'s mut Serializer<'a, I> _variant_index: usize, variant: &'static str) -> Result<(), Error> { - assert_eq!(self.tokens.next(), Some(&Token::EnumUnit(name, variant))); + assert_eq!(self.next_token(), Some(&Token::EnumUnit(name, variant))); Ok(()) } fn serialize_newtype_struct(self, name: &'static str, value: &T) -> Result<(), Error> where T: Serialize { - assert_eq!(self.tokens.next(), Some(&Token::StructNewType(name))); + assert_eq!(self.next_token(), Some(&Token::StructNewType(name))); value.serialize(self) } @@ -162,39 +157,39 @@ impl<'s, 'a, I> ser::Serializer for &'s mut Serializer<'a, I> -> Result<(), Error> where T: Serialize { - assert_eq!(self.tokens.next(), Some(&Token::EnumNewType(name, variant))); + assert_eq!(self.next_token(), Some(&Token::EnumNewType(name, variant))); value.serialize(self) } fn serialize_none(self) -> Result<(), Error> { - assert_eq!(self.tokens.next(), Some(&Token::Option(false))); + assert_eq!(self.next_token(), Some(&Token::Option(false))); Ok(()) } fn serialize_some(self, value: &T) -> Result<(), Error> where T: Serialize { - assert_eq!(self.tokens.next(), Some(&Token::Option(true))); + assert_eq!(self.next_token(), Some(&Token::Option(true))); value.serialize(self) } fn serialize_seq(self, len: Option) -> Result { - assert_eq!(self.tokens.next(), Some(&Token::SeqStart(len))); + assert_eq!(self.next_token(), Some(&Token::SeqStart(len))); Ok(self) } fn serialize_seq_fixed_size(self, len: usize) -> Result { - assert_eq!(self.tokens.next(), Some(&Token::SeqArrayStart(len))); + assert_eq!(self.next_token(), Some(&Token::SeqArrayStart(len))); Ok(self) } fn serialize_tuple(self, len: usize) -> Result { - assert_eq!(self.tokens.next(), Some(&Token::TupleStart(len))); + assert_eq!(self.next_token(), Some(&Token::TupleStart(len))); Ok(self) } fn serialize_tuple_struct(self, name: &'static str, len: usize) -> Result { - assert_eq!(self.tokens.next(), + assert_eq!(self.next_token(), Some(&Token::TupleStructStart(name, len))); Ok(self) } @@ -205,18 +200,18 @@ impl<'s, 'a, I> ser::Serializer for &'s mut Serializer<'a, I> variant: &'static str, len: usize) -> Result { - assert_eq!(self.tokens.next(), + assert_eq!(self.next_token(), Some(&Token::EnumSeqStart(name, variant, len))); Ok(self) } fn serialize_map(self, len: Option) -> Result { - assert_eq!(self.tokens.next(), Some(&Token::MapStart(len))); + assert_eq!(self.next_token(), Some(&Token::MapStart(len))); Ok(self) } fn serialize_struct(self, name: &'static str, len: usize) -> Result { - assert_eq!(self.tokens.next(), Some(&Token::StructStart(name, len))); + assert_eq!(self.next_token(), Some(&Token::StructStart(name, len))); Ok(self) } @@ -226,98 +221,88 @@ impl<'s, 'a, I> ser::Serializer for &'s mut Serializer<'a, I> variant: &'static str, len: usize) -> Result { - assert_eq!(self.tokens.next(), + assert_eq!(self.next_token(), Some(&Token::EnumMapStart(name, variant, len))); Ok(self) } } -impl<'s, 'a, I> ser::SerializeSeq for &'s mut Serializer<'a, I> - where I: Iterator -{ +impl<'s, 'a> ser::SerializeSeq for &'s mut Serializer<'a> { type Ok = (); type Error = Error; fn serialize_element(&mut self, value: &T) -> Result<(), Error> where T: Serialize { - assert_eq!(self.tokens.next(), Some(&Token::SeqSep)); + assert_eq!(self.next_token(), Some(&Token::SeqSep)); value.serialize(&mut **self) } fn end(self) -> Result<(), Error> { - assert_eq!(self.tokens.next(), Some(&Token::SeqEnd)); + assert_eq!(self.next_token(), Some(&Token::SeqEnd)); Ok(()) } } -impl<'s, 'a, I> ser::SerializeTuple for &'s mut Serializer<'a, I> - where I: Iterator -{ +impl<'s, 'a> ser::SerializeTuple for &'s mut Serializer<'a> { type Ok = (); type Error = Error; fn serialize_element(&mut self, value: &T) -> Result<(), Error> where T: Serialize { - assert_eq!(self.tokens.next(), Some(&Token::TupleSep)); + assert_eq!(self.next_token(), Some(&Token::TupleSep)); value.serialize(&mut **self) } fn end(self) -> Result<(), Error> { - assert_eq!(self.tokens.next(), Some(&Token::TupleEnd)); + assert_eq!(self.next_token(), Some(&Token::TupleEnd)); Ok(()) } } -impl<'s, 'a, I> ser::SerializeTupleStruct for &'s mut Serializer<'a, I> - where I: Iterator -{ +impl<'s, 'a> ser::SerializeTupleStruct for &'s mut Serializer<'a> { type Ok = (); type Error = Error; fn serialize_field(&mut self, value: &T) -> Result<(), Error> where T: Serialize { - assert_eq!(self.tokens.next(), Some(&Token::TupleStructSep)); + assert_eq!(self.next_token(), Some(&Token::TupleStructSep)); value.serialize(&mut **self) } fn end(self) -> Result<(), Error> { - assert_eq!(self.tokens.next(), Some(&Token::TupleStructEnd)); + assert_eq!(self.next_token(), Some(&Token::TupleStructEnd)); Ok(()) } } -impl<'s, 'a, I> ser::SerializeTupleVariant for &'s mut Serializer<'a, I> - where I: Iterator -{ +impl<'s, 'a> ser::SerializeTupleVariant for &'s mut Serializer<'a> { type Ok = (); type Error = Error; fn serialize_field(&mut self, value: &T) -> Result<(), Error> where T: Serialize { - assert_eq!(self.tokens.next(), Some(&Token::EnumSeqSep)); + assert_eq!(self.next_token(), Some(&Token::EnumSeqSep)); value.serialize(&mut **self) } fn end(self) -> Result<(), Error> { - assert_eq!(self.tokens.next(), Some(&Token::EnumSeqEnd)); + assert_eq!(self.next_token(), Some(&Token::EnumSeqEnd)); Ok(()) } } -impl<'s, 'a, I> ser::SerializeMap for &'s mut Serializer<'a, I> - where I: Iterator -{ +impl<'s, 'a> ser::SerializeMap for &'s mut Serializer<'a> { type Ok = (); type Error = Error; fn serialize_key(&mut self, key: &T) -> Result<(), Self::Error> where T: Serialize { - assert_eq!(self.tokens.next(), Some(&Token::MapSep)); + assert_eq!(self.next_token(), Some(&Token::MapSep)); key.serialize(&mut **self) } @@ -328,14 +313,12 @@ impl<'s, 'a, I> ser::SerializeMap for &'s mut Serializer<'a, I> } fn end(self) -> Result<(), Self::Error> { - assert_eq!(self.tokens.next(), Some(&Token::MapEnd)); + assert_eq!(self.next_token(), Some(&Token::MapEnd)); Ok(()) } } -impl<'s, 'a, I> ser::SerializeStruct for &'s mut Serializer<'a, I> - where I: Iterator -{ +impl<'s, 'a> ser::SerializeStruct for &'s mut Serializer<'a> { type Ok = (); type Error = Error; @@ -345,20 +328,18 @@ impl<'s, 'a, I> ser::SerializeStruct for &'s mut Serializer<'a, I> -> Result<(), Self::Error> where T: Serialize { - assert_eq!(self.tokens.next(), Some(&Token::StructSep)); + assert_eq!(self.next_token(), Some(&Token::StructSep)); try!(key.serialize(&mut **self)); value.serialize(&mut **self) } fn end(self) -> Result<(), Self::Error> { - assert_eq!(self.tokens.next(), Some(&Token::StructEnd)); + assert_eq!(self.next_token(), Some(&Token::StructEnd)); Ok(()) } } -impl<'s, 'a, I> ser::SerializeStructVariant for &'s mut Serializer<'a, I> - where I: Iterator -{ +impl<'s, 'a> ser::SerializeStructVariant for &'s mut Serializer<'a> { type Ok = (); type Error = Error; @@ -368,13 +349,13 @@ impl<'s, 'a, I> ser::SerializeStructVariant for &'s mut Serializer<'a, I> -> Result<(), Self::Error> where T: Serialize { - assert_eq!(self.tokens.next(), Some(&Token::EnumMapSep)); + assert_eq!(self.next_token(), Some(&Token::EnumMapSep)); try!(key.serialize(&mut **self)); value.serialize(&mut **self) } fn end(self) -> Result<(), Self::Error> { - assert_eq!(self.tokens.next(), Some(&Token::EnumMapEnd)); + assert_eq!(self.next_token(), Some(&Token::EnumMapEnd)); Ok(()) } }