diff --git a/serde_test/Cargo.toml b/serde_test/Cargo.toml
new file mode 100644
index 00000000..3148218b
--- /dev/null
+++ b/serde_test/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "serde_test"
+version = "0.1.0"
+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" }
diff --git a/serde_test/src/assert.rs b/serde_test/src/assert.rs
new file mode 100644
index 00000000..e580aa8a
--- /dev/null
+++ b/serde_test/src/assert.rs
@@ -0,0 +1,50 @@
+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: Vec<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 deserializing tokens into a 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));
+}
+
+pub fn assert_de_tokens<T>(value: &T, tokens: Vec<Token<'static>>)
+    where T: Deserialize + PartialEq + Debug,
+{
+    let mut de = Deserializer::new(tokens.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: Vec<Token<'static>>, error: Error)
+    where T: Deserialize + PartialEq + Debug,
+{
+    let mut de = Deserializer::new(tokens.into_iter());
+    let v: Result<T, Error> = Deserialize::deserialize(&mut de);
+    assert_eq!(v, Err(error));
+}
diff --git a/testing/tests/token.rs b/serde_test/src/de.rs
similarity index 56%
rename from testing/tests/token.rs
rename to serde_test/src/de.rs
index bd20a982..127dc221 100644
--- a/testing/tests/token.rs
+++ b/serde_test/src/de.rs
@@ -1,493 +1,39 @@
-use std::fmt;
 use std::iter;
-use std::error;
 
-extern crate serde;
-use self::serde::ser::{self, Serialize};
-use self::serde::de;
-use self::serde::de::value::{self, ValueDeserializer};
+use serde::de::{
+    self,
+    Deserialize,
+    EnumVisitor,
+    MapVisitor,
+    SeqVisitor,
+    VariantVisitor,
+    Visitor,
+};
 
-#[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]),
+use error::Error;
+use token::Token;
 
-    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,
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-pub struct Serializer<I> {
-    tokens: I,
-}
-
-impl<'a, I> Serializer<I>
-    where I: Iterator<Item=&'a Token<'a>>
+pub struct Deserializer<I>
+    where I: Iterator<Item=Token<'static>>,
 {
-    pub fn new(tokens: I) -> Serializer<I> {
-        Serializer {
-            tokens: tokens,
-        }
-    }
-
-    fn visit_sequence<V>(&mut self, mut visitor: V) -> Result<(), Error>
-        where V: ser::SeqVisitor
-    {
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        assert_eq!(self.tokens.next(), Some(&Token::SeqEnd));
-
-        Ok(())
-    }
-
-    fn visit_mapping<V>(&mut self, mut visitor: V) -> Result<(), Error>
-        where V: ser::MapVisitor
-    {
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        assert_eq!(self.tokens.next(), Some(&Token::MapEnd));
-
-        Ok(())
-    }
-}
-
-impl<'a, I> ser::Serializer for Serializer<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: ser::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: ser::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: ser::SeqVisitor
-    {
-        let len = visitor.len();
-
-        assert_eq!(self.tokens.next(), Some(&Token::SeqStart(len)));
-
-        self.visit_sequence(visitor)
-    }
-
-    fn serialize_fixed_size_array<V>(&mut self, visitor: V) -> Result<(), Error>
-        where V: ser::SeqVisitor
-    {
-        let len = visitor.len().expect("arrays must have a length");
-
-        assert_eq!(self.tokens.next(), Some(&Token::SeqArrayStart(len)));
-
-        self.visit_sequence(visitor)
-    }
-
-    fn serialize_seq_elt<T>(&mut self, value: T) -> Result<(), Error>
-        where T: ser::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: ser::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: ser::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: ser::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: ser::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: ser::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: ser::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: ser::Serialize,
-    {
-        assert_eq!(self.tokens.next(), Some(&Token::EnumSeqSep));
-        value.serialize(self)
-    }
-
-    fn serialize_map<V>(&mut self, visitor: V) -> Result<(), Error>
-        where V: ser::MapVisitor
-    {
-        let len = visitor.len();
-
-        assert_eq!(self.tokens.next(), Some(&Token::MapStart(len)));
-
-        self.visit_mapping(visitor)
-    }
-
-    fn serialize_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), Error>
-        where K: ser::Serialize,
-              V: ser::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: ser::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: ser::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: ser::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: ser::Serialize,
-    {
-        assert_eq!(self.tokens.next(), Some(&Token::EnumMapSep));
-
-        try!(key.serialize(self));
-        value.serialize(self)
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-#[derive(Clone, PartialEq, Debug)]
-pub enum Error {
-    SyntaxError,
-    EndOfStreamError,
-    UnknownFieldError(String),
-    UnknownVariantError(String),
-    MissingFieldError(&'static str),
-    DuplicateFieldError(&'static str),
-    InvalidName(&'static str),
-    InvalidValue(String),
-    UnexpectedToken(Token<'static>),
-    ValueError(value::Error),
-}
-
-impl ser::Error for Error {
-    fn custom<T: Into<String>>(_: T) -> Error { Error::SyntaxError }
-
-    fn invalid_value(msg: &str) -> Error {
-        Error::InvalidValue(msg.to_owned())
-    }
-}
-
-impl de::Error for Error {
-    fn custom<T: Into<String>>(_: T) -> Error { Error::SyntaxError }
-
-    fn end_of_stream() -> Error { Error::EndOfStreamError }
-
-    fn invalid_value(msg: &str) -> Error {
-        Error::InvalidValue(msg.to_owned())
-    }
-
-    fn unknown_field(field: &str) -> Error {
-        Error::UnknownFieldError(field.to_owned())
-    }
-
-    fn unknown_variant(variant: &str) -> Error {
-        Error::UnknownVariantError(variant.to_owned())
-    }
-
-    fn missing_field(field: &'static str) -> Error {
-        Error::MissingFieldError(field)
-    }
-
-    fn duplicate_field(field: &'static str) -> Error {
-        Error::DuplicateFieldError(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 Deserialization Error"
-    }
-
-    fn cause(&self) -> Option<&error::Error> {
-        None
-    }
-}
-
-impl From<value::Error> for Error {
-    fn from(error: value::Error) -> Error {
-        Error::ValueError(error)
-    }
-}
-
-struct Deserializer<I> where I: Iterator<Item=Token<'static>> {
     tokens: iter::Peekable<I>,
 }
 
 impl<I> Deserializer<I>
-    where I: Iterator<Item=Token<'static>>
+    where I: Iterator<Item=Token<'static>>,
 {
-    fn new(tokens: I) -> Deserializer<I> {
+    pub fn new(tokens: I) -> Deserializer<I> {
         Deserializer {
             tokens: tokens.peekable(),
         }
     }
 
+    pub fn next_token(&mut self) -> Option<Token<'static>> {
+        self.tokens.next()
+    }
+
     fn visit_seq<V>(&mut self, len: Option<usize>, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
+        where V: Visitor,
     {
         visitor.visit_seq(DeserializerSeqVisitor {
             de: self,
@@ -496,7 +42,7 @@ impl<I> Deserializer<I>
     }
 
     fn visit_array<V>(&mut self, len: usize, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
+        where V: Visitor,
     {
         visitor.visit_seq(DeserializerArrayVisitor {
             de: self,
@@ -505,7 +51,7 @@ impl<I> Deserializer<I>
     }
 
     fn visit_tuple<V>(&mut self, len: usize, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
+        where V: Visitor,
     {
         visitor.visit_seq(DeserializerTupleVisitor {
             de: self,
@@ -514,7 +60,7 @@ impl<I> Deserializer<I>
     }
 
     fn visit_tuple_struct<V>(&mut self, len: usize, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
+        where V: Visitor,
     {
         visitor.visit_seq(DeserializerTupleStructVisitor {
             de: self,
@@ -523,7 +69,7 @@ impl<I> Deserializer<I>
     }
 
     fn visit_variant_seq<V>(&mut self, len: Option<usize>, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
+        where V: Visitor,
     {
         visitor.visit_seq(DeserializerVariantSeqVisitor {
             de: self,
@@ -532,7 +78,7 @@ impl<I> Deserializer<I>
     }
 
     fn visit_map<V>(&mut self, len: Option<usize>, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
+        where V: Visitor,
     {
         visitor.visit_map(DeserializerMapVisitor {
             de: self,
@@ -541,7 +87,7 @@ impl<I> Deserializer<I>
     }
 
     fn visit_struct<V>(&mut self, len: Option<usize>, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
+        where V: Visitor,
     {
         visitor.visit_map(DeserializerStructVisitor {
             de: self,
@@ -550,7 +96,7 @@ impl<I> Deserializer<I>
     }
 
     fn visit_variant_map<V>(&mut self, len: Option<usize>, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
+        where V: Visitor,
     {
         visitor.visit_map(DeserializerVariantMapVisitor {
             de: self,
@@ -560,12 +106,12 @@ impl<I> Deserializer<I>
 }
 
 impl<I> de::Deserializer for Deserializer<I>
-    where I: Iterator<Item=Token<'static>>
+    where I: Iterator<Item=Token<'static>>,
 {
     type Error = Error;
 
     fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
+        where V: Visitor,
     {
         match self.tokens.next() {
             Some(Token::Bool(v)) => visitor.visit_bool(v),
@@ -606,7 +152,7 @@ impl<I> de::Deserializer for Deserializer<I>
     /// Hook into `Option` deserializing so we can treat `Unit` as a
     /// `None`, or a regular value as `Some(value)`.
     fn deserialize_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
+        where V: Visitor,
     {
         match self.tokens.peek() {
             Some(&Token::Option(false)) => {
@@ -630,7 +176,7 @@ impl<I> de::Deserializer for Deserializer<I>
                      name: &str,
                      _variants: &'static [&'static str],
                      mut visitor: V) -> Result<V::Value, Error>
-        where V: de::EnumVisitor,
+        where V: EnumVisitor,
     {
         match self.tokens.peek() {
             Some(&Token::EnumStart(n)) if name == n => {
@@ -657,7 +203,7 @@ impl<I> de::Deserializer for Deserializer<I>
     }
 
     fn deserialize_unit_struct<V>(&mut self, name: &str, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
+        where V: Visitor,
     {
         match self.tokens.peek() {
             Some(&Token::UnitStruct(n)) => {
@@ -676,7 +222,7 @@ impl<I> de::Deserializer for Deserializer<I>
     fn deserialize_newtype_struct<V>(&mut self,
                                      name: &str,
                                      mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
+        where V: Visitor,
     {
         match self.tokens.peek() {
             Some(&Token::StructNewType(n)) => {
@@ -695,7 +241,7 @@ impl<I> de::Deserializer for Deserializer<I>
     fn deserialize_fixed_size_array<V>(&mut self,
                                        len: usize,
                                        visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
+        where V: Visitor,
     {
         match self.tokens.peek() {
             Some(&Token::SeqArrayStart(_)) => {
@@ -710,7 +256,7 @@ impl<I> de::Deserializer for Deserializer<I>
     fn deserialize_tuple<V>(&mut self,
                             len: usize,
                             mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
+        where V: Visitor,
     {
         match self.tokens.peek() {
             Some(&Token::Unit) => {
@@ -746,7 +292,7 @@ impl<I> de::Deserializer for Deserializer<I>
                                    name: &str,
                                    len: usize,
                                    mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
+        where V: Visitor,
     {
         match self.tokens.peek() {
             Some(&Token::Unit) => {
@@ -790,7 +336,7 @@ impl<I> de::Deserializer for Deserializer<I>
                              name: &str,
                              fields: &'static [&'static str],
                              visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
+        where V: Visitor,
     {
         match self.tokens.peek() {
             Some(&Token::StructStart(n, _)) => {
@@ -818,19 +364,19 @@ struct DeserializerSeqVisitor<'a, I: 'a> where I: Iterator<Item=Token<'static>>
     len: Option<usize>,
 }
 
-impl<'a, I> de::SeqVisitor for DeserializerSeqVisitor<'a, I>
+impl<'a, I> SeqVisitor for DeserializerSeqVisitor<'a, I>
     where I: Iterator<Item=Token<'static>>,
 {
     type Error = Error;
 
     fn visit<T>(&mut self) -> Result<Option<T>, Error>
-        where T: de::Deserialize,
+        where T: Deserialize,
     {
         match self.de.tokens.peek() {
             Some(&Token::SeqSep) => {
                 self.de.tokens.next();
                 self.len = self.len.map(|len| len - 1);
-                Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+                Ok(Some(try!(Deserialize::deserialize(self.de))))
             }
             Some(&Token::SeqEnd) => Ok(None),
             Some(_) => {
@@ -863,19 +409,19 @@ struct DeserializerArrayVisitor<'a, I: 'a> where I: Iterator<Item=Token<'static>
     len: usize,
 }
 
-impl<'a, I> de::SeqVisitor for DeserializerArrayVisitor<'a, I>
+impl<'a, I> SeqVisitor for DeserializerArrayVisitor<'a, I>
     where I: Iterator<Item=Token<'static>>,
 {
     type Error = Error;
 
     fn visit<T>(&mut self) -> Result<Option<T>, Error>
-        where T: de::Deserialize,
+        where T: Deserialize,
     {
         match self.de.tokens.peek() {
             Some(&Token::SeqSep) => {
                 self.de.tokens.next();
                 self.len -= 1;
-                Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+                Ok(Some(try!(Deserialize::deserialize(self.de))))
             }
             Some(&Token::SeqEnd) => Ok(None),
             Some(_) => {
@@ -907,19 +453,19 @@ struct DeserializerTupleVisitor<'a, I: 'a> where I: Iterator<Item=Token<'static>
     len: usize,
 }
 
-impl<'a, I> de::SeqVisitor for DeserializerTupleVisitor<'a, I>
+impl<'a, I> SeqVisitor for DeserializerTupleVisitor<'a, I>
     where I: Iterator<Item=Token<'static>>,
 {
     type Error = Error;
 
     fn visit<T>(&mut self) -> Result<Option<T>, Error>
-        where T: de::Deserialize,
+        where T: Deserialize,
     {
         match self.de.tokens.peek() {
             Some(&Token::TupleSep) => {
                 self.de.tokens.next();
                 self.len -= 1;
-                Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+                Ok(Some(try!(Deserialize::deserialize(self.de))))
             }
             Some(&Token::TupleEnd) => Ok(None),
             Some(_) => {
@@ -951,19 +497,19 @@ struct DeserializerTupleStructVisitor<'a, I: 'a> where I: Iterator<Item=Token<'s
     len: usize,
 }
 
-impl<'a, I> de::SeqVisitor for DeserializerTupleStructVisitor<'a, I>
+impl<'a, I> SeqVisitor for DeserializerTupleStructVisitor<'a, I>
     where I: Iterator<Item=Token<'static>>,
 {
     type Error = Error;
 
     fn visit<T>(&mut self) -> Result<Option<T>, Error>
-        where T: de::Deserialize,
+        where T: Deserialize,
     {
         match self.de.tokens.peek() {
             Some(&Token::TupleStructSep) => {
                 self.de.tokens.next();
                 self.len -= 1;
-                Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+                Ok(Some(try!(Deserialize::deserialize(self.de))))
             }
             Some(&Token::TupleStructEnd) => Ok(None),
             Some(_) => {
@@ -995,19 +541,19 @@ struct DeserializerVariantSeqVisitor<'a, I: 'a> where I: Iterator<Item=Token<'st
     len: Option<usize>,
 }
 
-impl<'a, I> de::SeqVisitor for DeserializerVariantSeqVisitor<'a, I>
+impl<'a, I> SeqVisitor for DeserializerVariantSeqVisitor<'a, I>
     where I: Iterator<Item=Token<'static>>,
 {
     type Error = Error;
 
     fn visit<T>(&mut self) -> Result<Option<T>, Error>
-        where T: de::Deserialize,
+        where T: Deserialize,
     {
         match self.de.tokens.peek() {
             Some(&Token::EnumSeqSep) => {
                 self.de.tokens.next();
                 self.len = self.len.map(|len| len - 1);
-                Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+                Ok(Some(try!(Deserialize::deserialize(self.de))))
             }
             Some(&Token::EnumSeqEnd) => Ok(None),
             Some(_) => {
@@ -1040,19 +586,19 @@ struct DeserializerMapVisitor<'a, I: 'a> where I: Iterator<Item=Token<'static>>
     len: Option<usize>,
 }
 
-impl<'a, I> de::MapVisitor for DeserializerMapVisitor<'a, I>
+impl<'a, I> MapVisitor for DeserializerMapVisitor<'a, I>
     where I: Iterator<Item=Token<'static>>,
 {
     type Error = Error;
 
     fn visit_key<K>(&mut self) -> Result<Option<K>, Error>
-        where K: de::Deserialize,
+        where K: Deserialize,
     {
         match self.de.tokens.peek() {
             Some(&Token::MapSep) => {
                 self.de.tokens.next();
                 self.len = self.len.map(|len| if len > 0 { len - 1} else { 0 });
-                Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+                Ok(Some(try!(Deserialize::deserialize(self.de))))
             }
             Some(&Token::MapEnd) => Ok(None),
             Some(_) => {
@@ -1064,9 +610,9 @@ impl<'a, I> de::MapVisitor for DeserializerMapVisitor<'a, I>
     }
 
     fn visit_value<V>(&mut self) -> Result<V, Error>
-        where V: de::Deserialize,
+        where V: Deserialize,
     {
-        Ok(try!(de::Deserialize::deserialize(self.de)))
+        Ok(try!(Deserialize::deserialize(self.de)))
     }
 
     fn end(&mut self) -> Result<(), Error> {
@@ -1091,19 +637,19 @@ struct DeserializerStructVisitor<'a, I: 'a> where I: Iterator<Item=Token<'static
     len: Option<usize>,
 }
 
-impl<'a, I> de::MapVisitor for DeserializerStructVisitor<'a, I>
+impl<'a, I> MapVisitor for DeserializerStructVisitor<'a, I>
     where I: Iterator<Item=Token<'static>>,
 {
     type Error = Error;
 
     fn visit_key<K>(&mut self) -> Result<Option<K>, Error>
-        where K: de::Deserialize,
+        where K: Deserialize,
     {
         match self.de.tokens.peek() {
             Some(&Token::StructSep) => {
                 self.de.tokens.next();
                 self.len = self.len.map(|len| if len > 0 { len - 1} else { 0 });
-                Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+                Ok(Some(try!(Deserialize::deserialize(self.de))))
             }
             Some(&Token::StructEnd) => Ok(None),
             Some(_) => {
@@ -1115,9 +661,9 @@ impl<'a, I> de::MapVisitor for DeserializerStructVisitor<'a, I>
     }
 
     fn visit_value<V>(&mut self) -> Result<V, Error>
-        where V: de::Deserialize,
+        where V: Deserialize,
     {
-        Ok(try!(de::Deserialize::deserialize(self.de)))
+        Ok(try!(Deserialize::deserialize(self.de)))
     }
 
     fn end(&mut self) -> Result<(), Error> {
@@ -1141,25 +687,25 @@ struct DeserializerVariantVisitor<'a, I: 'a> where I: Iterator<Item=Token<'stati
     de: &'a mut Deserializer<I>,
 }
 
-impl<'a, I> de::VariantVisitor for DeserializerVariantVisitor<'a, I>
+impl<'a, I> VariantVisitor for DeserializerVariantVisitor<'a, I>
     where I: Iterator<Item=Token<'static>>,
 {
     type Error = Error;
 
     fn visit_variant<V>(&mut self) -> Result<V, Error>
-        where V: de::Deserialize,
+        where V: Deserialize,
     {
         match self.de.tokens.peek() {
             Some(&Token::EnumUnit(_, v))
             | Some(&Token::EnumNewType(_, v))
             | Some(&Token::EnumSeqStart(_, v, _))
             | Some(&Token::EnumMapStart(_, v, _)) => {
-                let mut de = ValueDeserializer::<Error>::into_deserializer(v);
-                let value = try!(de::Deserialize::deserialize(&mut de));
+                let mut de = de::value::ValueDeserializer::<Error>::into_deserializer(v);
+                let value = try!(Deserialize::deserialize(&mut de));
                 Ok(value)
             }
             Some(_) => {
-                de::Deserialize::deserialize(self.de)
+                Deserialize::deserialize(self.de)
             }
             None => Err(Error::EndOfStreamError),
         }
@@ -1172,22 +718,22 @@ impl<'a, I> de::VariantVisitor for DeserializerVariantVisitor<'a, I>
                 Ok(())
             }
             Some(_) => {
-                de::Deserialize::deserialize(self.de)
+                Deserialize::deserialize(self.de)
             }
             None => Err(Error::EndOfStreamError),
         }
     }
 
     fn visit_newtype<T>(&mut self) -> Result<T, Self::Error>
-        where T: de::Deserialize,
+        where T: Deserialize,
     {
         match self.de.tokens.peek() {
             Some(&Token::EnumNewType(_, _)) => {
                 self.de.tokens.next();
-                de::Deserialize::deserialize(self.de)
+                Deserialize::deserialize(self.de)
             }
             Some(_) => {
-                de::Deserialize::deserialize(self.de)
+                Deserialize::deserialize(self.de)
             }
             None => Err(Error::EndOfStreamError),
         }
@@ -1196,7 +742,7 @@ impl<'a, I> de::VariantVisitor for DeserializerVariantVisitor<'a, I>
     fn visit_tuple<V>(&mut self,
                       len: usize,
                       visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
+        where V: Visitor,
     {
         match self.de.tokens.peek() {
             Some(&Token::EnumSeqStart(_, _, Some(enum_len))) => {
@@ -1218,7 +764,7 @@ impl<'a, I> de::VariantVisitor for DeserializerVariantVisitor<'a, I>
                 }
             }
             Some(_) => {
-                de::Deserialize::deserialize(self.de)
+                Deserialize::deserialize(self.de)
             }
             None => Err(Error::EndOfStreamError),
         }
@@ -1227,7 +773,7 @@ impl<'a, I> de::VariantVisitor for DeserializerVariantVisitor<'a, I>
     fn visit_struct<V>(&mut self,
                        fields: &'static [&'static str],
                        visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
+        where V: Visitor,
     {
         match self.de.tokens.peek() {
             Some(&Token::EnumMapStart(_, _, Some(enum_len))) => {
@@ -1249,7 +795,7 @@ impl<'a, I> de::VariantVisitor for DeserializerVariantVisitor<'a, I>
                 }
             }
             Some(_) => {
-                de::Deserialize::deserialize(self.de)
+                Deserialize::deserialize(self.de)
             }
             None => Err(Error::EndOfStreamError),
         }
@@ -1263,19 +809,19 @@ struct DeserializerVariantMapVisitor<'a, I: 'a> where I: Iterator<Item=Token<'st
     len: Option<usize>,
 }
 
-impl<'a, I> de::MapVisitor for DeserializerVariantMapVisitor<'a, I>
+impl<'a, I> MapVisitor for DeserializerVariantMapVisitor<'a, I>
     where I: Iterator<Item=Token<'static>>,
 {
     type Error = Error;
 
     fn visit_key<K>(&mut self) -> Result<Option<K>, Error>
-        where K: de::Deserialize,
+        where K: Deserialize,
     {
         match self.de.tokens.peek() {
             Some(&Token::EnumMapSep) => {
                 self.de.tokens.next();
                 self.len = self.len.map(|len| if len > 0 { len - 1} else { 0 });
-                Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+                Ok(Some(try!(Deserialize::deserialize(self.de))))
             }
             Some(&Token::EnumMapEnd) => Ok(None),
             Some(_) => {
@@ -1287,9 +833,9 @@ impl<'a, I> de::MapVisitor for DeserializerVariantMapVisitor<'a, I>
     }
 
     fn visit_value<V>(&mut self) -> Result<V, Error>
-        where V: de::Deserialize,
+        where V: Deserialize,
     {
-        Ok(try!(de::Deserialize::deserialize(self.de)))
+        Ok(try!(Deserialize::deserialize(self.de)))
     }
 
     fn end(&mut self) -> Result<(), Error> {
@@ -1306,89 +852,3 @@ impl<'a, I> de::MapVisitor for DeserializerVariantMapVisitor<'a, I>
         (len, self.len)
     }
 }
-
-//////////////////////////////////////////////////////////////////////////////
-
-pub fn assert_ser_tokens<T>(value: &T, tokens: &[Token])
-    where T: ser::Serialize,
-{
-    let mut ser = Serializer::new(tokens.iter());
-    assert_eq!(ser::Serialize::serialize(value, &mut ser), Ok(()));
-    assert_eq!(ser.tokens.next(), None);
-}
-
-// Expect an error deserializing tokens into a T
-pub fn assert_ser_tokens_error<T>(value: &T, tokens: &[Token], error: Error)
-    where T: ser::Serialize + PartialEq + fmt::Debug,
-{
-    let mut ser = Serializer::new(tokens.iter());
-    let v: Result<(), Error> = ser::Serialize::serialize(value, &mut ser);
-    assert_eq!(v.as_ref(), Err(&error));
-}
-
-pub fn assert_de_tokens<T>(value: &T, tokens: Vec<Token<'static>>)
-    where T: de::Deserialize + PartialEq + fmt::Debug,
-{
-    let mut de = Deserializer::new(tokens.into_iter());
-    let v: Result<T, Error> = de::Deserialize::deserialize(&mut de);
-    assert_eq!(v.as_ref(), Ok(value));
-    assert_eq!(de.tokens.next(), None);
-}
-
-// Expect an error deserializing tokens into a T
-pub fn assert_de_tokens_error<T>(tokens: Vec<Token<'static>>, error: Error)
-    where T: de::Deserialize + PartialEq + fmt::Debug,
-{
-    let mut de = Deserializer::new(tokens.into_iter());
-    let v: Result<T, Error> = de::Deserialize::deserialize(&mut de);
-    assert_eq!(v, Err(error));
-}
-
-// Tests that the given token stream is ignorable when embedded in
-// an otherwise normal struct
-pub fn assert_de_tokens_ignore(ignorable_tokens: Vec<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.into_iter())
-        .chain(vec![
-            Token::MapEnd,
-        ].into_iter())
-        .collect();
-
-    let mut de = Deserializer::new(concated_tokens.into_iter());
-    let v: Result<IgnoreBase, Error> = de::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.tokens.next(), None);
-}
-
-pub fn assert_tokens<T>(value: &T, tokens: Vec<Token<'static>>)
-    where T: ser::Serialize + de::Deserialize + PartialEq + fmt::Debug,
-{
-    assert_ser_tokens(value, &tokens[..]);
-    assert_de_tokens(value, tokens);
-}
diff --git a/serde_test/src/error.rs b/serde_test/src/error.rs
new file mode 100644
index 00000000..580a5194
--- /dev/null
+++ b/serde_test/src/error.rs
@@ -0,0 +1,75 @@
+use std::{error, fmt};
+
+use serde::{ser, de};
+
+use token::Token;
+
+#[derive(Clone, PartialEq, Debug)]
+pub enum Error {
+    SyntaxError,
+    EndOfStreamError,
+    UnknownFieldError(String),
+    UnknownVariantError(String),
+    MissingFieldError(&'static str),
+    DuplicateFieldError(&'static str),
+    InvalidName(&'static str),
+    InvalidValue(String),
+    UnexpectedToken(Token<'static>),
+    ValueError(de::value::Error),
+}
+
+impl ser::Error for Error {
+    fn custom<T: Into<String>>(_: T) -> Error {
+        Error::SyntaxError
+    }
+
+    fn invalid_value(msg: &str) -> Error {
+        Error::InvalidValue(msg.to_owned())
+    }
+}
+
+impl de::Error for Error {
+    fn custom<T: Into<String>>(_: T) -> Error {
+        Error::SyntaxError
+    }
+
+    fn end_of_stream() -> Error {
+        Error::EndOfStreamError
+    }
+
+    fn invalid_value(msg: &str) -> Error {
+        Error::InvalidValue(msg.to_owned())
+    }
+
+    fn unknown_field(field: &str) -> Error {
+        Error::UnknownFieldError(field.to_owned())
+    }
+
+    fn unknown_variant(variant: &str) -> Error {
+        Error::UnknownVariantError(variant.to_owned())
+    }
+
+    fn missing_field(field: &'static str) -> Error {
+        Error::MissingFieldError(field)
+    }
+
+    fn duplicate_field(field: &'static str) -> Error {
+        Error::DuplicateFieldError(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
+    }
+}
diff --git a/serde_test/src/lib.rs b/serde_test/src/lib.rs
new file mode 100644
index 00000000..945262c0
--- /dev/null
+++ 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;
diff --git a/serde_test/src/ser.rs b/serde_test/src/ser.rs
new file mode 100644
index 00000000..2f028d3b
--- /dev/null
+++ 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)
+    }
+}
diff --git a/serde_test/src/token.rs b/serde_test/src/token.rs
new file mode 100644
index 00000000..dcb1137f
--- /dev/null
+++ 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,
+}
diff --git a/testing/Cargo.toml b/testing/Cargo.toml
index 27dab564..a32b2f9f 100644
--- a/testing/Cargo.toml
+++ b/testing/Cargo.toml
@@ -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 }
diff --git a/testing/tests/macros.rs b/testing/tests/macros.rs
index 2446150b..fa65f6ae 100644
--- a/testing/tests/macros.rs
+++ b/testing/tests/macros.rs
@@ -5,7 +5,7 @@ macro_rules! declare_ser_tests {
             #[test]
             fn $name() {
                 $(
-                    ::token::assert_ser_tokens(&$value, $tokens);
+                    self::serde_test::assert_ser_tokens(&$value, $tokens);
                 )+
             }
         )+
diff --git a/testing/tests/test.rs.in b/testing/tests/test.rs.in
index f64b84c1..32c00054 100644
--- a/testing/tests/test.rs.in
+++ b/testing/tests/test.rs.in
@@ -1,8 +1,6 @@
 #[macro_use]
 mod macros;
 
-mod token;
-
 mod test_annotations;
 mod test_bytes;
 mod test_de;
diff --git a/testing/tests/test_annotations.rs b/testing/tests/test_annotations.rs
index 79e1683b..544f2c3b 100644
--- a/testing/tests/test_annotations.rs
+++ b/testing/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,
diff --git a/testing/tests/test_de.rs b/testing/tests/test_de.rs
index 2b9d0035..a03081ab 100644
--- a/testing/tests/test_de.rs
+++ b/testing/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,6 +76,46 @@ macro_rules! declare_error_tests {
     }
 }
 
+fn assert_de_tokens_ignore(ignorable_tokens: Vec<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.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! {
diff --git a/testing/tests/test_macros.rs b/testing/tests/test_macros.rs
index 491acca2..188244c2 100644
--- a/testing/tests/test_macros.rs
+++ b/testing/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.
diff --git a/testing/tests/test_ser.rs b/testing/tests/test_ser.rs
index 5b3f215b..8521877b 100644
--- a/testing/tests/test_ser.rs
+++ b/testing/tests/test_ser.rs
@@ -3,7 +3,12 @@ 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_error,
+};
 
 extern crate fnv;
 use self::fnv::FnvHasher;
@@ -355,16 +360,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 �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 �World")],
-        token::Error::InvalidValue("Path contains invalid UTF-8 characters".to_owned()));
+        Error::InvalidValue("Path contains invalid UTF-8 characters".to_owned()));
 }