Merge pull request #412 from dtolnay/test

Move Token De/Serializer to serde_test crate
2016-06-29 10:05:36 +02:00 · 2016-06-29 10:05:36 +02:00 · d1be5ef187
commit d1be5ef187
parent 6ab508a93c f531be1524
28 changed files with 937 additions and 848 deletions
--- a/.travis.yml
+++ b/.travis.yml
@ -22,15 +22,15 @@ script:
 - (cd serde && travis-cargo build -- --no-default-features)
 - (cd serde && travis-cargo --only nightly build -- --no-default-features --features alloc)
 - (cd serde && travis-cargo --only nightly build -- --no-default-features --features collections)
- (cd serde_tests && travis-cargo --skip nightly test)
- (cd serde_tests && travis-cargo --only nightly test -- --features nightly-testing)
+- (cd testing && travis-cargo --skip nightly test)
+- (cd testing && travis-cargo --only nightly test -- --features nightly-testing)
 - (cd serde_macros && travis-cargo --only nightly test -- --features nightly-testing)
 - (cd examples/serde-syntex-example && travis-cargo --skip nightly run)
 - (cd examples/serde-syntex-example && travis-cargo --only nightly run -- --no-default-features --features nightly)
 - (cd serde && travis-cargo --only stable doc)
 after_success:
 - (cd serde && travis-cargo --only stable doc-upload)
- (cd serde_tests && travis-cargo --only stable coveralls --no-sudo)
+- (cd testing && travis-cargo --only stable coveralls --no-sudo)
 env:
  global:
  - TRAVIS_CARGO_NIGHTLY_FEATURE=""
--- a/serde_macros/Cargo.toml
+++ b/serde_macros/Cargo.toml
@ -25,6 +25,7 @@ compiletest_rs = "^0.2.0"
 fnv = "1.0"
 rustc-serialize = "^0.3.16"
 serde = { version = "^0.7.11", path = "../serde" }
+serde_test = { version = "^0.7.11", path = "../serde_test" }

 [[test]]
 name = "test"
--- a/serde_macros/benches/bench.rs
+++ b/serde_macros/benches/bench.rs
@ -6,4 +6,4 @@ extern crate rustc_serialize;
 extern crate serde;
 extern crate test;

-include!("../../serde_tests/benches/bench.rs.in");
+include!("../../testing/benches/bench.rs.in");
--- a/serde_macros/tests/test.rs
+++ b/serde_macros/tests/test.rs
@ -4,6 +4,6 @@
 extern crate serde;
 extern crate test;

-include!("../../serde_tests/tests/test.rs.in");
+include!("../../testing/tests/test.rs.in");

 mod compile_tests;
--- a/serde_test/Cargo.toml
+++ b/serde_test/Cargo.toml
@ -0,0 +1,14 @@
+[package]
+name = "serde_test"
+version = "0.7.11"
+authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
+license = "MIT/Apache-2.0"
+description = "Token De/Serializer for testing De/Serialize implementations"
+repository = "https://github.com/serde-rs/serde"
+documentation = "https://serde-rs.github.io/serde/serde/"
+readme = "../README.md"
+keywords = ["serde", "serialization"]
+include = ["Cargo.toml", "src/**/*.rs"]
+
+[dependencies]
+serde = { version = "0.7.11", path = "../serde" }
--- a/serde_test/src/assert.rs
+++ b/serde_test/src/assert.rs
@ -0,0 +1,54 @@
+use serde::{Serialize, Deserialize};
+
+use de::Deserializer;
+use error::Error;
+use ser::Serializer;
+use token::Token;
+
+use std::fmt::Debug;
+
+pub fn assert_tokens<T>(value: &T, tokens: &[Token<'static>])
+    where T: Serialize + Deserialize + PartialEq + Debug,
+{
+    assert_ser_tokens(value, tokens);
+    assert_de_tokens(value, tokens);
+}
+
+pub fn assert_ser_tokens<T>(value: &T, tokens: &[Token])
+    where T: Serialize,
+{
+    let mut ser = Serializer::new(tokens.iter());
+    assert_eq!(Serialize::serialize(value, &mut ser), Ok(()));
+    assert_eq!(ser.next_token(), None);
+}
+
+/// Expect an error serializing `T`.
+pub fn assert_ser_tokens_error<T>(value: &T, tokens: &[Token], error: Error)
+    where T: Serialize + PartialEq + Debug,
+{
+    let mut ser = Serializer::new(tokens.iter());
+    let v: Result<(), Error> = Serialize::serialize(value, &mut ser);
+    assert_eq!(v.as_ref(), Err(&error));
+    assert_eq!(ser.next_token(), None);
+}
+
+pub fn assert_de_tokens<T>(value: &T, tokens: &[Token<'static>])
+    where T: Deserialize + PartialEq + Debug,
+{
+    let mut de = Deserializer::new(tokens.to_vec().into_iter());
+    let v: Result<T, Error> = Deserialize::deserialize(&mut de);
+    assert_eq!(v.as_ref(), Ok(value));
+    assert_eq!(de.next_token(), None);
+}
+
+/// Expect an error deserializing tokens into a `T`.
+pub fn assert_de_tokens_error<T>(tokens: &[Token<'static>], error: Error)
+    where T: Deserialize + PartialEq + Debug,
+{
+    let mut de = Deserializer::new(tokens.to_vec().into_iter());
+    let v: Result<T, Error> = Deserialize::deserialize(&mut de);
+    assert_eq!(v, Err(error));
+    // There may be one token left if a peek caused the error
+    de.next_token();
+    assert_eq!(de.next_token(), None);
+}
--- a/serde_tests/tests/token.rs
+++ b/serde_tests/tests/token.rs
--- a/serde_test/src/error.rs
+++ b/serde_test/src/error.rs
@ -0,0 +1,87 @@
+use std::{error, fmt};
+
+use serde::{ser, de};
+
+use token::Token;
+
+#[derive(Clone, PartialEq, Debug)]
+pub enum Error {
+    // Shared
+    Custom(String),
+    InvalidValue(String),
+
+    // De
+    EndOfStream,
+    InvalidType(de::Type),
+    InvalidLength(usize),
+    UnknownVariant(String),
+    UnknownField(String),
+    MissingField(&'static str),
+    DuplicateField(&'static str),
+    InvalidName(&'static str),
+    UnexpectedToken(Token<'static>),
+}
+
+impl ser::Error for Error {
+    fn custom<T: Into<String>>(msg: T) -> Error {
+        Error::Custom(msg.into())
+    }
+
+    fn invalid_value(msg: &str) -> Error {
+        Error::InvalidValue(msg.to_owned())
+    }
+}
+
+impl de::Error for Error {
+    fn custom<T: Into<String>>(msg: T) -> Error {
+        Error::Custom(msg.into())
+    }
+
+    fn end_of_stream() -> Error {
+        Error::EndOfStream
+    }
+
+    fn invalid_type(ty: de::Type) -> Error {
+        Error::InvalidType(ty)
+    }
+
+    fn invalid_value(msg: &str) -> Error {
+        Error::InvalidValue(msg.to_owned())
+    }
+
+    fn invalid_length(len: usize) -> Error {
+        Error::InvalidLength(len)
+    }
+
+    fn unknown_variant(variant: &str) -> Error {
+        Error::UnknownVariant(variant.to_owned())
+    }
+
+    fn unknown_field(field: &str) -> Error {
+        Error::UnknownField(field.to_owned())
+    }
+
+    fn missing_field(field: &'static str) -> Error {
+        Error::MissingField(field)
+    }
+
+    fn duplicate_field(field: &'static str) -> Error {
+        Error::DuplicateField(field)
+    }
+}
+
+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 Error"
+    }
+
+    fn cause(&self) -> Option<&error::Error> {
+        None
+    }
+}
--- a/serde_test/src/lib.rs
+++ b/serde_test/src/lib.rs
@ -0,0 +1,22 @@
+extern crate serde;
+
+mod assert;
+pub use assert::{
+    assert_tokens,
+    assert_ser_tokens,
+    assert_ser_tokens_error,
+    assert_de_tokens,
+    assert_de_tokens_error,
+};
+
+mod ser;
+pub use ser::Serializer;
+
+mod de;
+pub use de::Deserializer;
+
+mod token;
+pub use token::Token;
+
+mod error;
+pub use error::Error;
--- a/serde_test/src/ser.rs
+++ b/serde_test/src/ser.rs
@ -0,0 +1,350 @@
+use std::marker::PhantomData;
+
+use serde::ser::{
+    self,
+    MapVisitor,
+    SeqVisitor,
+    Serialize,
+};
+
+use error::Error;
+use token::Token;
+
+pub struct Serializer<'a, I>
+    where I: Iterator<Item=&'a Token<'a>>,
+{
+    tokens: I,
+    phantom: PhantomData<&'a Token<'a>>,
+}
+
+impl<'a, I> Serializer<'a, I>
+    where I: Iterator<Item=&'a Token<'a>>,
+{
+    pub fn new(tokens: I) -> Serializer<'a, I> {
+        Serializer {
+            tokens: tokens,
+            phantom: PhantomData,
+        }
+    }
+
+    pub fn next_token(&mut self) -> Option<&'a Token<'a>> {
+        self.tokens.next()
+    }
+
+    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<(), Error>
+        where V: SeqVisitor
+    {
+        while let Some(()) = try!(visitor.visit(self)) { }
+
+        assert_eq!(self.tokens.next(), Some(&Token::SeqEnd));
+
+        Ok(())
+    }
+
+    fn visit_map<V>(&mut self, mut visitor: V) -> Result<(), Error>
+        where V: MapVisitor
+    {
+        while let Some(()) = try!(visitor.visit(self)) { }
+
+        assert_eq!(self.tokens.next(), Some(&Token::MapEnd));
+
+        Ok(())
+    }
+}
+
+impl<'a, I> ser::Serializer for Serializer<'a, I>
+    where I: Iterator<Item=&'a Token<'a>>,
+{
+    type Error = Error;
+
+    fn serialize_unit(&mut self) -> Result<(), Error> {
+        assert_eq!(self.tokens.next(), Some(&Token::Unit));
+        Ok(())
+    }
+
+    fn serialize_newtype_variant<T>(&mut self,
+                                name: &str,
+                                _variant_index: usize,
+                                variant: &str,
+                                value: T) -> Result<(), Error>
+        where T: Serialize,
+    {
+        assert_eq!(self.tokens.next(), Some(&Token::EnumNewType(name, variant)));
+        value.serialize(self)
+    }
+
+    fn serialize_unit_struct(&mut self, name: &str) -> Result<(), Error> {
+        assert_eq!(self.tokens.next(), Some(&Token::UnitStruct(name)));
+        Ok(())
+    }
+
+    fn serialize_unit_variant(&mut self,
+                          name: &str,
+                          _variant_index: usize,
+                          variant: &str) -> Result<(), Error> {
+        assert_eq!(self.tokens.next(), Some(&Token::EnumUnit(name, variant)));
+
+        Ok(())
+    }
+
+    fn serialize_bool(&mut self, v: bool) -> Result<(), Error> {
+        assert_eq!(self.tokens.next(), Some(&Token::Bool(v)));
+        Ok(())
+    }
+
+    fn serialize_isize(&mut self, v: isize) -> Result<(), Error> {
+        assert_eq!(self.tokens.next(), Some(&Token::Isize(v)));
+        Ok(())
+    }
+
+    fn serialize_i8(&mut self, v: i8) -> Result<(), Error> {
+        assert_eq!(self.tokens.next(), Some(&Token::I8(v)));
+        Ok(())
+    }
+
+    fn serialize_i16(&mut self, v: i16) -> Result<(), Error> {
+        assert_eq!(self.tokens.next(), Some(&Token::I16(v)));
+        Ok(())
+    }
+
+    fn serialize_i32(&mut self, v: i32) -> Result<(), Error> {
+        assert_eq!(self.tokens.next(), Some(&Token::I32(v)));
+        Ok(())
+    }
+
+    fn serialize_i64(&mut self, v: i64) -> Result<(), Error> {
+        assert_eq!(self.tokens.next(), Some(&Token::I64(v)));
+        Ok(())
+    }
+
+    fn serialize_usize(&mut self, v: usize) -> Result<(), Error> {
+        assert_eq!(self.tokens.next(), Some(&Token::Usize(v)));
+        Ok(())
+    }
+
+    fn serialize_u8(&mut self, v: u8) -> Result<(), Error> {
+        assert_eq!(self.tokens.next(), Some(&Token::U8(v)));
+        Ok(())
+    }
+
+    fn serialize_u16(&mut self, v: u16) -> Result<(), Error> {
+        assert_eq!(self.tokens.next(), Some(&Token::U16(v)));
+        Ok(())
+    }
+
+    fn serialize_u32(&mut self, v: u32) -> Result<(), Error> {
+        assert_eq!(self.tokens.next(), Some(&Token::U32(v)));
+        Ok(())
+    }
+
+    fn serialize_u64(&mut self, v: u64) -> Result<(), Error> {
+        assert_eq!(self.tokens.next(), Some(&Token::U64(v)));
+        Ok(())
+    }
+
+    fn serialize_f32(&mut self, v: f32) -> Result<(), Error> {
+        assert_eq!(self.tokens.next(), Some(&Token::F32(v)));
+        Ok(())
+    }
+
+    fn serialize_f64(&mut self, v: f64) -> Result<(), Error> {
+        assert_eq!(self.tokens.next(), Some(&Token::F64(v)));
+        Ok(())
+    }
+
+    fn serialize_char(&mut self, v: char) -> Result<(), Error> {
+        assert_eq!(self.tokens.next(), Some(&Token::Char(v)));
+        Ok(())
+    }
+
+    fn serialize_str(&mut self, v: &str) -> Result<(), Error> {
+        assert_eq!(self.tokens.next(), Some(&Token::Str(v)));
+        Ok(())
+    }
+
+    fn serialize_none(&mut self) -> Result<(), Error> {
+        assert_eq!(self.tokens.next(), Some(&Token::Option(false)));
+        Ok(())
+    }
+
+    fn serialize_some<V>(&mut self, value: V) -> Result<(), Error>
+        where V: Serialize,
+    {
+        assert_eq!(self.tokens.next(), Some(&Token::Option(true)));
+        value.serialize(self)
+    }
+
+
+    fn serialize_seq<V>(&mut self, visitor: V) -> Result<(), Error>
+        where V: SeqVisitor
+    {
+        let len = visitor.len();
+
+        assert_eq!(self.tokens.next(), Some(&Token::SeqStart(len)));
+
+        self.visit_seq(visitor)
+    }
+
+    fn serialize_fixed_size_array<V>(&mut self, visitor: V) -> Result<(), Error>
+        where V: SeqVisitor
+    {
+        let len = visitor.len().expect("arrays must have a length");
+
+        assert_eq!(self.tokens.next(), Some(&Token::SeqArrayStart(len)));
+
+        self.visit_seq(visitor)
+    }
+
+    fn serialize_seq_elt<T>(&mut self, value: T) -> Result<(), Error>
+        where T: Serialize
+    {
+        assert_eq!(self.tokens.next(), Some(&Token::SeqSep));
+        value.serialize(self)
+    }
+
+    fn serialize_tuple<V>(&mut self, mut visitor: V) -> Result<(), Error>
+        where V: SeqVisitor
+    {
+        let len = visitor.len().expect("arrays must have a length");
+
+        assert_eq!(self.tokens.next(), Some(&Token::TupleStart(len)));
+
+        while let Some(()) = try!(visitor.visit(self)) { }
+
+        assert_eq!(self.tokens.next(), Some(&Token::TupleEnd));
+
+        Ok(())
+    }
+
+    fn serialize_tuple_elt<T>(&mut self, value: T) -> Result<(), Error>
+        where T: Serialize
+    {
+        assert_eq!(self.tokens.next(), Some(&Token::TupleSep));
+        value.serialize(self)
+    }
+
+    fn serialize_newtype_struct<T>(&mut self,
+                               name: &'static str,
+                               value: T) -> Result<(), Error>
+        where T: Serialize,
+    {
+        assert_eq!(self.tokens.next(), Some(&Token::StructNewType(name)));
+        value.serialize(self)
+    }
+
+    fn serialize_tuple_struct<V>(&mut self, name: &str, mut visitor: V) -> Result<(), Error>
+        where V: SeqVisitor
+    {
+        let len = visitor.len();
+
+        assert_eq!(self.tokens.next(), Some(&Token::TupleStructStart(name, len)));
+
+        while let Some(()) = try!(visitor.visit(self)) { }
+
+        assert_eq!(self.tokens.next(), Some(&Token::TupleStructEnd));
+
+        Ok(())
+    }
+
+    fn serialize_tuple_struct_elt<T>(&mut self, value: T) -> Result<(), Error>
+        where T: Serialize,
+    {
+        assert_eq!(self.tokens.next(), Some(&Token::TupleStructSep));
+        value.serialize(self)
+    }
+
+    fn serialize_tuple_variant<V>(&mut self,
+                                  name: &str,
+                                  _variant_index: usize,
+                                  variant: &str,
+                                  mut visitor: V) -> Result<(), Error>
+        where V: SeqVisitor
+    {
+        let len = visitor.len();
+
+        assert_eq!(self.tokens.next(), Some(&Token::EnumSeqStart(name, variant, len)));
+
+        while let Some(()) = try!(visitor.visit(self)) { }
+
+        assert_eq!(self.tokens.next(), Some(&Token::EnumSeqEnd));
+
+        Ok(())
+    }
+
+    fn serialize_tuple_variant_elt<T>(&mut self, value: T) -> Result<(), Error>
+        where T: Serialize,
+    {
+        assert_eq!(self.tokens.next(), Some(&Token::EnumSeqSep));
+        value.serialize(self)
+    }
+
+    fn serialize_map<V>(&mut self, visitor: V) -> Result<(), Error>
+        where V: MapVisitor
+    {
+        let len = visitor.len();
+
+        assert_eq!(self.tokens.next(), Some(&Token::MapStart(len)));
+
+        self.visit_map(visitor)
+    }
+
+    fn serialize_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), Error>
+        where K: Serialize,
+              V: Serialize,
+    {
+        assert_eq!(self.tokens.next(), Some(&Token::MapSep));
+
+        try!(key.serialize(self));
+        value.serialize(self)
+    }
+
+    fn serialize_struct<V>(&mut self, name: &str, mut visitor: V) -> Result<(), Error>
+        where V: MapVisitor
+    {
+        let len = visitor.len();
+
+        assert_eq!(self.tokens.next(), Some(&Token::StructStart(name, len)));
+
+        while let Some(()) = try!(visitor.visit(self)) { }
+
+        assert_eq!(self.tokens.next(), Some(&Token::StructEnd));
+
+        Ok(())
+    }
+
+    fn serialize_struct_elt<T>(&mut self, key: &'static str, value: T) -> Result<(), Error>
+        where T: Serialize,
+    {
+        assert_eq!(self.tokens.next(), Some(&Token::StructSep));
+
+        try!(key.serialize(self));
+        value.serialize(self)
+    }
+
+    fn serialize_struct_variant<V>(&mut self,
+                                   name: &str,
+                                   _variant_index: usize,
+                                   variant: &str,
+                                   mut visitor: V) -> Result<(), Error>
+        where V: MapVisitor
+    {
+        let len = visitor.len();
+
+        assert_eq!(self.tokens.next(), Some(&Token::EnumMapStart(name, variant, len)));
+
+        while let Some(()) = try!(visitor.visit(self)) { }
+
+        assert_eq!(self.tokens.next(), Some(&Token::EnumMapEnd));
+
+        Ok(())
+    }
+
+    fn serialize_struct_variant_elt<T>(&mut self, key: &'static str, value: T) -> Result<(), Error>
+        where T: Serialize,
+    {
+        assert_eq!(self.tokens.next(), Some(&Token::EnumMapSep));
+
+        try!(key.serialize(self));
+        value.serialize(self)
+    }
+}
--- a/serde_test/src/token.rs
+++ b/serde_test/src/token.rs
@ -0,0 +1,60 @@
+#[derive(Clone, PartialEq, Debug)]
+pub enum Token<'a> {
+    Bool(bool),
+    Isize(isize),
+    I8(i8),
+    I16(i16),
+    I32(i32),
+    I64(i64),
+    Usize(usize),
+    U8(u8),
+    U16(u16),
+    U32(u32),
+    U64(u64),
+    F32(f32),
+    F64(f64),
+    Char(char),
+    Str(&'a str),
+    String(String),
+    Bytes(&'a [u8]),
+
+    Option(bool),
+
+    Unit,
+    UnitStruct(&'a str),
+
+    StructNewType(&'a str),
+
+    EnumStart(&'a str),
+    EnumUnit(&'a str, &'a str),
+    EnumNewType(&'a str, &'a str),
+
+    SeqStart(Option<usize>),
+    SeqArrayStart(usize),
+    SeqSep,
+    SeqEnd,
+
+    TupleStart(usize),
+    TupleSep,
+    TupleEnd,
+
+    TupleStructStart(&'a str, Option<usize>),
+    TupleStructSep,
+    TupleStructEnd,
+
+    MapStart(Option<usize>),
+    MapSep,
+    MapEnd,
+
+    StructStart(&'a str, Option<usize>),
+    StructSep,
+    StructEnd,
+
+    EnumSeqStart(&'a str, &'a str, Option<usize>),
+    EnumSeqSep,
+    EnumSeqEnd,
+
+    EnumMapStart(&'a str, &'a str, Option<usize>),
+    EnumMapSep,
+    EnumMapEnd,
+}
--- a/serde_tests/Cargo.toml
+++ b/serde_tests/Cargo.toml
@ -1,5 +1,5 @@
 [package]
-name = "serde_tests"
+name = "serde_testing"
 version = "0.7.11"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
@ -20,6 +20,7 @@ serde_codegen = { version = "*", path = "../serde_codegen", features = ["with-sy
 fnv = "1.0"
 rustc-serialize = "^0.3.16"
 serde = { version = "*", path = "../serde" }
+serde_test = { version = "*", path = "../serde_test" }

 [dependencies]
 clippy = { version = "^0.*", optional = true }
--- a/serde_tests/benches/bench.rs
+++ b/serde_tests/benches/bench.rs
--- a/serde_tests/benches/bench.rs.in
+++ b/serde_tests/benches/bench.rs.in
--- a/serde_tests/benches/bench_enum.rs
+++ b/serde_tests/benches/bench_enum.rs
--- a/serde_tests/benches/bench_map.rs
+++ b/serde_tests/benches/bench_map.rs
--- a/serde_tests/benches/bench_struct.rs
+++ b/serde_tests/benches/bench_struct.rs
--- a/serde_tests/benches/bench_vec.rs
+++ b/serde_tests/benches/bench_vec.rs
--- a/serde_tests/build.rs
+++ b/serde_tests/build.rs
--- a/serde_tests/tests/macros.rs
+++ b/serde_tests/tests/macros.rs
@ -5,7 +5,7 @@ macro_rules! declare_ser_tests {
            #[test]
            fn $name() {
                $(
-                    ::token::assert_ser_tokens(&$value, $tokens);
+                    assert_ser_tokens(&$value, $tokens);
                )+
            }
        )+
--- a/serde_tests/tests/test.rs
+++ b/serde_tests/tests/test.rs
--- a/serde_tests/tests/test.rs.in
+++ b/serde_tests/tests/test.rs.in
@ -1,8 +1,6 @@
 #[macro_use]
 mod macros;

-mod token;
-
 mod test_annotations;
 mod test_bytes;
 mod test_de;
--- a/serde_tests/tests/test_annotations.rs
+++ b/serde_tests/tests/test_annotations.rs
@ -1,7 +1,8 @@
 extern crate serde;
 use self::serde::{Serialize, Serializer, Deserialize, Deserializer};

-use token::{
+extern crate serde_test;
+use self::serde_test::{
    Error,
    Token,
    assert_tokens,
@ -80,7 +81,7 @@ struct DefaultStruct<A, B, C, D, E>
 fn test_default_struct() {
    assert_de_tokens(
        &DefaultStruct { a1: 1, a2: 2, a3: 3, a4: 0, a5: 123 },
-        vec![
+        &[
            Token::StructStart("DefaultStruct", Some(3)),

            Token::StructSep,
@ -109,7 +110,7 @@ fn test_default_struct() {

    assert_de_tokens(
        &DefaultStruct { a1: 1, a2: 0, a3: 123, a4: 0, a5: 123 },
-        vec![
+        &[
            Token::StructStart("DefaultStruct", Some(1)),

            Token::StructSep,
@ -143,7 +144,7 @@ enum DefaultEnum<A, B, C, D, E>
 fn test_default_enum() {
    assert_de_tokens(
        &DefaultEnum::Struct { a1: 1, a2: 2, a3: 3, a4: 0, a5: 123 },
-        vec![
+        &[
            Token::EnumMapStart("DefaultEnum", "Struct", Some(5)),

            Token::EnumMapSep,
@ -172,7 +173,7 @@ fn test_default_enum() {

    assert_de_tokens(
        &DefaultEnum::Struct { a1: 1, a2: 0, a3: 123, a4: 0, a5: 123 },
-        vec![
+        &[
            Token::EnumMapStart("DefaultEnum", "Struct", Some(5)),

            Token::EnumMapSep,
@ -206,7 +207,7 @@ struct ContainsNoStdDefault<A: MyDefault> {
 fn test_no_std_default() {
    assert_de_tokens(
        &ContainsNoStdDefault { a: NoStdDefault(123) },
-        vec![
+        &[
            Token::StructStart("ContainsNoStdDefault", Some(1)),
            Token::StructEnd,
        ]
@ -214,7 +215,7 @@ fn test_no_std_default() {

    assert_de_tokens(
        &ContainsNoStdDefault { a: NoStdDefault(8) },
-        vec![
+        &[
            Token::StructStart("ContainsNoStdDefault", Some(1)),

            Token::StructSep,
@ -279,7 +280,7 @@ fn test_elt_not_deserialize() {
            c: NotDeserializeStruct(123),
            e: NotDeserializeEnum::Trouble,
        },
-        vec![
+        &[
            Token::StructStart("ContainsNotDeserialize", Some(3)),
            Token::StructEnd,
        ]
@ -297,7 +298,7 @@ fn test_ignore_unknown() {
    // 'Default' allows unknown. Basic smoke test of ignore...
    assert_de_tokens(
        &DefaultStruct { a1: 1, a2: 2, a3: 3, a4: 0, a5: 123 },
-        vec![
+        &[
            Token::StructStart("DefaultStruct", Some(5)),

            Token::StructSep,
@ -332,7 +333,7 @@ fn test_ignore_unknown() {
    );

    assert_de_tokens_error::<DenyUnknown>(
-        vec![
+        &[
            Token::StructStart("DenyUnknown", Some(2)),

            Token::StructSep,
@ -341,11 +342,8 @@ fn test_ignore_unknown() {

            Token::StructSep,
            Token::Str("whoops"),
-            Token::I32(2),
-
-            Token::StructEnd,
        ],
-        Error::UnknownFieldError("whoops".to_owned())
+        Error::UnknownField("whoops".to_owned())
    );
 }

@ -369,7 +367,7 @@ struct RenameStructSerializeDeserialize {
 fn test_rename_struct() {
    assert_tokens(
        &RenameStruct { a1: 1, a2: 2 },
-        vec![
+        &[
            Token::StructStart("Superhero", Some(2)),

            Token::StructSep,
@ -403,7 +401,7 @@ fn test_rename_struct() {

    assert_de_tokens(
        &RenameStructSerializeDeserialize { a1: 1, a2: 2 },
-        vec![
+        &[
            Token::StructStart("SuperheroDe", Some(2)),

            Token::StructSep,
@ -451,14 +449,14 @@ enum RenameEnumSerializeDeserialize<A> {
 fn test_rename_enum() {
    assert_tokens(
        &RenameEnum::Batman,
-        vec![
+        &[
            Token::EnumUnit("Superhero", "bruce_wayne"),
        ]
    );

    assert_tokens(
        &RenameEnum::Superman(0),
-        vec![
+        &[
            Token::EnumNewType("Superhero", "clark_kent"),
            Token::I8(0),
        ]
@ -466,7 +464,7 @@ fn test_rename_enum() {

    assert_tokens(
        &RenameEnum::WonderWoman(0, 1),
-        vec![
+        &[
            Token::EnumSeqStart("Superhero", "diana_prince", Some(2)),

            Token::EnumSeqSep,
@ -481,7 +479,7 @@ fn test_rename_enum() {

    assert_tokens(
        &RenameEnum::Flash { a: 1 },
-        vec![
+        &[
            Token::EnumMapStart("Superhero", "barry_allan", Some(1)),

            Token::EnumMapSep,
@ -517,7 +515,7 @@ fn test_rename_enum() {
            a: 0,
            b: String::new(),
        },
-        vec![
+        &[
            Token::EnumMapStart("SuperheroDe", "jason_todd", Some(2)),

            Token::EnumMapSep,
@ -807,7 +805,7 @@ fn test_deserialize_with_struct() {
            a: 1,
            b: 2,
        },
-        vec![
+        &[
            Token::StructStart("DeserializeWithStruct", Some(2)),

            Token::StructSep,
@ -827,7 +825,7 @@ fn test_deserialize_with_struct() {
            a: 1,
            b: 123,
        },
-        vec![
+        &[
            Token::StructStart("DeserializeWithStruct", Some(2)),

            Token::StructSep,
@ -859,7 +857,7 @@ fn test_deserialize_with_enum() {
            a: 1,
            b: 2,
        },
-        vec![
+        &[
            Token::EnumMapStart("DeserializeWithEnum", "Struct", Some(2)),

            Token::EnumMapSep,
@ -879,7 +877,7 @@ fn test_deserialize_with_enum() {
            a: 1,
            b: 123,
        },
-        vec![
+        &[
            Token::EnumMapStart("DeserializeWithEnum", "Struct", Some(2)),

            Token::EnumMapSep,
@ -898,7 +896,7 @@ fn test_deserialize_with_enum() {
 #[test]
 fn test_missing_renamed_field_struct() {
    assert_de_tokens_error::<RenameStruct>(
-        vec![
+        &[
            Token::StructStart("Superhero", Some(2)),

            Token::StructSep,
@ -907,11 +905,11 @@ fn test_missing_renamed_field_struct() {

            Token::StructEnd,
        ],
-        Error::MissingFieldError("a3"),
+        Error::MissingField("a3"),
    );

    assert_de_tokens_error::<RenameStructSerializeDeserialize>(
-        vec![
+        &[
            Token::StructStart("SuperheroDe", Some(2)),

            Token::StructSep,
@ -920,23 +918,23 @@ fn test_missing_renamed_field_struct() {

            Token::StructEnd,
        ],
-        Error::MissingFieldError("a5"),
+        Error::MissingField("a5"),
    );
 }

 #[test]
 fn test_missing_renamed_field_enum() {
    assert_de_tokens_error::<RenameEnum>(
-        vec![
+        &[
            Token::EnumMapStart("Superhero", "barry_allan", Some(1)),

            Token::EnumMapEnd,
        ],
-        Error::MissingFieldError("b"),
+        Error::MissingField("b"),
    );

    assert_de_tokens_error::<RenameEnumSerializeDeserialize<i8>>(
-        vec![
+        &[
            Token::EnumMapStart("SuperheroDe", "jason_todd", Some(2)),

            Token::EnumMapSep,
@ -945,6 +943,6 @@ fn test_missing_renamed_field_enum() {

            Token::EnumMapEnd,
        ],
-        Error::MissingFieldError("d"),
+        Error::MissingField("d"),
    );
 }
--- a/serde_tests/tests/test_bytes.rs
+++ b/serde_tests/tests/test_bytes.rs
--- a/serde_tests/tests/test_de.rs
+++ b/serde_tests/tests/test_de.rs
@ -2,14 +2,17 @@ use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::net;
 use std::path::PathBuf;

+extern crate serde;
+use self::serde::Deserialize;
+
 extern crate fnv;
 use self::fnv::FnvHasher;

-use token::{
+extern crate serde_test;
+use self::serde_test::{
    Error,
    Token,
    assert_de_tokens,
-    assert_de_tokens_ignore,
    assert_de_tokens_error,
 };

@ -73,107 +76,147 @@ macro_rules! declare_error_tests {
    }
 }

+fn assert_de_tokens_ignore(ignorable_tokens: &[Token<'static>]) {
+    #[derive(PartialEq, Debug, Deserialize)]
+    struct IgnoreBase {
+        a: i32,
+    }
+ 
+    let expected = IgnoreBase{a: 1};
+ 
+    // Embed the tokens to be ignored in the normal token
+    // stream for an IgnoreBase type
+    let concated_tokens : Vec<Token<'static>> = vec![
+            Token::MapStart(Some(2)),
+                Token::MapSep,
+                Token::Str("a"),
+                Token::I32(1),
+ 
+                Token::MapSep,
+                Token::Str("ignored")
+        ]
+        .into_iter()
+        .chain(ignorable_tokens.to_vec().into_iter())
+        .chain(vec![
+            Token::MapEnd,
+        ].into_iter())
+        .collect();
+ 
+    let mut de = serde_test::Deserializer::new(concated_tokens.into_iter());
+    let v: Result<IgnoreBase, Error> = Deserialize::deserialize(&mut de);
+ 
+    // We run this test on every token stream for convenience, but
+    // some token streams don't make sense embedded as a map value,
+    // so we ignore those. SyntaxError is the real sign of trouble.
+    if let Err(Error::UnexpectedToken(_)) = v {
+        return;
+    }
+ 
+    assert_eq!(v.as_ref(), Ok(&expected));
+    assert_eq!(de.next_token(), None);
+}
+
 //////////////////////////////////////////////////////////////////////////

 declare_tests! {
    test_bool {
-        true => vec![Token::Bool(true)],
-        false => vec![Token::Bool(false)],
+        true => &[Token::Bool(true)],
+        false => &[Token::Bool(false)],
    }
    test_isize {
-        0isize => vec![Token::Isize(0)],
-        0isize => vec![Token::I8(0)],
-        0isize => vec![Token::I16(0)],
-        0isize => vec![Token::I32(0)],
-        0isize => vec![Token::I64(0)],
-        0isize => vec![Token::Usize(0)],
-        0isize => vec![Token::U8(0)],
-        0isize => vec![Token::U16(0)],
-        0isize => vec![Token::U32(0)],
-        0isize => vec![Token::U64(0)],
-        0isize => vec![Token::F32(0.)],
-        0isize => vec![Token::F64(0.)],
+        0isize => &[Token::Isize(0)],
+        0isize => &[Token::I8(0)],
+        0isize => &[Token::I16(0)],
+        0isize => &[Token::I32(0)],
+        0isize => &[Token::I64(0)],
+        0isize => &[Token::Usize(0)],
+        0isize => &[Token::U8(0)],
+        0isize => &[Token::U16(0)],
+        0isize => &[Token::U32(0)],
+        0isize => &[Token::U64(0)],
+        0isize => &[Token::F32(0.)],
+        0isize => &[Token::F64(0.)],
    }
    test_ints {
-        0isize => vec![Token::Isize(0)],
-        0i8 => vec![Token::I8(0)],
-        0i16 => vec![Token::I16(0)],
-        0i32 => vec![Token::I32(0)],
-        0i64 => vec![Token::I64(0)],
+        0isize => &[Token::Isize(0)],
+        0i8 => &[Token::I8(0)],
+        0i16 => &[Token::I16(0)],
+        0i32 => &[Token::I32(0)],
+        0i64 => &[Token::I64(0)],
    }
    test_uints {
-        0usize => vec![Token::Usize(0)],
-        0u8 => vec![Token::U8(0)],
-        0u16 => vec![Token::U16(0)],
-        0u32 => vec![Token::U32(0)],
-        0u64 => vec![Token::U64(0)],
+        0usize => &[Token::Usize(0)],
+        0u8 => &[Token::U8(0)],
+        0u16 => &[Token::U16(0)],
+        0u32 => &[Token::U32(0)],
+        0u64 => &[Token::U64(0)],
    }
    test_floats {
-        0f32 => vec![Token::F32(0.)],
-        0f64 => vec![Token::F64(0.)],
+        0f32 => &[Token::F32(0.)],
+        0f64 => &[Token::F64(0.)],
    }
    test_char {
-        'a' => vec![Token::Char('a')],
-        'a' => vec![Token::Str("a")],
-        'a' => vec![Token::String("a".to_owned())],
+        'a' => &[Token::Char('a')],
+        'a' => &[Token::Str("a")],
+        'a' => &[Token::String("a".to_owned())],
    }
    test_string {
-        "abc".to_owned() => vec![Token::Str("abc")],
-        "abc".to_owned() => vec![Token::String("abc".to_owned())],
-        "a".to_owned() => vec![Token::Char('a')],
+        "abc".to_owned() => &[Token::Str("abc")],
+        "abc".to_owned() => &[Token::String("abc".to_owned())],
+        "a".to_owned() => &[Token::Char('a')],
    }
    test_option {
-        None::<i32> => vec![Token::Unit],
-        None::<i32> => vec![Token::Option(false)],
-        Some(1) => vec![Token::I32(1)],
-        Some(1) => vec![
+        None::<i32> => &[Token::Unit],
+        None::<i32> => &[Token::Option(false)],
+        Some(1) => &[Token::I32(1)],
+        Some(1) => &[
            Token::Option(true),
            Token::I32(1),
        ],
    }
    test_result {
-        Ok::<i32, i32>(0) => vec![
+        Ok::<i32, i32>(0) => &[
            Token::EnumStart("Result"),
            Token::Str("Ok"),
            Token::I32(0),
        ],
-        Err::<i32, i32>(1) => vec![
+        Err::<i32, i32>(1) => &[
            Token::EnumStart("Result"),
            Token::Str("Err"),
            Token::I32(1),
        ],
    }
    test_unit {
-        () => vec![Token::Unit],
-        () => vec![
+        () => &[Token::Unit],
+        () => &[
            Token::SeqStart(Some(0)),
            Token::SeqEnd,
        ],
-        () => vec![
+        () => &[
            Token::SeqStart(None),
            Token::SeqEnd,
        ],
-        () => vec![
+        () => &[
            Token::TupleStructStart("Anything", Some(0)),
            Token::SeqEnd,
        ],
    }
    test_unit_struct {
-        UnitStruct => vec![Token::Unit],
-        UnitStruct => vec![
+        UnitStruct => &[Token::Unit],
+        UnitStruct => &[
            Token::UnitStruct("UnitStruct"),
        ],
-        UnitStruct => vec![
+        UnitStruct => &[
            Token::SeqStart(Some(0)),
            Token::SeqEnd,
        ],
-        UnitStruct => vec![
+        UnitStruct => &[
            Token::SeqStart(None),
            Token::SeqEnd,
        ],
    }
    test_tuple_struct {
-        TupleStruct(1, 2, 3) => vec![
+        TupleStruct(1, 2, 3) => &[
            Token::SeqStart(Some(3)),
                Token::SeqSep,
                Token::I32(1),
@ -185,7 +228,7 @@ declare_tests! {
                Token::I32(3),
            Token::SeqEnd,
        ],
-        TupleStruct(1, 2, 3) => vec![
+        TupleStruct(1, 2, 3) => &[
            Token::SeqStart(None),
                Token::SeqSep,
                Token::I32(1),
@ -197,7 +240,7 @@ declare_tests! {
                Token::I32(3),
            Token::SeqEnd,
        ],
-        TupleStruct(1, 2, 3) => vec![
+        TupleStruct(1, 2, 3) => &[
            Token::TupleStructStart("TupleStruct", Some(3)),
                Token::TupleStructSep,
                Token::I32(1),
@ -209,7 +252,7 @@ declare_tests! {
                Token::I32(3),
            Token::TupleStructEnd,
        ],
-        TupleStruct(1, 2, 3) => vec![
+        TupleStruct(1, 2, 3) => &[
            Token::TupleStructStart("TupleStruct", None),
                Token::TupleStructSep,
                Token::I32(1),
@ -223,14 +266,14 @@ declare_tests! {
        ],
    }
    test_btreeset {
-        BTreeSet::<isize>::new() => vec![
+        BTreeSet::<isize>::new() => &[
            Token::Unit,
        ],
-        BTreeSet::<isize>::new() => vec![
+        BTreeSet::<isize>::new() => &[
            Token::SeqStart(Some(0)),
            Token::SeqEnd,
        ],
-        btreeset![btreeset![], btreeset![1], btreeset![2, 3]] => vec![
+        btreeset![btreeset![], btreeset![1], btreeset![2, 3]] => &[
            Token::SeqStart(Some(3)),
                Token::SeqSep,
                Token::SeqStart(Some(0)),
@ -252,23 +295,23 @@ declare_tests! {
                Token::SeqEnd,
            Token::SeqEnd,
        ],
-        BTreeSet::<isize>::new() => vec![
+        BTreeSet::<isize>::new() => &[
            Token::UnitStruct("Anything"),
        ],
-        BTreeSet::<isize>::new() => vec![
+        BTreeSet::<isize>::new() => &[
            Token::TupleStructStart("Anything", Some(0)),
            Token::SeqEnd,
        ],
    }
    test_hashset {
-        HashSet::<isize>::new() => vec![
+        HashSet::<isize>::new() => &[
            Token::Unit,
        ],
-        HashSet::<isize>::new() => vec![
+        HashSet::<isize>::new() => &[
            Token::SeqStart(Some(0)),
            Token::SeqEnd,
        ],
-        hashset![1, 2, 3] => vec![
+        hashset![1, 2, 3] => &[
            Token::SeqStart(Some(3)),
                Token::SeqSep,
                Token::I32(1),
@ -280,14 +323,14 @@ declare_tests! {
                Token::I32(3),
            Token::SeqEnd,
        ],
-        HashSet::<isize>::new() => vec![
+        HashSet::<isize>::new() => &[
            Token::UnitStruct("Anything"),
        ],
-        HashSet::<isize>::new() => vec![
+        HashSet::<isize>::new() => &[
            Token::TupleStructStart("Anything", Some(0)),
            Token::SeqEnd,
        ],
-        hashset![FnvHasher @ 1, 2, 3] => vec![
+        hashset![FnvHasher @ 1, 2, 3] => &[
            Token::SeqStart(Some(3)),
                Token::SeqSep,
                Token::I32(1),
@ -301,14 +344,14 @@ declare_tests! {
        ],
    }
    test_vec {
-        Vec::<isize>::new() => vec![
+        Vec::<isize>::new() => &[
            Token::Unit,
        ],
-        Vec::<isize>::new() => vec![
+        Vec::<isize>::new() => &[
            Token::SeqStart(Some(0)),
            Token::SeqEnd,
        ],
-        vec![vec![], vec![1], vec![2, 3]] => vec![
+        vec![vec![], vec![1], vec![2, 3]] => &[
            Token::SeqStart(Some(3)),
                Token::SeqSep,
                Token::SeqStart(Some(0)),
@ -330,27 +373,27 @@ declare_tests! {
                Token::SeqEnd,
            Token::SeqEnd,
        ],
-        Vec::<isize>::new() => vec![
+        Vec::<isize>::new() => &[
            Token::UnitStruct("Anything"),
        ],
-        Vec::<isize>::new() => vec![
+        Vec::<isize>::new() => &[
            Token::TupleStructStart("Anything", Some(0)),
            Token::SeqEnd,
        ],
    }
    test_array {
-        [0; 0] => vec![
+        [0; 0] => &[
            Token::Unit,
        ],
-        [0; 0] => vec![
+        [0; 0] => &[
            Token::SeqStart(Some(0)),
            Token::SeqEnd,
        ],
-        [0; 0] => vec![
+        [0; 0] => &[
            Token::SeqArrayStart(0),
            Token::SeqEnd,
        ],
-        ([0; 0], [1], [2, 3]) => vec![
+        ([0; 0], [1], [2, 3]) => &[
            Token::SeqStart(Some(3)),
                Token::SeqSep,
                Token::SeqStart(Some(0)),
@ -372,7 +415,7 @@ declare_tests! {
                Token::SeqEnd,
            Token::SeqEnd,
        ],
-        ([0; 0], [1], [2, 3]) => vec![
+        ([0; 0], [1], [2, 3]) => &[
            Token::SeqArrayStart(3),
                Token::SeqSep,
                Token::SeqArrayStart(0),
@ -394,22 +437,22 @@ declare_tests! {
                Token::SeqEnd,
            Token::SeqEnd,
        ],
-        [0; 0] => vec![
+        [0; 0] => &[
            Token::UnitStruct("Anything"),
        ],
-        [0; 0] => vec![
+        [0; 0] => &[
            Token::TupleStructStart("Anything", Some(0)),
            Token::SeqEnd,
        ],
    }
    test_tuple {
-        (1,) => vec![
+        (1,) => &[
            Token::SeqStart(Some(1)),
                Token::SeqSep,
                Token::I32(1),
            Token::SeqEnd,
        ],
-        (1, 2, 3) => vec![
+        (1, 2, 3) => &[
            Token::SeqStart(Some(3)),
                Token::SeqSep,
                Token::I32(1),
@ -421,13 +464,13 @@ declare_tests! {
                Token::I32(3),
            Token::SeqEnd,
        ],
-        (1,) => vec![
+        (1,) => &[
            Token::TupleStart(1),
                Token::TupleSep,
                Token::I32(1),
            Token::TupleEnd,
        ],
-        (1, 2, 3) => vec![
+        (1, 2, 3) => &[
            Token::TupleStart(3),
                Token::TupleSep,
                Token::I32(1),
@ -441,21 +484,21 @@ declare_tests! {
        ],
    }
    test_btreemap {
-        BTreeMap::<isize, isize>::new() => vec![
+        BTreeMap::<isize, isize>::new() => &[
            Token::Unit,
        ],
-        BTreeMap::<isize, isize>::new() => vec![
+        BTreeMap::<isize, isize>::new() => &[
            Token::MapStart(Some(0)),
            Token::MapEnd,
        ],
-        btreemap![1 => 2] => vec![
+        btreemap![1 => 2] => &[
            Token::MapStart(Some(1)),
                Token::MapSep,
                Token::I32(1),
                Token::I32(2),
            Token::MapEnd,
        ],
-        btreemap![1 => 2, 3 => 4] => vec![
+        btreemap![1 => 2, 3 => 4] => &[
            Token::MapStart(Some(2)),
                Token::MapSep,
                Token::I32(1),
@ -466,7 +509,7 @@ declare_tests! {
                Token::I32(4),
            Token::MapEnd,
        ],
-        btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]] => vec![
+        btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]] => &[
            Token::MapStart(Some(2)),
                Token::MapSep,
                Token::I32(1),
@ -486,30 +529,30 @@ declare_tests! {
                Token::MapEnd,
            Token::MapEnd,
        ],
-        BTreeMap::<isize, isize>::new() => vec![
+        BTreeMap::<isize, isize>::new() => &[
            Token::UnitStruct("Anything"),
        ],
-        BTreeMap::<isize, isize>::new() => vec![
+        BTreeMap::<isize, isize>::new() => &[
            Token::StructStart("Anything", Some(0)),
            Token::MapEnd,
        ],
    }
    test_hashmap {
-        HashMap::<isize, isize>::new() => vec![
+        HashMap::<isize, isize>::new() => &[
            Token::Unit,
        ],
-        HashMap::<isize, isize>::new() => vec![
+        HashMap::<isize, isize>::new() => &[
            Token::MapStart(Some(0)),
            Token::MapEnd,
        ],
-        hashmap![1 => 2] => vec![
+        hashmap![1 => 2] => &[
            Token::MapStart(Some(1)),
                Token::MapSep,
                Token::I32(1),
                Token::I32(2),
            Token::MapEnd,
        ],
-        hashmap![1 => 2, 3 => 4] => vec![
+        hashmap![1 => 2, 3 => 4] => &[
            Token::MapStart(Some(2)),
                Token::MapSep,
                Token::I32(1),
@ -520,7 +563,7 @@ declare_tests! {
                Token::I32(4),
            Token::MapEnd,
        ],
-        hashmap![1 => hashmap![], 2 => hashmap![3 => 4, 5 => 6]] => vec![
+        hashmap![1 => hashmap![], 2 => hashmap![3 => 4, 5 => 6]] => &[
            Token::MapStart(Some(2)),
                Token::MapSep,
                Token::I32(1),
@ -540,14 +583,14 @@ declare_tests! {
                Token::MapEnd,
            Token::MapEnd,
        ],
-        HashMap::<isize, isize>::new() => vec![
+        HashMap::<isize, isize>::new() => &[
            Token::UnitStruct("Anything"),
        ],
-        HashMap::<isize, isize>::new() => vec![
+        HashMap::<isize, isize>::new() => &[
            Token::StructStart("Anything", Some(0)),
            Token::MapEnd,
        ],
-        hashmap![FnvHasher @ 1 => 2, 3 => 4] => vec![
+        hashmap![FnvHasher @ 1 => 2, 3 => 4] => &[
            Token::MapStart(Some(2)),
                Token::MapSep,
                Token::I32(1),
@ -560,7 +603,7 @@ declare_tests! {
        ],
    }
    test_struct {
-        Struct { a: 1, b: 2, c: 0 } => vec![
+        Struct { a: 1, b: 2, c: 0 } => &[
            Token::MapStart(Some(3)),
                Token::MapSep,
                Token::Str("a"),
@ -571,7 +614,7 @@ declare_tests! {
                Token::I32(2),
            Token::MapEnd,
        ],
-        Struct { a: 1, b: 2, c: 0 } => vec![
+        Struct { a: 1, b: 2, c: 0 } => &[
            Token::StructStart("Struct", Some(3)),
                Token::StructSep,
                Token::Str("a"),
@ -582,7 +625,7 @@ declare_tests! {
                Token::I32(2),
            Token::StructEnd,
        ],
-        Struct { a: 1, b: 2, c: 0 } => vec![
+        Struct { a: 1, b: 2, c: 0 } => &[
            Token::SeqStart(Some(3)),
                Token::SeqSep,
                Token::I32(1),
@ -593,7 +636,7 @@ declare_tests! {
        ],
    }
    test_struct_with_skip {
-        Struct { a: 1, b: 2, c: 0 } => vec![
+        Struct { a: 1, b: 2, c: 0 } => &[
            Token::MapStart(Some(3)),
                Token::MapSep,
                Token::Str("a"),
@ -612,7 +655,7 @@ declare_tests! {
                Token::I32(4),
            Token::MapEnd,
        ],
-        Struct { a: 1, b: 2, c: 0 } => vec![
+        Struct { a: 1, b: 2, c: 0 } => &[
            Token::StructStart("Struct", Some(3)),
                Token::StructSep,
                Token::Str("a"),
@ -633,18 +676,18 @@ declare_tests! {
        ],
    }
    test_enum_unit {
-        Enum::Unit => vec![
+        Enum::Unit => &[
            Token::EnumUnit("Enum", "Unit"),
        ],
    }
    test_enum_simple {
-        Enum::Simple(1) => vec![
+        Enum::Simple(1) => &[
            Token::EnumNewType("Enum", "Simple"),
            Token::I32(1),
        ],
    }
    test_enum_seq {
-        Enum::Seq(1, 2, 3) => vec![
+        Enum::Seq(1, 2, 3) => &[
            Token::EnumSeqStart("Enum", "Seq", Some(3)),
                Token::EnumSeqSep,
                Token::I32(1),
@ -658,7 +701,7 @@ declare_tests! {
        ],
    }
    test_enum_map {
-        Enum::Map { a: 1, b: 2, c: 3 } => vec![
+        Enum::Map { a: 1, b: 2, c: 3 } => &[
            Token::EnumMapStart("Enum", "Map", Some(3)),
                Token::EnumMapSep,
                Token::Str("a"),
@ -675,24 +718,24 @@ declare_tests! {
        ],
    }
    test_enum_unit_usize {
-        Enum::Unit => vec![
+        Enum::Unit => &[
            Token::EnumStart("Enum"),
            Token::Usize(0),
            Token::Unit,
        ],
    }
    test_enum_unit_bytes {
-        Enum::Unit => vec![
+        Enum::Unit => &[
            Token::EnumStart("Enum"),
            Token::Bytes(b"Unit"),
            Token::Unit,
        ],
    }
    test_box {
-        Box::new(0i32) => vec![Token::I32(0)],
+        Box::new(0i32) => &[Token::I32(0)],
    }
    test_boxed_slice {
-        Box::new([0, 1, 2]) => vec![
+        Box::new([0, 1, 2]) => &[
            Token::SeqStart(Some(3)),
            Token::SeqSep,
            Token::I32(0),
@ -704,18 +747,18 @@ declare_tests! {
        ],
    }
    test_net_ipv4addr {
-        "1.2.3.4".parse::<net::Ipv4Addr>().unwrap() => vec![Token::Str("1.2.3.4")],
+        "1.2.3.4".parse::<net::Ipv4Addr>().unwrap() => &[Token::Str("1.2.3.4")],
    }
    test_net_ipv6addr {
-        "::1".parse::<net::Ipv6Addr>().unwrap() => vec![Token::Str("::1")],
+        "::1".parse::<net::Ipv6Addr>().unwrap() => &[Token::Str("::1")],
    }
    test_net_socketaddr {
-        "1.2.3.4:1234".parse::<net::SocketAddr>().unwrap() => vec![Token::Str("1.2.3.4:1234")],
-        "1.2.3.4:1234".parse::<net::SocketAddrV4>().unwrap() => vec![Token::Str("1.2.3.4:1234")],
-        "[::1]:1234".parse::<net::SocketAddrV6>().unwrap() => vec![Token::Str("[::1]:1234")],
+        "1.2.3.4:1234".parse::<net::SocketAddr>().unwrap() => &[Token::Str("1.2.3.4:1234")],
+        "1.2.3.4:1234".parse::<net::SocketAddrV4>().unwrap() => &[Token::Str("1.2.3.4:1234")],
+        "[::1]:1234".parse::<net::SocketAddrV6>().unwrap() => &[Token::Str("[::1]:1234")],
    }
    test_path_buf {
-        PathBuf::from("/usr/local/lib") => vec![
+        PathBuf::from("/usr/local/lib") => &[
            Token::String("/usr/local/lib".to_owned()),
        ],
    }
@ -726,30 +769,28 @@ declare_tests! {
 fn test_net_ipaddr() {
    assert_de_tokens(
        "1.2.3.4".parse::<net::IpAddr>().unwrap(),
-        vec![Token::Str("1.2.3.4")],
+        &[Token::Str("1.2.3.4")],
    );
 }

 declare_error_tests! {
    test_unknown_variant<Enum> {
-        vec![
+        &[
            Token::EnumUnit("Enum", "Foo"),
        ],
-        Error::UnknownVariantError("Foo".to_owned()),
+        Error::UnknownVariant("Foo".to_owned()),
    }
    test_struct_seq_too_long<Struct> {
-        vec![
+        &[
            Token::SeqStart(Some(4)),
                Token::SeqSep, Token::I32(1),
                Token::SeqSep, Token::I32(2),
                Token::SeqSep, Token::I32(3),
-                Token::SeqSep, Token::I32(4),
-            Token::SeqEnd,
        ],
        Error::UnexpectedToken(Token::SeqSep),
    }
    test_duplicate_field_struct<Struct> {
-        vec![
+        &[
            Token::MapStart(Some(3)),
                Token::MapSep,
                Token::Str("a"),
@ -757,13 +798,11 @@ declare_error_tests! {

                Token::MapSep,
                Token::Str("a"),
-                Token::I32(3),
-            Token::MapEnd,
        ],
-        Error::DuplicateFieldError("a"),
+        Error::DuplicateField("a"),
    }
    test_duplicate_field_enum<Enum> {
-        vec![
+        &[
            Token::EnumMapStart("Enum", "Map", Some(3)),
                Token::EnumMapSep,
                Token::Str("a"),
@ -771,9 +810,7 @@ declare_error_tests! {

                Token::EnumMapSep,
                Token::Str("a"),
-                Token::I32(3),
-            Token::EnumMapEnd,
        ],
-        Error::DuplicateFieldError("a"),
+        Error::DuplicateField("a"),
    }
 }
--- a/serde_tests/tests/test_gen.rs
+++ b/serde_tests/tests/test_gen.rs
--- a/serde_tests/tests/test_macros.rs
+++ b/serde_tests/tests/test_macros.rs
@ -1,11 +1,12 @@
-use std::marker::PhantomData;
-use token::{Token, assert_tokens, assert_ser_tokens, assert_de_tokens};
+extern crate serde_test;
+use self::serde_test::{
+    Token,
+    assert_tokens,
+    assert_ser_tokens,
+    assert_de_tokens,
+};

-/*
-trait Trait {
-    type Type;
-}
-*/
+use std::marker::PhantomData;

 // That tests that the derived Serialize implementation doesn't trigger
 // any warning about `serializer` not being used, in case of empty enums.
@ -161,7 +162,7 @@ struct DefaultTyParam<T: AssociatedType<X=i32> = i32> {
 fn test_named_unit() {
    assert_tokens(
        &NamedUnit,
-        vec![Token::UnitStruct("NamedUnit")]
+        &[Token::UnitStruct("NamedUnit")]
    );
 }

@ -192,7 +193,7 @@ fn test_ser_named_tuple() {
 fn test_de_named_tuple() {
    assert_de_tokens(
        &DeNamedTuple(5, 6, 7),
-        vec![
+        &[
            Token::SeqStart(Some(3)),
            Token::SeqSep,
            Token::I32(5),
@ -209,7 +210,7 @@ fn test_de_named_tuple() {

    assert_de_tokens(
        &DeNamedTuple(5, 6, 7),
-        vec![
+        &[
            Token::TupleStructStart("DeNamedTuple", Some(3)),
            Token::TupleStructSep,
            Token::I32(5),
@ -265,7 +266,7 @@ fn test_de_named_map() {
            b: 6,
            c: 7,
        },
-        vec![
+        &[
            Token::StructStart("DeNamedMap", Some(3)),

            Token::StructSep,
@ -379,7 +380,7 @@ fn test_ser_enum_map() {
 fn test_de_enum_unit() {
    assert_tokens(
        &DeEnum::Unit::<u32, u32, u32>,
-        vec![
+        &[
            Token::EnumUnit("DeEnum", "Unit"),
        ],
    );
@ -403,7 +404,7 @@ fn test_de_enum_seq() {
            e,
            //f,
        ),
-        vec![
+        &[
            Token::EnumSeqStart("DeEnum", "Seq", Some(4)),

            Token::EnumSeqSep,
@ -441,7 +442,7 @@ fn test_de_enum_map() {
            e: e,
            //f: f,
        },
-        vec![
+        &[
            Token::EnumMapStart("DeEnum", "Map", Some(4)),

            Token::EnumMapSep,
@ -516,7 +517,7 @@ fn test_lifetimes() {
 fn test_generic_struct() {
    assert_tokens(
        &GenericStruct { x: 5u32 },
-        vec![
+        &[
            Token::StructStart("GenericStruct", Some(1)),

            Token::StructSep,
@ -532,7 +533,7 @@ fn test_generic_struct() {
 fn test_generic_newtype_struct() {
    assert_tokens(
        &GenericNewTypeStruct(5u32),
-        vec![
+        &[
            Token::StructNewType("GenericNewTypeStruct"),
            Token::U32(5),
        ]
@ -543,7 +544,7 @@ fn test_generic_newtype_struct() {
 fn test_generic_tuple_struct() {
    assert_tokens(
        &GenericTupleStruct(5u32, 6u32),
-        vec![
+        &[
            Token::TupleStructStart("GenericTupleStruct", Some(2)),

            Token::TupleStructSep,
@ -561,7 +562,7 @@ fn test_generic_tuple_struct() {
 fn test_generic_enum_unit() {
    assert_tokens(
        &GenericEnum::Unit::<u32, u32>,
-        vec![
+        &[
            Token::EnumUnit("GenericEnum", "Unit"),
        ]
    );
@ -571,7 +572,7 @@ fn test_generic_enum_unit() {
 fn test_generic_enum_newtype() {
    assert_tokens(
        &GenericEnum::NewType::<u32, u32>(5),
-        vec![
+        &[
            Token::EnumNewType("GenericEnum", "NewType"),
            Token::U32(5),
        ]
@ -582,7 +583,7 @@ fn test_generic_enum_newtype() {
 fn test_generic_enum_seq() {
    assert_tokens(
        &GenericEnum::Seq::<u32, u32>(5, 6),
-        vec![
+        &[
            Token::EnumSeqStart("GenericEnum", "Seq", Some(2)),

            Token::EnumSeqSep,
@ -600,7 +601,7 @@ fn test_generic_enum_seq() {
 fn test_generic_enum_map() {
    assert_tokens(
        &GenericEnum::Map::<u32, u32> { x: 5, y: 6 },
-        vec![
+        &[
            Token::EnumMapStart("GenericEnum", "Map", Some(2)),

            Token::EnumMapSep,
@ -620,7 +621,7 @@ fn test_generic_enum_map() {
 fn test_default_ty_param() {
    assert_tokens(
        &DefaultTyParam::<i32> { phantom: PhantomData },
-        vec![
+        &[
            Token::StructStart("DefaultTyParam", Some(1)),

            Token::StructSep,
--- a/serde_tests/tests/test_ser.rs
+++ b/serde_tests/tests/test_ser.rs
@ -3,7 +3,13 @@ use std::net;
 use std::path::{Path, PathBuf};
 use std::str;

-use token::{self, Token};
+extern crate serde_test;
+use self::serde_test::{
+    Error,
+    Token,
+    assert_ser_tokens,
+    assert_ser_tokens_error,
+};

 extern crate fnv;
 use self::fnv::FnvHasher;
@ -355,16 +361,16 @@ fn test_cannot_serialize_paths() {
    let path = unsafe {
        str::from_utf8_unchecked(b"Hello \xF0\x90\x80World")
    };
-    token::assert_ser_tokens_error(
+    assert_ser_tokens_error(
        &Path::new(path),
-        &[Token::Str("Hello <20>World")],
-        token::Error::InvalidValue("Path contains invalid UTF-8 characters".to_owned()));
+        &[],
+        Error::InvalidValue("Path contains invalid UTF-8 characters".to_owned()));

    let mut path_buf = PathBuf::new();
    path_buf.push(path);

-    token::assert_ser_tokens_error(
+    assert_ser_tokens_error(
        &path_buf,
-        &[Token::Str("Hello <20>World")],
-        token::Error::InvalidValue("Path contains invalid UTF-8 characters".to_owned()));
+        &[],
+        Error::InvalidValue("Path contains invalid UTF-8 characters".to_owned()));
 }