Rename serde_tests to testing

testing/Cargo.toml

@@ -0,0 +1,33 @@
+[package]
+name = "serde_testing"
+version = "0.7.11"
+authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
+license = "MIT/Apache-2.0"
+description = "A generic serialization/deserialization framework"
+repository = "https://github.com/serde-rs/serde"
+documentation = "http://serde-rs.github.io/serde/serde"
+readme = "README.md"
+keywords = ["serialization"]
+build = "build.rs"
+
+[features]
+nightly-testing = ["clippy", "serde/nightly-testing", "serde_codegen/nightly-testing"]
+
+[build-dependencies]
+serde_codegen = { version = "*", path = "../serde_codegen", features = ["with-syntex"] }
+
+[dev-dependencies]
+fnv = "1.0"
+rustc-serialize = "^0.3.16"
+serde = { version = "*", path = "../serde" }
+
+[dependencies]
+clippy = { version = "^0.*", optional = true }
+
+[[test]]
+name = "test"
+path = "tests/test.rs"
+
+[[bench]]
+name = "bench"
+path = "benches/bench.rs"

testing/benches/bench.rs

@@ -0,0 +1,9 @@
+#![feature(test)]
+#![cfg_attr(feature = "nightly", feature(plugin))]
+#![cfg_attr(feature = "nightly", plugin(clippy))]
+
+extern crate rustc_serialize;
+extern crate serde;
+extern crate test;
+
+include!(concat!(env!("OUT_DIR"), "/bench.rs"));

testing/benches/bench.rs.in

@@ -0,0 +1,4 @@
+mod bench_enum;
+mod bench_map;
+mod bench_struct;
+mod bench_vec;

testing/benches/bench_enum.rs

@@ -0,0 +1,466 @@
+use test::Bencher;
+use std::error;
+use std::fmt;
+use rustc_serialize::Decodable;
+use serde;
+use serde::de::Deserialize;
+
+//////////////////////////////////////////////////////////////////////////////
+
+#[derive(Clone, PartialEq, Debug, RustcDecodable, Deserialize)]
+pub enum Animal {
+    Dog,
+    Frog(String, isize)
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+#[derive(Debug)]
+pub enum Error {
+    EndOfStream,
+    Syntax,
+}
+
+impl serde::de::Error for Error {
+    fn custom<T: Into<String>>(_: T) -> Error { Error::Syntax }
+
+    fn end_of_stream() -> Error { Error::EndOfStream }
+
+    fn unknown_field(_: &str) -> Error { Error::Syntax }
+
+    fn missing_field(_: &'static str) -> Error { Error::Syntax }
+}
+
+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
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+mod decoder {
+    use rustc_serialize::Decoder;
+
+    use super::{Animal, Error};
+    use super::Animal::{Dog, Frog};
+
+    enum State {
+        Animal(Animal),
+        Isize(isize),
+        String(String),
+    }
+
+    pub struct AnimalDecoder {
+        stack: Vec<State>,
+
+    }
+
+    impl AnimalDecoder {
+        #[inline]
+        pub fn new(animal: Animal) -> AnimalDecoder {
+            AnimalDecoder {
+                stack: vec!(State::Animal(animal)),
+            }
+        }
+    }
+
+    impl Decoder for AnimalDecoder {
+        type Error = Error;
+
+        fn error(&mut self, _: &str) -> Error { Error::Syntax }
+
+        // Primitive types:
+        fn read_nil(&mut self) -> Result<(), Error> { Err(Error::Syntax) }
+        fn read_usize(&mut self) -> Result<usize, Error> { Err(Error::Syntax) }
+        fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::Syntax) }
+        fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::Syntax) }
+        fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::Syntax) }
+        fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::Syntax) }
+        #[inline]
+        fn read_isize(&mut self) -> Result<isize, Error> {
+            match self.stack.pop() {
+                Some(State::Isize(x)) => Ok(x),
+                _ => Err(Error::Syntax),
+            }
+        }
+        fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::Syntax) }
+        fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::Syntax) }
+        fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::Syntax) }
+        fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::Syntax) }
+        fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::Syntax) }
+        fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::Syntax) }
+        fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::Syntax) }
+        fn read_char(&mut self) -> Result<char, Error> { Err(Error::Syntax) }
+        #[inline]
+        fn read_str(&mut self) -> Result<String, Error> {
+            match self.stack.pop() {
+                Some(State::String(x)) => Ok(x),
+                _ => Err(Error::Syntax),
+            }
+        }
+
+        // Compound types:
+        #[inline]
+        fn read_enum<T, F>(&mut self, name: &str, f: F) -> Result<T, Error> where
+            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
+        {
+            match self.stack.pop() {
+                Some(State::Animal(animal)) => {
+                    self.stack.push(State::Animal(animal));
+                    if name == "Animal" {
+                        f(self)
+                    } else {
+                        Err(Error::Syntax)
+                    }
+                }
+                _ => Err(Error::Syntax)
+            }
+        }
+
+        #[inline]
+        fn read_enum_variant<T, F>(&mut self, names: &[&str], f: F) -> Result<T, Error> where
+            F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>,
+        {
+            let name = match self.stack.pop() {
+                Some(State::Animal(Dog)) => "Dog",
+                Some(State::Animal(Frog(x0, x1))) => {
+                    self.stack.push(State::Isize(x1));
+                    self.stack.push(State::String(x0));
+                    "Frog"
+                }
+                _ => { return Err(Error::Syntax); }
+            };
+
+            let idx = match names.iter().position(|n| *n == name) {
+                Some(idx) => idx,
+                None => { return Err(Error::Syntax); }
+            };
+
+            f(self, idx)
+        }
+
+        #[inline]
+        fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, f: F) -> Result<T, Error> where
+            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
+        {
+            f(self)
+        }
+
+        fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        // Specialized types:
+        fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut AnimalDecoder, bool) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        #[inline]
+        fn read_seq<T, F>(&mut self, f: F) -> Result<T, Error> where
+            F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>,
+        {
+            f(self, 3)
+        }
+
+        #[inline]
+        fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
+            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
+        {
+            f(self)
+        }
+
+        fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_map_elt_key<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_map_elt_val<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+mod deserializer {
+    use super::{Animal, Error};
+
+    use serde::de;
+
+    #[derive(Debug)]
+    enum State {
+        Animal(Animal),
+        Isize(isize),
+        Str(&'static str),
+        String(String),
+        UnitState,
+    }
+
+    pub struct AnimalDeserializer {
+        stack: Vec<State>,
+    }
+
+    impl AnimalDeserializer {
+        #[inline]
+        pub fn new(animal: Animal) -> AnimalDeserializer {
+            AnimalDeserializer {
+                stack: vec!(State::Animal(animal)),
+            }
+        }
+    }
+
+    impl de::Deserializer for AnimalDeserializer {
+        type Error = Error;
+
+        #[inline]
+        fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+            where V: de::Visitor,
+        {
+            match self.stack.pop() {
+                Some(State::Isize(value)) => {
+                    visitor.visit_isize(value)
+                }
+                Some(State::String(value)) => {
+                    visitor.visit_string(value)
+                }
+                Some(State::Str(value)) => {
+                    visitor.visit_str(value)
+                }
+                Some(State::UnitState) => {
+                    visitor.visit_unit()
+                }
+                Some(_) => {
+                    Err(Error::Syntax)
+                }
+                None => {
+                    Err(Error::EndOfStream)
+                }
+            }
+        }
+
+        #[inline]
+        fn deserialize_enum<V>(&mut self,
+                         _name: &str,
+                         _variants: &[&str],
+                         mut visitor: V) -> Result<V::Value, Error>
+            where V: de::EnumVisitor,
+        {
+            match self.stack.pop() {
+                Some(State::Animal(Animal::Dog)) => {
+                    self.stack.push(State::UnitState);
+                    self.stack.push(State::Str("Dog"));
+                    visitor.visit(DogVisitor {
+                        de: self,
+                    })
+                }
+                Some(State::Animal(Animal::Frog(x0, x1))) => {
+                    self.stack.push(State::Isize(x1));
+                    self.stack.push(State::String(x0));
+                    self.stack.push(State::Str("Frog"));
+                    visitor.visit(FrogVisitor {
+                        de: self,
+                        state: 0,
+                    })
+                }
+                Some(_) => {
+                    Err(Error::Syntax)
+                }
+                None => {
+                    Err(Error::EndOfStream)
+                }
+            }
+        }
+    }
+
+    struct DogVisitor<'a> {
+        de: &'a mut AnimalDeserializer,
+    }
+
+    impl<'a> de::VariantVisitor for DogVisitor<'a> {
+        type Error = Error;
+
+        fn visit_variant<V>(&mut self) -> Result<V, Error>
+            where V: de::Deserialize
+        {
+            de::Deserialize::deserialize(self.de)
+        }
+
+        fn visit_unit(&mut self) -> Result<(), Error> {
+            de::Deserialize::deserialize(self.de)
+        }
+    }
+
+    struct FrogVisitor<'a> {
+        de: &'a mut AnimalDeserializer,
+        state: usize,
+    }
+
+    impl<'a> de::VariantVisitor for FrogVisitor<'a> {
+        type Error = Error;
+
+        fn visit_variant<V>(&mut self) -> Result<V, Error>
+            where V: de::Deserialize
+        {
+            de::Deserialize::deserialize(self.de)
+        }
+
+        fn visit_tuple<V>(&mut self,
+                          _len: usize,
+                          mut visitor: V) -> Result<V::Value, Error>
+            where V: de::Visitor,
+        {
+            visitor.visit_seq(self)
+        }
+    }
+
+    impl<'a> de::SeqVisitor for FrogVisitor<'a> {
+        type Error = Error;
+
+        fn visit<T>(&mut self) -> Result<Option<T>, Error>
+            where T: de::Deserialize,
+        {
+            match self.state {
+                0 => {
+                    self.state += 1;
+                    Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+                }
+                1 => {
+                    self.state += 1;
+                    Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+                }
+                _ => {
+                    Ok(None)
+                }
+            }
+        }
+
+        fn end(&mut self) -> Result<(), Error> {
+            if self.state == 2 {
+                Ok(())
+            } else {
+                Err(Error::Syntax)
+            }
+        }
+
+        fn size_hint(&self) -> (usize, Option<usize>) {
+            let len = 2 - self.state;
+            (len, Some(len))
+        }
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+#[bench]
+fn bench_decoder_dog(b: &mut Bencher) {
+    b.iter(|| {
+        let animal = Animal::Dog;
+
+        let mut d = decoder::AnimalDecoder::new(animal.clone());
+        let value: Animal = Decodable::decode(&mut d).unwrap();
+
+        assert_eq!(value, animal);
+    })
+}
+
+#[bench]
+fn bench_decoder_frog(b: &mut Bencher) {
+    b.iter(|| {
+        let animal = Animal::Frog("Henry".to_owned(), 349);
+
+        let mut d = decoder::AnimalDecoder::new(animal.clone());
+        let value: Animal = Decodable::decode(&mut d).unwrap();
+
+        assert_eq!(value, animal);
+    })
+}
+
+#[bench]
+fn bench_deserializer_dog(b: &mut Bencher) {
+    b.iter(|| {
+        let animal = Animal::Dog;
+
+        let mut d = deserializer::AnimalDeserializer::new(animal.clone());
+        let value: Animal = Deserialize::deserialize(&mut d).unwrap();
+
+        assert_eq!(value, animal);
+    })
+}
+
+#[bench]
+fn bench_deserializer_frog(b: &mut Bencher) {
+    b.iter(|| {
+        let animal = Animal::Frog("Henry".to_owned(), 349);
+
+        let mut d = deserializer::AnimalDeserializer::new(animal.clone());
+        let value: Animal = Deserialize::deserialize(&mut d).unwrap();
+
+        assert_eq!(value, animal);
+    })
+}

testing/benches/bench_map.rs

@@ -0,0 +1,474 @@
+use std::fmt::Debug;
+use std::fmt;
+use std::error;
+use std::collections::HashMap;
+use test::Bencher;
+
+use rustc_serialize::{Decoder, Decodable};
+
+use serde;
+use serde::de::{Deserializer, Deserialize};
+
+//////////////////////////////////////////////////////////////////////////////
+
+#[derive(PartialEq, Debug)]
+pub enum Error {
+    EndOfStream,
+    Syntax,
+    MissingField,
+}
+
+impl serde::de::Error for Error {
+    fn custom<T: Into<String>>(_: T) -> Error { Error::Syntax }
+
+    fn end_of_stream() -> Error { Error::EndOfStream }
+
+    fn unknown_field(_: &str) -> Error { Error::Syntax }
+
+    fn missing_field(_: &'static str) -> Error {
+        Error::MissingField
+    }
+}
+
+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
+    }
+}
+//////////////////////////////////////////////////////////////////////////////
+
+mod decoder {
+    use std::collections::HashMap;
+    use std::collections::hash_map::IntoIter;
+    use rustc_serialize;
+
+    use super::Error;
+
+    enum Value {
+        String(String),
+        Isize(isize),
+    }
+
+    pub struct IsizeDecoder {
+        len: usize,
+        iter: IntoIter<String, isize>,
+        stack: Vec<Value>,
+    }
+
+    impl IsizeDecoder {
+        #[inline]
+        pub fn new(values: HashMap<String, isize>) -> IsizeDecoder {
+            IsizeDecoder {
+                len: values.len(),
+                iter: values.into_iter(),
+                stack: vec!(),
+            }
+        }
+    }
+
+    impl rustc_serialize::Decoder for IsizeDecoder {
+        type Error = Error;
+
+        fn error(&mut self, _msg: &str) -> Error {
+            Error::Syntax
+        }
+
+        // Primitive types:
+        fn read_nil(&mut self) -> Result<(), Error> { Err(Error::Syntax) }
+        fn read_usize(&mut self) -> Result<usize, Error> { Err(Error::Syntax) }
+        fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::Syntax) }
+        fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::Syntax) }
+        fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::Syntax) }
+        fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::Syntax) }
+        #[inline]
+        fn read_isize(&mut self) -> Result<isize, Error> {
+            match self.stack.pop() {
+                Some(Value::Isize(x)) => Ok(x),
+                Some(_) => Err(Error::Syntax),
+                None => Err(Error::EndOfStream),
+            }
+        }
+        fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::Syntax) }
+        fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::Syntax) }
+        fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::Syntax) }
+        fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::Syntax) }
+        fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::Syntax) }
+        fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::Syntax) }
+        fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::Syntax) }
+        fn read_char(&mut self) -> Result<char, Error> { Err(Error::Syntax) }
+        #[inline]
+        fn read_str(&mut self) -> Result<String, Error> {
+            match self.stack.pop() {
+                Some(Value::String(x)) => Ok(x),
+                Some(_) => Err(Error::Syntax),
+                None => Err(Error::EndOfStream),
+            }
+        }
+
+        // Compound types:
+        fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        // Specialized types:
+        fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder, bool) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_seq<T, F>(&mut self, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_seq_elt<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        #[inline]
+        fn read_map<T, F>(&mut self, f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
+        {
+            let len = self.len;
+            f(self, len)
+        }
+        #[inline]
+        fn read_map_elt_key<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
+        {
+            match self.iter.next() {
+                Some((key, value)) => {
+                    self.stack.push(Value::Isize(value));
+                    self.stack.push(Value::String(key));
+                    f(self)
+                }
+                None => {
+                    Err(Error::Syntax)
+                }
+            }
+        }
+
+        #[inline]
+        fn read_map_elt_val<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
+        {
+            f(self)
+        }
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+mod deserializer {
+    use std::collections::HashMap;
+    use std::collections::hash_map;
+
+    use super::Error;
+
+    use serde::de;
+
+    #[derive(PartialEq, Debug)]
+    enum State {
+        StartState,
+        Key(String),
+        Value(isize),
+    }
+
+    pub struct IsizeDeserializer {
+        stack: Vec<State>,
+        iter: hash_map::IntoIter<String, isize>,
+    }
+
+    impl IsizeDeserializer {
+        #[inline]
+        pub fn new(values: HashMap<String, isize>) -> IsizeDeserializer {
+            IsizeDeserializer {
+                stack: vec!(State::StartState),
+                iter: values.into_iter(),
+            }
+        }
+    }
+
+    impl de::Deserializer for IsizeDeserializer {
+        type Error = Error;
+
+        fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+            where V: de::Visitor,
+        {
+            match self.stack.pop() {
+                Some(State::StartState) => {
+                    visitor.visit_map(self)
+                }
+                Some(State::Key(key)) => {
+                    visitor.visit_string(key)
+                }
+                Some(State::Value(value)) => {
+                    visitor.visit_isize(value)
+                }
+                None => {
+                    Err(Error::EndOfStream)
+                }
+            }
+        }
+    }
+
+    impl de::MapVisitor for IsizeDeserializer {
+        type Error = Error;
+
+        fn visit_key<K>(&mut self) -> Result<Option<K>, Error>
+            where K: de::Deserialize,
+        {
+            match self.iter.next() {
+                Some((key, value)) => {
+                    self.stack.push(State::Value(value));
+                    self.stack.push(State::Key(key));
+                    Ok(Some(try!(de::Deserialize::deserialize(self))))
+                }
+                None => {
+                    Ok(None)
+                }
+            }
+        }
+
+        fn visit_value<V>(&mut self) -> Result<V, Error>
+            where V: de::Deserialize,
+        {
+            de::Deserialize::deserialize(self)
+        }
+
+        fn end(&mut self) -> Result<(), Error> {
+            match self.iter.next() {
+                Some(_) => Err(Error::Syntax),
+                None => Ok(()),
+            }
+        }
+
+        fn size_hint(&self) -> (usize, Option<usize>) {
+            self.iter.size_hint()
+        }
+    }
+
+/*
+    impl Iterator for IsizeDeserializer {
+        type Item = Result<de::Token, Error>;
+
+        #[inline]
+        fn next(&mut self) -> Option<Result<de::Token, Error>> {
+            match self.stack.pop() {
+                Some(State::StartState) => {
+                    self.stack.push(KeyOrEndState);
+                    Some(Ok(de::Token::MapStart(self.len)))
+                }
+                Some(State::KeyOrEndState) => {
+                    match self.iter.next() {
+                        Some((key, value)) => {
+                            self.stack.push(Value(value));
+                            Some(Ok(de::Token::String(key)))
+                        }
+                        None => {
+                            self.stack.push(EndState);
+                            Some(Ok(de::Token::End))
+                        }
+                    }
+                }
+                Some(State::Value(x)) => {
+                    self.stack.push(KeyOrEndState);
+                    Some(Ok(de::Token::Isize(x)))
+                }
+                Some(EndState) => {
+                    None
+                }
+                None => {
+                    None
+                }
+            }
+        }
+    }
+
+    impl de::Deserializer<Error> for IsizeDeserializer {
+        #[inline]
+        fn end_of_stream(&mut self) -> Error {
+            EndOfStream
+        }
+
+        #[inline]
+        fn syntax(&mut self, _token: de::Token, _expected: &[de::TokenKind]) -> Error {
+            Syntax
+        }
+
+        #[inline]
+        fn unexpected_name(&mut self, _token: de::Token) -> Error {
+            Syntax
+        }
+
+        #[inline]
+        fn conversion_error(&mut self, _token: de::Token) -> Error {
+            Syntax
+        }
+
+        #[inline]
+        fn missing_field<
+            T: de::Deserialize<IsizeDeserializer, Error>
+        >(&mut self, _field: &'static str) -> Result<T, Error> {
+            Err(Error::Syntax)
+        }
+    }
+*/
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+fn run_decoder<
+    D: Decoder<Error=Error>,
+    T: Clone + PartialEq + Debug + Decodable
+>(mut d: D, value: T) {
+    let v = Decodable::decode(&mut d);
+
+    assert_eq!(Ok(value), v);
+}
+
+#[bench]
+fn bench_decoder_000(b: &mut Bencher) {
+    b.iter(|| {
+        let m: HashMap<String, isize> = HashMap::new();
+        run_decoder(decoder::IsizeDecoder::new(m.clone()), m)
+    })
+}
+
+#[bench]
+fn bench_decoder_003(b: &mut Bencher) {
+    b.iter(|| {
+        let mut m: HashMap<String, isize> = HashMap::new();
+        for i in 0 .. 3 {
+            m.insert(i.to_string(), i);
+        }
+        run_decoder(decoder::IsizeDecoder::new(m.clone()), m)
+    })
+}
+
+#[bench]
+fn bench_decoder_100(b: &mut Bencher) {
+    b.iter(|| {
+        let mut m: HashMap<String, isize> = HashMap::new();
+        for i in 0 .. 100 {
+            m.insert(i.to_string(), i);
+        }
+        run_decoder(decoder::IsizeDecoder::new(m.clone()), m)
+    })
+}
+
+fn run_deserializer<D, T>(mut d: D, value: T)
+    where D: Deserializer,
+          D::Error: Debug + PartialEq,
+          T: Clone + PartialEq + Debug + Deserialize
+{
+    let v = T::deserialize(&mut d);
+
+    assert_eq!(Ok(value), v);
+}
+
+#[bench]
+fn bench_deserializer_000(b: &mut Bencher) {
+    b.iter(|| {
+        let m: HashMap<String, isize> = HashMap::new();
+        run_deserializer(deserializer::IsizeDeserializer::new(m.clone()), m)
+    })
+}
+
+#[bench]
+fn bench_deserializer_003(b: &mut Bencher) {
+    b.iter(|| {
+        let mut m: HashMap<String, isize> = HashMap::new();
+        for i in 0 .. 3 {
+            m.insert(i.to_string(), i);
+        }
+        run_deserializer(deserializer::IsizeDeserializer::new(m.clone()), m)
+    })
+}
+
+#[bench]
+fn bench_deserializer_100(b: &mut Bencher) {
+    b.iter(|| {
+        let mut m: HashMap<String, isize> = HashMap::new();
+        for i in 0 .. 100 {
+            m.insert(i.to_string(), i);
+        }
+        run_deserializer(deserializer::IsizeDeserializer::new(m.clone()), m)
+    })
+}

testing/benches/bench_struct.rs

@@ -0,0 +1,745 @@
+use std::collections::HashMap;
+use test::Bencher;
+use std::fmt;
+use std::error;
+
+use rustc_serialize::Decodable;
+
+use serde;
+use serde::de::Deserialize;
+
+//////////////////////////////////////////////////////////////////////////////
+
+#[derive(Clone, PartialEq, Debug, RustcDecodable, Deserialize)]
+pub struct Inner {
+    a: (),
+    b: usize,
+    c: HashMap<String, Option<char>>,
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+#[derive(Clone, PartialEq, Debug, RustcDecodable, Deserialize)]
+pub struct Outer {
+    inner: Vec<Inner>,
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+#[derive(Debug, PartialEq)]
+pub enum Error {
+    EndOfStream,
+    Syntax,
+    MissingField,
+    OtherError,
+}
+
+impl serde::de::Error for Error {
+    fn custom<T: Into<String>>(_: T) -> Error { Error::Syntax }
+
+    fn end_of_stream() -> Error { Error::EndOfStream }
+
+    fn unknown_field(_: &str) -> Error { Error::Syntax }
+
+    fn missing_field(_: &'static str) -> Error {
+        Error::MissingField
+    }
+}
+
+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
+    }
+}
+
+mod decoder {
+    use std::collections::HashMap;
+    use rustc_serialize::Decoder;
+
+    use super::{Outer, Inner, Error};
+
+    #[derive(Debug)]
+    enum State {
+        Outer(Outer),
+        Inner(Inner),
+        Null,
+        Usize(usize),
+        Char(char),
+        String(String),
+        Field(&'static str),
+        Vec(Vec<Inner>),
+        Map(HashMap<String, Option<char>>),
+        Option(bool),
+    }
+
+    pub struct OuterDecoder {
+        stack: Vec<State>,
+
+    }
+
+    impl OuterDecoder {
+        #[inline]
+        pub fn new(animal: Outer) -> OuterDecoder {
+            OuterDecoder {
+                stack: vec!(State::Outer(animal)),
+            }
+        }
+    }
+
+    impl Decoder for OuterDecoder {
+        type Error = Error;
+
+        fn error(&mut self, _msg: &str) -> Error {
+            Error::OtherError
+        }
+
+        // Primitive types:
+        #[inline]
+        fn read_nil(&mut self) -> Result<(), Error> {
+            match self.stack.pop() {
+                Some(State::Null) => Ok(()),
+                _ => Err(Error::Syntax),
+            }
+        }
+        #[inline]
+        fn read_usize(&mut self) -> Result<usize, Error> {
+            match self.stack.pop() {
+                Some(State::Usize(value)) => Ok(value),
+                _ => Err(Error::Syntax),
+            }
+        }
+        fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::Syntax) }
+        fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::Syntax) }
+        fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::Syntax) }
+        fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::Syntax) }
+        fn read_isize(&mut self) -> Result<isize, Error> { Err(Error::Syntax) }
+        fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::Syntax) }
+        fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::Syntax) }
+        fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::Syntax) }
+        fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::Syntax) }
+        fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::Syntax) }
+        fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::Syntax) }
+        fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::Syntax) }
+        #[inline]
+        fn read_char(&mut self) -> Result<char, Error> {
+            match self.stack.pop() {
+                Some(State::Char(c)) => Ok(c),
+                _ => Err(Error::Syntax),
+            }
+        }
+        #[inline]
+        fn read_str(&mut self) -> Result<String, Error> {
+            match self.stack.pop() {
+                Some(State::String(value)) => Ok(value),
+                _ => Err(Error::Syntax),
+            }
+        }
+
+        // Compound types:
+        fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        #[inline]
+        fn read_struct<T, F>(&mut self, s_name: &str, _len: usize, f: F) -> Result<T, Error> where
+            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
+        {
+            match self.stack.pop() {
+                Some(State::Outer(Outer { inner })) => {
+                    if s_name == "Outer" {
+                        self.stack.push(State::Vec(inner));
+                        self.stack.push(State::Field("inner"));
+                        f(self)
+                    } else {
+                        Err(Error::Syntax)
+                    }
+                }
+                Some(State::Inner(Inner { a: (), b, c })) => {
+                    if s_name == "Inner" {
+                        self.stack.push(State::Map(c));
+                        self.stack.push(State::Field("c"));
+
+                        self.stack.push(State::Usize(b));
+                        self.stack.push(State::Field("b"));
+
+                        self.stack.push(State::Null);
+                        self.stack.push(State::Field("a"));
+                        f(self)
+                    } else {
+                        Err(Error::Syntax)
+                    }
+                }
+                _ => Err(Error::Syntax),
+            }
+        }
+        #[inline]
+        fn read_struct_field<T, F>(&mut self, f_name: &str, _f_idx: usize, f: F) -> Result<T, Error> where
+            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
+        {
+            match self.stack.pop() {
+                Some(State::Field(name)) => {
+                    if f_name == name {
+                        f(self)
+                    } else {
+                        Err(Error::Syntax)
+                    }
+                }
+                _ => Err(Error::Syntax)
+            }
+        }
+
+        fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        // Specialized types:
+        #[inline]
+        fn read_option<T, F>(&mut self, f: F) -> Result<T, Error> where
+            F: FnOnce(&mut OuterDecoder, bool) -> Result<T, Error>,
+        {
+            match self.stack.pop() {
+                Some(State::Option(b)) => f(self, b),
+                _ => Err(Error::Syntax),
+            }
+        }
+
+        #[inline]
+        fn read_seq<T, F>(&mut self, f: F) -> Result<T, Error> where
+            F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>,
+        {
+            match self.stack.pop() {
+                Some(State::Vec(value)) => {
+                    let len = value.len();
+                    for inner in value.into_iter().rev() {
+                        self.stack.push(State::Inner(inner));
+                    }
+                    f(self, len)
+                }
+                _ => Err(Error::Syntax)
+            }
+        }
+        #[inline]
+        fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
+            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
+        {
+            f(self)
+        }
+
+        #[inline]
+        fn read_map<T, F>(&mut self, f: F) -> Result<T, Error> where
+            F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>,
+        {
+            match self.stack.pop() {
+                Some(State::Map(map)) => {
+                    let len = map.len();
+                    for (key, value) in map {
+                        match value {
+                            Some(c) => {
+                                self.stack.push(State::Char(c));
+                                self.stack.push(State::Option(true));
+                            }
+                            None => {
+                                self.stack.push(State::Option(false));
+                            }
+                        }
+                        self.stack.push(State::String(key));
+                    }
+                    f(self, len)
+                }
+                _ => Err(Error::Syntax),
+            }
+        }
+        #[inline]
+        fn read_map_elt_key<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
+            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
+        {
+            f(self)
+        }
+
+        #[inline]
+        fn read_map_elt_val<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
+            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
+        {
+            f(self)
+        }
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+mod deserializer {
+    use std::collections::HashMap;
+    use std::collections::hash_map;
+    use std::vec;
+    use super::{Outer, Inner};
+    use super::Error;
+    use serde::de;
+
+    #[derive(Debug)]
+    enum State {
+        Outer(Outer),
+        Inner(Inner),
+        Str(&'static str),
+        Null,
+        Usize(usize),
+        Char(char),
+        String(String),
+        Option(bool),
+        Vec(Vec<Inner>),
+        Map(HashMap<String, Option<char>>),
+    }
+
+    pub struct OuterDeserializer {
+        stack: Vec<State>,
+    }
+
+    impl OuterDeserializer {
+        #[inline]
+        pub fn new(outer: Outer) -> OuterDeserializer {
+            OuterDeserializer {
+                stack: vec!(State::Outer(outer)),
+            }
+        }
+    }
+
+    impl de::Deserializer for OuterDeserializer {
+        type Error = Error;
+
+        fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+            where V: de::Visitor,
+        {
+            match self.stack.pop() {
+                Some(State::Vec(value)) => {
+                    visitor.visit_seq(OuterSeqVisitor {
+                        de: self,
+                        iter: value.into_iter(),
+                    })
+                }
+                Some(State::Map(value)) => {
+                    visitor.visit_map(MapVisitor {
+                        de: self,
+                        iter: value.into_iter(),
+                    })
+                }
+                Some(State::Null) => {
+                    visitor.visit_unit()
+                }
+                Some(State::Usize(x)) => {
+                    visitor.visit_usize(x)
+                }
+                Some(State::Char(x)) => {
+                    visitor.visit_char(x)
+                }
+                Some(State::Str(x)) => {
+                    visitor.visit_str(x)
+                }
+                Some(State::String(x)) => {
+                    visitor.visit_string(x)
+                }
+                Some(State::Option(false)) => {
+                    visitor.visit_none()
+                }
+                Some(State::Option(true)) => {
+                    visitor.visit_some(self)
+                }
+                Some(_) => Err(Error::Syntax),
+                None => Err(Error::EndOfStream),
+            }
+        }
+
+        fn deserialize_struct<V>(&mut self,
+                           name: &str,
+                           _fields: &'static [&'static str],
+                           mut visitor: V) -> Result<V::Value, Error>
+            where V: de::Visitor,
+        {
+            match self.stack.pop() {
+                Some(State::Outer(Outer { inner })) => {
+                    if name != "Outer" {
+                        return Err(Error::Syntax);
+                    }
+
+                    self.stack.push(State::Vec(inner));
+                    self.stack.push(State::Str("inner"));
+
+                    visitor.visit_map(OuterMapVisitor {
+                        de: self,
+                        state: 0,
+                    })
+                }
+                Some(State::Inner(Inner { a: (), b, c })) => {
+                    if name != "Inner" {
+                        return Err(Error::Syntax);
+                    }
+
+                    self.stack.push(State::Map(c));
+                    self.stack.push(State::Str("c"));
+
+                    self.stack.push(State::Usize(b));
+                    self.stack.push(State::Str("b"));
+
+                    self.stack.push(State::Null);
+                    self.stack.push(State::Str("a"));
+
+                    visitor.visit_map(InnerMapVisitor {
+                        de: self,
+                        state: 0,
+                    })
+                }
+                _ => {
+                    Err(Error::Syntax)
+                }
+            }
+        }
+    }
+
+    struct OuterMapVisitor<'a> {
+        de: &'a mut OuterDeserializer,
+        state: usize,
+    }
+
+    impl<'a> de::MapVisitor for OuterMapVisitor<'a> {
+        type Error = Error;
+
+        fn visit_key<K>(&mut self) -> Result<Option<K>, Error>
+            where K: de::Deserialize,
+        {
+            match self.state {
+                0 => {
+                    self.state += 1;
+                    Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+                }
+                _ => {
+                    Ok(None)
+                }
+            }
+        }
+
+        fn visit_value<V>(&mut self) -> Result<V, Error>
+            where V: de::Deserialize,
+        {
+            de::Deserialize::deserialize(self.de)
+        }
+
+        fn end(&mut self) -> Result<(), Error> {
+            if self.state == 1 {
+                Ok(())
+            } else {
+                Err(Error::Syntax)
+            }
+        }
+
+        fn size_hint(&self) -> (usize, Option<usize>) {
+            let len = 1 - self.state;
+            (len, Some(len))
+        }
+    }
+
+    struct OuterSeqVisitor<'a> {
+        de: &'a mut OuterDeserializer,
+        iter: vec::IntoIter<Inner>,
+    }
+
+    impl<'a> de::SeqVisitor for OuterSeqVisitor<'a> {
+        type Error = Error;
+
+        fn visit<T>(&mut self) -> Result<Option<T>, Error>
+            where T: de::Deserialize,
+        {
+            match self.iter.next() {
+                Some(value) => {
+                    self.de.stack.push(State::Inner(value));
+                    Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+                }
+                None => {
+                    Ok(None)
+                }
+            }
+        }
+
+        fn end(&mut self) -> Result<(), Error> {
+            match self.iter.next() {
+                Some(_) => Err(Error::Syntax),
+                None => Ok(()),
+            }
+        }
+
+        fn size_hint(&self) -> (usize, Option<usize>) {
+            self.iter.size_hint()
+        }
+    }
+
+    struct InnerMapVisitor<'a> {
+        de: &'a mut OuterDeserializer,
+        state: usize,
+    }
+
+    impl<'a> de::MapVisitor for InnerMapVisitor<'a> {
+        type Error = Error;
+
+        fn visit_key<K>(&mut self) -> Result<Option<K>, Error>
+            where K: de::Deserialize,
+        {
+            match self.state {
+                0 ... 2 => {
+                    self.state += 1;
+                    Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+                }
+                _ => {
+                    Ok(None)
+                }
+            }
+        }
+
+        fn visit_value<V>(&mut self) -> Result<V, Error>
+            where V: de::Deserialize,
+        {
+            de::Deserialize::deserialize(self.de)
+        }
+
+        fn end(&mut self) -> Result<(), Error> {
+            if self.state == 3 {
+                Ok(())
+            } else {
+                Err(Error::Syntax)
+            }
+        }
+
+        fn size_hint(&self) -> (usize, Option<usize>) {
+            let len = 1 - self.state;
+            (len, Some(len))
+        }
+    }
+
+    struct MapVisitor<'a> {
+        de: &'a mut OuterDeserializer,
+        iter: hash_map::IntoIter<String, Option<char>>,
+    }
+
+    impl<'a> de::MapVisitor for MapVisitor<'a> {
+        type Error = Error;
+
+        fn visit_key<K>(&mut self) -> Result<Option<K>, Error>
+            where K: de::Deserialize,
+        {
+            match self.iter.next() {
+                Some((key, Some(value))) => {
+                    self.de.stack.push(State::Char(value));
+                    self.de.stack.push(State::Option(true));
+                    self.de.stack.push(State::String(key));
+                    Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+                }
+                Some((key, None)) => {
+                    self.de.stack.push(State::Option(false));
+                    self.de.stack.push(State::String(key));
+                    Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+                }
+                None => {
+                    Ok(None)
+                }
+            }
+        }
+
+        fn visit_value<V>(&mut self) -> Result<V, Error>
+            where V: de::Deserialize,
+        {
+            de::Deserialize::deserialize(self.de)
+        }
+
+        fn end(&mut self) -> Result<(), Error> {
+            match self.iter.next() {
+                Some(_) => Err(Error::Syntax),
+                None => Ok(()),
+            }
+        }
+
+        fn size_hint(&self) -> (usize, Option<usize>) {
+            self.iter.size_hint()
+        }
+    }
+}
+
+#[bench]
+fn bench_decoder_0_0(b: &mut Bencher) {
+    b.iter(|| {
+        let mut map = HashMap::new();
+        map.insert("abc".to_owned(), Some('c'));
+
+        let outer = Outer {
+            inner: vec!(),
+        };
+
+        let mut d = decoder::OuterDecoder::new(outer.clone());
+        let value: Result<Outer, Error> = Decodable::decode(&mut d);
+
+        assert_eq!(value, Ok(outer));
+    })
+}
+
+#[bench]
+fn bench_decoder_1_0(b: &mut Bencher) {
+    b.iter(|| {
+        let map = HashMap::new();
+
+        let outer = Outer {
+            inner: vec!(
+                Inner {
+                    a: (),
+                    b: 5,
+                    c: map,
+                },
+            )
+        };
+
+        let mut d = decoder::OuterDecoder::new(outer.clone());
+        let value: Result<Outer, Error> = Decodable::decode(&mut d);
+
+        assert_eq!(value, Ok(outer));
+    })
+}
+
+#[bench]
+fn bench_decoder_1_5(b: &mut Bencher) {
+    b.iter(|| {
+        let mut map = HashMap::new();
+        map.insert("1".to_owned(), Some('a'));
+        map.insert("2".to_owned(), None);
+        map.insert("3".to_owned(), Some('b'));
+        map.insert("4".to_owned(), None);
+        map.insert("5".to_owned(), Some('c'));
+
+        let outer = Outer {
+            inner: vec!(
+                Inner {
+                    a: (),
+                    b: 5,
+                    c: map,
+                },
+            )
+        };
+
+        let mut d = decoder::OuterDecoder::new(outer.clone());
+        let value: Result<Outer, Error> = Decodable::decode(&mut d);
+
+        assert_eq!(value, Ok(outer));
+    })
+}
+
+#[bench]
+fn bench_deserializer_0_0(b: &mut Bencher) {
+    b.iter(|| {
+        let outer = Outer {
+            inner: vec!(),
+        };
+
+        let mut d = deserializer::OuterDeserializer::new(outer.clone());
+        let value: Result<Outer, Error> = Deserialize::deserialize(&mut d);
+
+        assert_eq!(value, Ok(outer));
+    })
+}
+
+#[bench]
+fn bench_deserializer_1_0(b: &mut Bencher) {
+    b.iter(|| {
+        let map = HashMap::new();
+
+        let outer = Outer {
+            inner: vec!(
+                Inner {
+                    a: (),
+                    b: 5,
+                    c: map,
+                },
+            )
+        };
+
+        let mut d = deserializer::OuterDeserializer::new(outer.clone());
+        let value: Result<Outer, Error> = Deserialize::deserialize(&mut d);
+
+        assert_eq!(value, Ok(outer));
+    })
+}
+
+#[bench]
+fn bench_deserializer_1_5(b: &mut Bencher) {
+    b.iter(|| {
+        let mut map = HashMap::new();
+        map.insert("1".to_owned(), Some('a'));
+        map.insert("2".to_owned(), None);
+        map.insert("3".to_owned(), Some('b'));
+        map.insert("4".to_owned(), None);
+        map.insert("5".to_owned(), Some('c'));
+
+        let outer = Outer {
+            inner: vec!(
+                Inner {
+                    a: (),
+                    b: 5,
+                    c: map,
+                },
+            )
+        };
+
+        let mut d = deserializer::OuterDeserializer::new(outer.clone());
+        let value: Result<Outer, Error> = Deserialize::deserialize(&mut d);
+
+        assert_eq!(value, Ok(outer));
+    })
+}

testing/benches/bench_vec.rs

@@ -0,0 +1,628 @@
+use std::fmt::Debug;
+use std::fmt;
+use std::error;
+use test::Bencher;
+
+use rustc_serialize::{Decoder, Decodable};
+
+use serde;
+use serde::de::{Deserializer, Deserialize};
+
+//////////////////////////////////////////////////////////////////////////////
+
+#[derive(PartialEq, Debug)]
+pub enum Error {
+    EndOfStream,
+    Syntax,
+}
+
+impl serde::de::Error for Error {
+    fn custom<T: Into<String>>(_: T) -> Error { Error::Syntax }
+
+    fn end_of_stream() -> Error { Error::EndOfStream }
+
+    fn unknown_field(_: &str) -> Error { Error::Syntax }
+
+    fn missing_field(_: &'static str) -> Error { Error::Syntax }
+}
+
+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
+    }
+}
+//////////////////////////////////////////////////////////////////////////////
+
+mod decoder {
+    use std::vec;
+    use rustc_serialize;
+
+    use super::Error;
+
+    pub struct UsizeDecoder {
+        len: usize,
+        iter: vec::IntoIter<usize>,
+    }
+
+    impl UsizeDecoder {
+        #[inline]
+        pub fn new(values: Vec<usize>) -> UsizeDecoder {
+            UsizeDecoder {
+                len: values.len(),
+                iter: values.into_iter(),
+            }
+        }
+    }
+
+    impl rustc_serialize::Decoder for UsizeDecoder {
+        type Error = Error;
+
+        fn error(&mut self, _: &str) -> Error { Error::Syntax }
+
+        // Primitive types:
+        fn read_nil(&mut self) -> Result<(), Error> { Err(Error::Syntax) }
+        #[inline]
+        fn read_usize(&mut self) -> Result<usize, Error> {
+            match self.iter.next() {
+                Some(value) => Ok(value),
+                None => Err(Error::EndOfStream),
+            }
+        }
+        fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::Syntax) }
+        fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::Syntax) }
+        fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::Syntax) }
+        fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::Syntax) }
+        fn read_isize(&mut self) -> Result<isize, Error> { Err(Error::Syntax) }
+        fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::Syntax) }
+        fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::Syntax) }
+        fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::Syntax) }
+        fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::Syntax) }
+        fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::Syntax) }
+        fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::Syntax) }
+        fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::Syntax) }
+        fn read_char(&mut self) -> Result<char, Error> { Err(Error::Syntax) }
+        fn read_str(&mut self) -> Result<String, Error> { Err(Error::Syntax) }
+
+        // Compound types:
+        fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut UsizeDecoder, usize) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut UsizeDecoder, usize) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        // Specialized types:
+        fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut UsizeDecoder, bool) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        #[inline]
+        fn read_seq<T, F>(&mut self, f: F) -> Result<T, Error> where
+            F: FnOnce(&mut UsizeDecoder, usize) -> Result<T, Error>,
+        {
+            let len = self.len;
+            f(self, len)
+        }
+        #[inline]
+        fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
+            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
+        {
+            f(self)
+        }
+
+        fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut UsizeDecoder, usize) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_map_elt_key<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_map_elt_val<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+    }
+
+
+    pub struct U8Decoder {
+        len: usize,
+        iter: vec::IntoIter<u8>,
+    }
+
+    impl U8Decoder {
+        #[inline]
+        pub fn new(values: Vec<u8>) -> U8Decoder {
+            U8Decoder {
+                len: values.len(),
+                iter: values.into_iter(),
+            }
+        }
+    }
+
+    impl rustc_serialize::Decoder for U8Decoder {
+        type Error = Error;
+
+        fn error(&mut self, _: &str) -> Error { Error::Syntax }
+
+        // Primitive types:
+        fn read_nil(&mut self) -> Result<(), Error> { Err(Error::Syntax) }
+        fn read_usize(&mut self) -> Result<usize, Error> { Err(Error::Syntax) }
+        fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::Syntax) }
+        fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::Syntax) }
+        fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::Syntax) }
+        #[inline]
+        fn read_u8(&mut self) -> Result<u8, Error> {
+            match self.iter.next() {
+                Some(value) => Ok(value),
+                None => Err(Error::EndOfStream),
+            }
+        }
+        #[inline]
+        fn read_isize(&mut self) -> Result<isize, Error> { Err(Error::Syntax) }
+        fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::Syntax) }
+        fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::Syntax) }
+        fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::Syntax) }
+        fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::Syntax) }
+        fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::Syntax) }
+        fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::Syntax) }
+        fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::Syntax) }
+        fn read_char(&mut self) -> Result<char, Error> { Err(Error::Syntax) }
+        fn read_str(&mut self) -> Result<String, Error> { Err(Error::Syntax) }
+
+        // Compound types:
+        fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut U8Decoder, usize) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut U8Decoder, usize) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        // Specialized types:
+        fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut U8Decoder, bool) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        #[inline]
+        fn read_seq<T, F>(&mut self, f: F) -> Result<T, Error> where
+            F: FnOnce(&mut U8Decoder, usize) -> Result<T, Error>,
+        {
+            let len = self.len;
+            f(self, len)
+        }
+        #[inline]
+        fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
+            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
+        {
+            f(self)
+        }
+
+        fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut U8Decoder, usize) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_map_elt_key<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+
+        fn read_map_elt_val<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
+        {
+            Err(Error::Syntax)
+        }
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+mod deserializer {
+    //use std::num;
+    use std::vec;
+
+    use super::Error;
+
+    use serde::de;
+
+    #[derive(PartialEq, Debug)]
+    enum State {
+        Start,
+        SepOrEnd,
+        End,
+    }
+
+    pub struct Deserializer<A> {
+        state: State,
+        iter: vec::IntoIter<A>,
+        len: usize,
+        value: Option<A>,
+    }
+
+    impl<A> Deserializer<A> {
+        #[inline]
+        pub fn new(values: Vec<A>) -> Deserializer<A> {
+            let len = values.len();
+            Deserializer {
+                state: State::Start,
+                iter: values.into_iter(),
+                len: len,
+                value: None,
+            }
+        }
+    }
+
+    impl de::Deserializer for Deserializer<usize> {
+        type Error = Error;
+
+        #[inline]
+        fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+            where V: de::Visitor,
+        {
+            match self.state {
+                State::Start => {
+                    self.state = State::SepOrEnd;
+                    visitor.visit_seq(self)
+                }
+                State::SepOrEnd => {
+                    visitor.visit_usize(self.value.take().unwrap())
+                }
+                State::End => {
+                    Err(Error::EndOfStream)
+                }
+            }
+        }
+    }
+
+    impl de::SeqVisitor for Deserializer<usize> {
+        type Error = Error;
+
+        #[inline]
+        fn visit<T>(&mut self) -> Result<Option<T>, Error>
+            where T: de::Deserialize,
+        {
+            match self.iter.next() {
+                Some(value) => {
+                    self.len -= 1;
+                    self.value = Some(value);
+                    Ok(Some(try!(de::Deserialize::deserialize(self))))
+                }
+                None => {
+                    self.state = State::End;
+                    Ok(None)
+                }
+            }
+        }
+
+        #[inline]
+        fn end(&mut self) -> Result<(), Error> {
+            match self.iter.next() {
+                Some(_) => Err(Error::Syntax),
+                None => {
+                    self.state = State::End;
+                    Ok(())
+                }
+            }
+        }
+
+        #[inline]
+        fn size_hint(&self) -> (usize, Option<usize>) {
+            (self.len, Some(self.len))
+        }
+    }
+
+    impl de::Deserializer for Deserializer<u8> {
+        type Error = Error;
+
+        #[inline]
+        fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+            where V: de::Visitor,
+        {
+            match self.state {
+                State::Start => {
+                    self.state = State::SepOrEnd;
+                    visitor.visit_seq(self)
+                }
+                State::SepOrEnd => {
+                    visitor.visit_u8(self.value.take().unwrap())
+                }
+                State::End => {
+                    Err(Error::EndOfStream)
+                }
+            }
+        }
+    }
+
+    impl de::SeqVisitor for Deserializer<u8> {
+        type Error = Error;
+
+        #[inline]
+        fn visit<T>(&mut self) -> Result<Option<T>, Error>
+            where T: de::Deserialize,
+        {
+            match self.iter.next() {
+                Some(value) => {
+                    self.len -= 1;
+                    self.value = Some(value);
+                    Ok(Some(try!(de::Deserialize::deserialize(self))))
+                }
+                None => {
+                    self.state = State::End;
+                    Ok(None)
+                }
+            }
+        }
+
+        #[inline]
+        fn end(&mut self) -> Result<(), Error> {
+            match self.iter.next() {
+                Some(_) => Err(Error::Syntax),
+                None => {
+                    self.state = State::End;
+                    Ok(())
+                }
+            }
+        }
+
+        #[inline]
+        fn size_hint(&self) -> (usize, Option<usize>) {
+            (self.len, Some(self.len))
+        }
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+fn run_decoder<
+    D: Decoder<Error=Error>,
+    T: Clone + PartialEq + Debug + Decodable
+>(mut d: D, value: T) {
+    let v = Decodable::decode(&mut d);
+
+    assert_eq!(Ok(value), v);
+}
+
+fn run_deserializer<D, T>(mut d: D, value: T)
+    where D: Deserializer,
+          D::Error: Debug + PartialEq,
+          T: Clone + PartialEq + Debug + Deserialize
+{
+    let v = T::deserialize(&mut d);
+
+    assert_eq!(Ok(value), v);
+}
+
+#[bench]
+fn bench_decoder_usize_000(b: &mut Bencher) {
+    b.iter(|| {
+        let v: Vec<usize> = vec!();
+        run_decoder(decoder::UsizeDecoder::new(v.clone()), v)
+    })
+}
+
+#[bench]
+fn bench_decoder_usize_003(b: &mut Bencher) {
+    b.iter(|| {
+        let v: Vec<usize> = vec!(1, 2, 3);
+        run_decoder(decoder::UsizeDecoder::new(v.clone()), v)
+    })
+}
+
+#[bench]
+fn bench_decoder_usize_100(b: &mut Bencher) {
+    b.iter(|| {
+        let v: Vec<usize> = (0 .. 100).collect();
+        run_decoder(decoder::UsizeDecoder::new(v.clone()), v)
+    })
+}
+
+#[bench]
+fn bench_decoder_u8_000(b: &mut Bencher) {
+    b.iter(|| {
+        let v: Vec<u8> = vec!();
+        run_decoder(decoder::U8Decoder::new(v.clone()), v)
+    })
+}
+
+#[bench]
+fn bench_decoder_u8_003(b: &mut Bencher) {
+    b.iter(|| {
+        let v: Vec<u8> = vec!(1, 2, 3);
+        run_decoder(decoder::U8Decoder::new(v.clone()), v)
+    })
+}
+
+#[bench]
+fn bench_decoder_u8_100(b: &mut Bencher) {
+    b.iter(|| {
+        let v: Vec<u8> = (0 .. 100).collect();
+        run_decoder(decoder::U8Decoder::new(v.clone()), v)
+    })
+}
+
+#[bench]
+fn bench_deserializer_usize_000(b: &mut Bencher) {
+    b.iter(|| {
+        let v: Vec<usize> = vec!();
+        run_deserializer(deserializer::Deserializer::new(v.clone()), v)
+    })
+}
+
+#[bench]
+fn bench_deserializer_usize_003(b: &mut Bencher) {
+    b.iter(|| {
+        let v: Vec<usize> = vec!(1, 2, 3);
+        run_deserializer(deserializer::Deserializer::new(v.clone()), v)
+    })
+}
+
+#[bench]
+fn bench_deserializer_usize_100(b: &mut Bencher) {
+    b.iter(|| {
+        let v: Vec<usize> = (0 .. 100).collect();
+        run_deserializer(deserializer::Deserializer::new(v.clone()), v)
+    })
+}
+
+#[bench]
+fn bench_deserializer_u8_000(b: &mut Bencher) {
+    b.iter(|| {
+        let v: Vec<u8> = vec!();
+        run_deserializer(deserializer::Deserializer::new(v.clone()), v)
+    })
+}
+
+#[bench]
+fn bench_deserializer_u8_003(b: &mut Bencher) {
+    b.iter(|| {
+        let v: Vec<u8> = vec!(1, 2, 3);
+        run_deserializer(deserializer::Deserializer::new(v.clone()), v)
+    })
+}
+
+#[bench]
+fn bench_deserializer_u8_100(b: &mut Bencher) {
+    b.iter(|| {
+        let v: Vec<u8> = (0 .. 100).collect();
+        run_deserializer(deserializer::Deserializer::new(v.clone()), v)
+    })
+}

testing/build.rs

@@ -0,0 +1,17 @@
+extern crate serde_codegen;
+
+use std::env;
+use std::path::Path;
+
+fn main() {
+    let out_dir = env::var_os("OUT_DIR").unwrap();
+
+    for &(src, dst) in &[
+        ("tests/test.rs.in", "test.rs"),
+        ("benches/bench.rs.in", "bench.rs"),
+    ] {
+        let src = Path::new(src);
+        let dst = Path::new(&out_dir).join(dst);
+        serde_codegen::expand(&src, &dst).unwrap();
+    }
+}

testing/tests/macros.rs

@@ -0,0 +1,95 @@
+#[macro_export]
+macro_rules! declare_ser_tests {
+    ($($name:ident { $($value:expr => $tokens:expr,)+ })+) => {
+        $(
+            #[test]
+            fn $name() {
+                $(
+                    ::token::assert_ser_tokens(&$value, $tokens);
+                )+
+            }
+        )+
+    }
+}
+
+#[macro_export]
+macro_rules! btreemap {
+    () => {
+        BTreeMap::new()
+    };
+    ($($key:expr => $value:expr),+) => {
+        {
+            let mut map = BTreeMap::new();
+            $(map.insert($key, $value);)+
+            map
+        }
+    }
+}
+
+macro_rules! btreeset {
+    () => {
+        BTreeSet::new()
+    };
+    ($($value:expr),+) => {
+        {
+            let mut set = BTreeSet::new();
+            $(set.insert($value);)+
+            set
+        }
+    }
+}
+
+macro_rules! btreemap {
+    () => {
+        BTreeMap::new()
+    };
+    ($($key:expr => $value:expr),+) => {
+        {
+            let mut map = BTreeMap::new();
+            $(map.insert($key, $value);)+
+            map
+        }
+    }
+}
+
+macro_rules! hashset {
+    () => {
+        HashSet::new()
+    };
+    ($($value:expr),+) => {
+        {
+            let mut set = HashSet::new();
+            $(set.insert($value);)+
+            set
+        }
+    };
+    ($hasher:ident @ $($value:expr),+) => {
+        {
+            use std::hash::BuildHasherDefault;
+            let mut set = HashSet::with_hasher(BuildHasherDefault::<$hasher>::default());
+            $(set.insert($value);)+
+            set
+        }
+    }
+}
+
+macro_rules! hashmap {
+    () => {
+        HashMap::new()
+    };
+    ($($key:expr => $value:expr),+) => {
+        {
+            let mut map = HashMap::new();
+            $(map.insert($key, $value);)+
+            map
+        }
+    };
+    ($hasher:ident @ $($key:expr => $value:expr),+) => {
+        {
+            use std::hash::BuildHasherDefault;
+            let mut map = HashMap::with_hasher(BuildHasherDefault::<$hasher>::default());
+            $(map.insert($key, $value);)+
+            map
+        }
+    }
+}

testing/tests/test.rs

@@ -0,0 +1,4 @@
+#![cfg_attr(feature = "nightly", feature(plugin))]
+#![cfg_attr(feature = "nightly", plugin(clippy))]
+
+include!(concat!(env!("OUT_DIR"), "/test.rs"));

testing/tests/test.rs.in

@@ -0,0 +1,11 @@
+#[macro_use]
+mod macros;
+
+mod token;
+
+mod test_annotations;
+mod test_bytes;
+mod test_de;
+mod test_gen;
+mod test_macros;
+mod test_ser;

testing/tests/test_annotations.rs

@@ -0,0 +1,950 @@
+extern crate serde;
+use self::serde::{Serialize, Serializer, Deserialize, Deserializer};
+
+use token::{
+    Error,
+    Token,
+    assert_tokens,
+    assert_ser_tokens,
+    assert_de_tokens,
+    assert_de_tokens_error
+};
+
+trait MyDefault: Sized {
+    fn my_default() -> Self;
+}
+
+trait ShouldSkip: Sized {
+    fn should_skip(&self) -> bool;
+}
+
+trait SerializeWith: Sized {
+    fn serialize_with<S>(&self, ser: &mut S) -> Result<(), S::Error>
+        where S: Serializer;
+}
+
+trait DeserializeWith: Sized {
+    fn deserialize_with<D>(de: &mut D) -> Result<Self, D::Error>
+        where D: Deserializer;
+}
+
+impl MyDefault for i32 {
+    fn my_default() -> Self { 123 }
+}
+
+impl ShouldSkip for i32 {
+    fn should_skip(&self) -> bool { *self == 123 }
+}
+
+impl SerializeWith for i32 {
+    fn serialize_with<S>(&self, ser: &mut S) -> Result<(), S::Error>
+        where S: Serializer
+    {
+        if *self == 123 {
+            true.serialize(ser)
+        } else {
+            false.serialize(ser)
+        }
+    }
+}
+
+impl DeserializeWith for i32 {
+    fn deserialize_with<D>(de: &mut D) -> Result<Self, D::Error>
+        where D: Deserializer
+    {
+        if try!(Deserialize::deserialize(de)) {
+            Ok(123)
+        } else {
+            Ok(2)
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+struct DefaultStruct<A, B, C, D, E>
+    where C: MyDefault,
+          E: MyDefault,
+{
+    a1: A,
+    #[serde(default)]
+    a2: B,
+    #[serde(default="MyDefault::my_default")]
+    a3: C,
+    #[serde(skip_deserializing)]
+    a4: D,
+    #[serde(skip_deserializing, default="MyDefault::my_default")]
+    a5: E,
+}
+
+#[test]
+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,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::StructSep,
+            Token::Str("a2"),
+            Token::I32(2),
+
+            Token::StructSep,
+            Token::Str("a3"),
+            Token::I32(3),
+
+            Token::StructSep,
+            Token::Str("a4"),
+            Token::I32(4),
+
+            Token::StructSep,
+            Token::Str("a5"),
+            Token::I32(5),
+
+            Token::StructEnd,
+        ]
+    );
+
+    assert_de_tokens(
+        &DefaultStruct { a1: 1, a2: 0, a3: 123, a4: 0, a5: 123 },
+        vec![
+            Token::StructStart("DefaultStruct", Some(1)),
+
+            Token::StructSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::StructEnd,
+        ]
+    );
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+enum DefaultEnum<A, B, C, D, E>
+    where C: MyDefault,
+          E: MyDefault
+{
+    Struct {
+        a1: A,
+        #[serde(default)]
+        a2: B,
+        #[serde(default="MyDefault::my_default")]
+        a3: C,
+        #[serde(skip_deserializing)]
+        a4: D,
+        #[serde(skip_deserializing, default="MyDefault::my_default")]
+        a5: E,
+    }
+}
+
+#[test]
+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,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::EnumMapSep,
+            Token::Str("a2"),
+            Token::I32(2),
+
+            Token::EnumMapSep,
+            Token::Str("a3"),
+            Token::I32(3),
+
+            Token::EnumMapSep,
+            Token::Str("a4"),
+            Token::I32(4),
+
+            Token::EnumMapSep,
+            Token::Str("a5"),
+            Token::I32(5),
+
+            Token::EnumMapEnd,
+        ]
+    );
+
+    assert_de_tokens(
+        &DefaultEnum::Struct { a1: 1, a2: 0, a3: 123, a4: 0, a5: 123 },
+        vec![
+            Token::EnumMapStart("DefaultEnum", "Struct", Some(5)),
+
+            Token::EnumMapSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::EnumMapEnd,
+        ]
+    );
+}
+
+// Does not implement std::default::Default.
+#[derive(Debug, PartialEq, Deserialize)]
+struct NoStdDefault(i8);
+
+impl MyDefault for NoStdDefault {
+    fn my_default() -> Self {
+        NoStdDefault(123)
+    }
+}
+
+#[derive(Debug, PartialEq, Deserialize)]
+struct ContainsNoStdDefault<A: MyDefault> {
+    #[serde(default="MyDefault::my_default")]
+    a: A,
+}
+
+// Tests that a struct field does not need to implement std::default::Default if
+// it is annotated with `default=...`.
+#[test]
+fn test_no_std_default() {
+    assert_de_tokens(
+        &ContainsNoStdDefault { a: NoStdDefault(123) },
+        vec![
+            Token::StructStart("ContainsNoStdDefault", Some(1)),
+            Token::StructEnd,
+        ]
+    );
+
+    assert_de_tokens(
+        &ContainsNoStdDefault { a: NoStdDefault(8) },
+        vec![
+            Token::StructStart("ContainsNoStdDefault", Some(1)),
+
+            Token::StructSep,
+            Token::Str("a"),
+            Token::StructNewType("NoStdDefault"),
+            Token::I8(8),
+
+            Token::StructEnd,
+        ]
+    );
+}
+
+// Does not implement Deserialize.
+#[derive(Debug, PartialEq)]
+struct NotDeserializeStruct(i8);
+
+impl Default for NotDeserializeStruct {
+    fn default() -> Self {
+        NotDeserializeStruct(123)
+    }
+}
+
+impl DeserializeWith for NotDeserializeStruct {
+    fn deserialize_with<D>(_: &mut D) -> Result<Self, D::Error>
+        where D: Deserializer
+    {
+        panic!()
+    }
+}
+
+// Does not implement Deserialize.
+#[derive(Debug, PartialEq)]
+enum NotDeserializeEnum { Trouble }
+
+impl MyDefault for NotDeserializeEnum {
+    fn my_default() -> Self {
+        NotDeserializeEnum::Trouble
+    }
+}
+
+#[derive(Debug, PartialEq, Deserialize)]
+struct ContainsNotDeserialize<A, B, C: DeserializeWith, E: MyDefault> {
+    #[serde(skip_deserializing)]
+    a: A,
+    #[serde(skip_deserializing, default)]
+    b: B,
+    #[serde(deserialize_with="DeserializeWith::deserialize_with", default)]
+    c: C,
+    #[serde(skip_deserializing, default="MyDefault::my_default")]
+    e: E,
+}
+
+// Tests that a struct field does not need to implement Deserialize if it is
+// annotated with skip_deserializing, whether using the std Default or a
+// custom default.
+#[test]
+fn test_elt_not_deserialize() {
+    assert_de_tokens(
+        &ContainsNotDeserialize {
+            a: NotDeserializeStruct(123),
+            b: NotDeserializeStruct(123),
+            c: NotDeserializeStruct(123),
+            e: NotDeserializeEnum::Trouble,
+        },
+        vec![
+            Token::StructStart("ContainsNotDeserialize", Some(3)),
+            Token::StructEnd,
+        ]
+    );
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct DenyUnknown {
+    a1: i32,
+}
+
+#[test]
+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,
+            Token::Str("whoops1"),
+            Token::I32(2),
+
+            Token::StructSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::StructSep,
+            Token::Str("whoops2"),
+            Token::SeqStart(Some(1)),
+            Token::SeqSep,
+            Token::I32(2),
+            Token::SeqEnd,
+
+            Token::StructSep,
+            Token::Str("a2"),
+            Token::I32(2),
+
+            Token::StructSep,
+            Token::Str("whoops3"),
+            Token::I32(2),
+
+            Token::StructSep,
+            Token::Str("a3"),
+            Token::I32(3),
+
+            Token::StructEnd,
+        ]
+    );
+
+    assert_de_tokens_error::<DenyUnknown>(
+        vec![
+            Token::StructStart("DenyUnknown", Some(2)),
+
+            Token::StructSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::StructSep,
+            Token::Str("whoops"),
+            Token::I32(2),
+
+            Token::StructEnd,
+        ],
+        Error::UnknownFieldError("whoops".to_owned())
+    );
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename="Superhero")]
+struct RenameStruct {
+    a1: i32,
+    #[serde(rename="a3")]
+    a2: i32,
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename(serialize="SuperheroSer", deserialize="SuperheroDe"))]
+struct RenameStructSerializeDeserialize {
+    a1: i32,
+    #[serde(rename(serialize="a4", deserialize="a5"))]
+    a2: i32,
+}
+
+#[test]
+fn test_rename_struct() {
+    assert_tokens(
+        &RenameStruct { a1: 1, a2: 2 },
+        vec![
+            Token::StructStart("Superhero", Some(2)),
+
+            Token::StructSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::StructSep,
+            Token::Str("a3"),
+            Token::I32(2),
+
+            Token::StructEnd,
+        ]
+    );
+
+    assert_ser_tokens(
+        &RenameStructSerializeDeserialize { a1: 1, a2: 2 },
+        &[
+            Token::StructStart("SuperheroSer", Some(2)),
+
+            Token::StructSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::StructSep,
+            Token::Str("a4"),
+            Token::I32(2),
+
+            Token::StructEnd,
+        ]
+    );
+
+    assert_de_tokens(
+        &RenameStructSerializeDeserialize { a1: 1, a2: 2 },
+        vec![
+            Token::StructStart("SuperheroDe", Some(2)),
+
+            Token::StructSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::StructSep,
+            Token::Str("a5"),
+            Token::I32(2),
+
+            Token::StructEnd,
+        ]
+    );
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename="Superhero")]
+enum RenameEnum {
+    #[serde(rename="bruce_wayne")]
+    Batman,
+    #[serde(rename="clark_kent")]
+    Superman(i8),
+    #[serde(rename="diana_prince")]
+    WonderWoman(i8, i8),
+    #[serde(rename="barry_allan")]
+    Flash {
+        #[serde(rename="b")]
+        a: i32,
+    },
+}
+
+#[derive(Debug, PartialEq, Deserialize, Serialize)]
+#[serde(rename(serialize="SuperheroSer", deserialize="SuperheroDe"))]
+enum RenameEnumSerializeDeserialize<A> {
+    #[serde(rename(serialize="dick_grayson", deserialize="jason_todd"))]
+    Robin {
+        a: i8,
+        #[serde(rename(serialize="c"))]
+        #[serde(rename(deserialize="d"))]
+        b: A,
+    },
+}
+
+#[test]
+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),
+        ]
+    );
+
+    assert_tokens(
+        &RenameEnum::WonderWoman(0, 1),
+        vec![
+            Token::EnumSeqStart("Superhero", "diana_prince", Some(2)),
+
+            Token::EnumSeqSep,
+            Token::I8(0),
+
+            Token::EnumSeqSep,
+            Token::I8(1),
+
+            Token::EnumSeqEnd,
+        ]
+    );
+
+    assert_tokens(
+        &RenameEnum::Flash { a: 1 },
+        vec![
+            Token::EnumMapStart("Superhero", "barry_allan", Some(1)),
+
+            Token::EnumMapSep,
+            Token::Str("b"),
+            Token::I32(1),
+
+            Token::EnumMapEnd,
+        ]
+    );
+
+    assert_ser_tokens(
+        &RenameEnumSerializeDeserialize::Robin {
+            a: 0,
+            b: String::new(),
+        },
+        &[
+            Token::EnumMapStart("SuperheroSer", "dick_grayson", Some(2)),
+
+            Token::EnumMapSep,
+            Token::Str("a"),
+            Token::I8(0),
+
+            Token::EnumMapSep,
+            Token::Str("c"),
+            Token::Str(""),
+
+            Token::EnumMapEnd,
+        ]
+    );
+
+    assert_de_tokens(
+        &RenameEnumSerializeDeserialize::Robin {
+            a: 0,
+            b: String::new(),
+        },
+        vec![
+            Token::EnumMapStart("SuperheroDe", "jason_todd", Some(2)),
+
+            Token::EnumMapSep,
+            Token::Str("a"),
+            Token::I8(0),
+
+            Token::EnumMapSep,
+            Token::Str("d"),
+            Token::Str(""),
+
+            Token::EnumMapEnd,
+        ]
+    );
+}
+
+#[derive(Debug, PartialEq, Serialize)]
+struct SkipSerializingStruct<'a, B, C> where C: ShouldSkip {
+    a: &'a i8,
+    #[serde(skip_serializing)]
+    b: B,
+    #[serde(skip_serializing_if="ShouldSkip::should_skip")]
+    c: C,
+}
+
+#[test]
+fn test_skip_serializing_struct() {
+    let a = 1;
+    assert_ser_tokens(
+        &SkipSerializingStruct {
+            a: &a,
+            b: 2,
+            c: 3,
+        },
+        &[
+            Token::StructStart("SkipSerializingStruct", Some(2)),
+
+            Token::StructSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::StructSep,
+            Token::Str("c"),
+            Token::I32(3),
+
+            Token::StructEnd,
+        ]
+    );
+
+    assert_ser_tokens(
+        &SkipSerializingStruct {
+            a: &a,
+            b: 2,
+            c: 123,
+        },
+        &[
+            Token::StructStart("SkipSerializingStruct", Some(1)),
+
+            Token::StructSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::StructEnd,
+        ]
+    );
+}
+
+#[derive(Debug, PartialEq, Serialize)]
+enum SkipSerializingEnum<'a, B, C> where C: ShouldSkip {
+    Struct {
+        a: &'a i8,
+        #[serde(skip_serializing)]
+        _b: B,
+        #[serde(skip_serializing_if="ShouldSkip::should_skip")]
+        c: C,
+    }
+}
+
+#[test]
+fn test_skip_serializing_enum() {
+    let a = 1;
+    assert_ser_tokens(
+        &SkipSerializingEnum::Struct {
+            a: &a,
+            _b: 2,
+            c: 3,
+        },
+        &[
+            Token::EnumMapStart("SkipSerializingEnum", "Struct", Some(2)),
+
+            Token::EnumMapSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::EnumMapSep,
+            Token::Str("c"),
+            Token::I32(3),
+
+            Token::EnumMapEnd,
+        ]
+    );
+
+    assert_ser_tokens(
+        &SkipSerializingEnum::Struct {
+            a: &a,
+            _b: 2,
+            c: 123,
+        },
+        &[
+            Token::EnumMapStart("SkipSerializingEnum", "Struct", Some(1)),
+
+            Token::EnumMapSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::EnumMapEnd,
+        ]
+    );
+}
+
+#[derive(Debug, PartialEq)]
+struct NotSerializeStruct(i8);
+
+#[derive(Debug, PartialEq)]
+enum NotSerializeEnum { Trouble }
+
+impl SerializeWith for NotSerializeEnum {
+    fn serialize_with<S>(&self, ser: &mut S) -> Result<(), S::Error>
+        where S: Serializer
+    {
+        "trouble".serialize(ser)
+    }
+}
+
+#[derive(Debug, PartialEq, Serialize)]
+struct ContainsNotSerialize<'a, B, C, D> where B: 'a, D: SerializeWith {
+    a: &'a Option<i8>,
+    #[serde(skip_serializing)]
+    b: &'a B,
+    #[serde(skip_serializing)]
+    c: Option<C>,
+    #[serde(serialize_with="SerializeWith::serialize_with")]
+    d: D,
+}
+
+#[test]
+fn test_elt_not_serialize() {
+    let a = 1;
+    assert_ser_tokens(
+        &ContainsNotSerialize {
+            a: &Some(a),
+            b: &NotSerializeStruct(2),
+            c: Some(NotSerializeEnum::Trouble),
+            d: NotSerializeEnum::Trouble,
+        },
+        &[
+            Token::StructStart("ContainsNotSerialize", Some(2)),
+
+            Token::StructSep,
+            Token::Str("a"),
+            Token::Option(true),
+            Token::I8(1),
+
+            Token::StructSep,
+            Token::Str("d"),
+            Token::Str("trouble"),
+
+            Token::StructEnd,
+        ]
+    );
+}
+
+#[derive(Debug, PartialEq, Serialize)]
+struct SerializeWithStruct<'a, B> where B: SerializeWith {
+    a: &'a i8,
+    #[serde(serialize_with="SerializeWith::serialize_with")]
+    b: B,
+}
+
+#[test]
+fn test_serialize_with_struct() {
+    let a = 1;
+    assert_ser_tokens(
+        &SerializeWithStruct {
+            a: &a,
+            b: 2,
+        },
+        &[
+            Token::StructStart("SerializeWithStruct", Some(2)),
+
+            Token::StructSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::StructSep,
+            Token::Str("b"),
+            Token::Bool(false),
+
+            Token::StructEnd,
+        ]
+    );
+
+    assert_ser_tokens(
+        &SerializeWithStruct {
+            a: &a,
+            b: 123,
+        },
+        &[
+            Token::StructStart("SerializeWithStruct", Some(2)),
+
+            Token::StructSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::StructSep,
+            Token::Str("b"),
+            Token::Bool(true),
+
+            Token::StructEnd,
+        ]
+    );
+}
+
+#[derive(Debug, PartialEq, Serialize)]
+enum SerializeWithEnum<'a, B> where B: SerializeWith {
+    Struct {
+        a: &'a i8,
+        #[serde(serialize_with="SerializeWith::serialize_with")]
+        b: B,
+    }
+}
+
+#[test]
+fn test_serialize_with_enum() {
+    let a = 1;
+    assert_ser_tokens(
+        &SerializeWithEnum::Struct {
+            a: &a,
+            b: 2,
+        },
+        &[
+            Token::EnumMapStart("SerializeWithEnum", "Struct", Some(2)),
+
+            Token::EnumMapSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::EnumMapSep,
+            Token::Str("b"),
+            Token::Bool(false),
+
+            Token::EnumMapEnd,
+        ]
+    );
+
+    assert_ser_tokens(
+        &SerializeWithEnum::Struct {
+            a: &a,
+            b: 123,
+        },
+        &[
+            Token::EnumMapStart("SerializeWithEnum", "Struct", Some(2)),
+
+            Token::EnumMapSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::EnumMapSep,
+            Token::Str("b"),
+            Token::Bool(true),
+
+            Token::EnumMapEnd,
+        ]
+    );
+}
+
+#[derive(Debug, PartialEq, Deserialize)]
+struct DeserializeWithStruct<B> where B: DeserializeWith {
+    a: i8,
+    #[serde(deserialize_with="DeserializeWith::deserialize_with")]
+    b: B,
+}
+
+#[test]
+fn test_deserialize_with_struct() {
+    assert_de_tokens(
+        &DeserializeWithStruct {
+            a: 1,
+            b: 2,
+        },
+        vec![
+            Token::StructStart("DeserializeWithStruct", Some(2)),
+
+            Token::StructSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::StructSep,
+            Token::Str("b"),
+            Token::Bool(false),
+
+            Token::StructEnd,
+        ]
+    );
+
+    assert_de_tokens(
+        &DeserializeWithStruct {
+            a: 1,
+            b: 123,
+        },
+        vec![
+            Token::StructStart("DeserializeWithStruct", Some(2)),
+
+            Token::StructSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::StructSep,
+            Token::Str("b"),
+            Token::Bool(true),
+
+            Token::StructEnd,
+        ]
+    );
+}
+
+#[derive(Debug, PartialEq, Deserialize)]
+enum DeserializeWithEnum<B> where B: DeserializeWith {
+    Struct {
+        a: i8,
+        #[serde(deserialize_with="DeserializeWith::deserialize_with")]
+        b: B,
+    }
+}
+
+#[test]
+fn test_deserialize_with_enum() {
+    assert_de_tokens(
+        &DeserializeWithEnum::Struct {
+            a: 1,
+            b: 2,
+        },
+        vec![
+            Token::EnumMapStart("DeserializeWithEnum", "Struct", Some(2)),
+
+            Token::EnumMapSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::EnumMapSep,
+            Token::Str("b"),
+            Token::Bool(false),
+
+            Token::EnumMapEnd,
+        ]
+    );
+
+    assert_de_tokens(
+        &DeserializeWithEnum::Struct {
+            a: 1,
+            b: 123,
+        },
+        vec![
+            Token::EnumMapStart("DeserializeWithEnum", "Struct", Some(2)),
+
+            Token::EnumMapSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::EnumMapSep,
+            Token::Str("b"),
+            Token::Bool(true),
+
+            Token::EnumMapEnd,
+        ]
+    );
+}
+
+#[test]
+fn test_missing_renamed_field_struct() {
+    assert_de_tokens_error::<RenameStruct>(
+        vec![
+            Token::StructStart("Superhero", Some(2)),
+
+            Token::StructSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::StructEnd,
+        ],
+        Error::MissingFieldError("a3"),
+    );
+
+    assert_de_tokens_error::<RenameStructSerializeDeserialize>(
+        vec![
+            Token::StructStart("SuperheroDe", Some(2)),
+
+            Token::StructSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::StructEnd,
+        ],
+        Error::MissingFieldError("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"),
+    );
+
+    assert_de_tokens_error::<RenameEnumSerializeDeserialize<i8>>(
+        vec![
+            Token::EnumMapStart("SuperheroDe", "jason_todd", Some(2)),
+
+            Token::EnumMapSep,
+            Token::Str("a"),
+            Token::I8(0),
+
+            Token::EnumMapEnd,
+        ],
+        Error::MissingFieldError("d"),
+    );
+}

testing/tests/test_bytes.rs

@@ -0,0 +1,185 @@
+use std::fmt;
+use std::error;
+
+extern crate serde;
+use self::serde::Serialize;
+use self::serde::bytes::{ByteBuf, Bytes};
+
+///////////////////////////////////////////////////////////////////////////////
+
+#[derive(Debug, PartialEq)]
+struct Error;
+
+impl serde::ser::Error for Error {
+    fn custom<T: Into<String>>(_: T) -> Error { Error }
+}
+
+impl serde::de::Error for Error {
+    fn custom<T: Into<String>>(_: T) -> Error { Error }
+
+    fn end_of_stream() -> Error { Error }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        formatter.write_str(format!("{:?}", self).as_ref())
+    }
+}
+
+impl error::Error for Error {
+    fn description(&self) -> &str {
+        "Serde Deserialization Error"
+    }
+
+    fn cause(&self) -> Option<&error::Error> {
+        None
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct BytesSerializer {
+    bytes: Vec<u8>,
+}
+
+impl BytesSerializer {
+    fn new(bytes: Vec<u8>) -> Self {
+        BytesSerializer {
+            bytes: bytes,
+        }
+    }
+}
+
+impl serde::Serializer for BytesSerializer {
+    type Error = Error;
+
+    fn serialize_unit(&mut self) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn serialize_bool(&mut self, _v: bool) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn serialize_i64(&mut self, _v: i64) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn serialize_u64(&mut self, _v: u64) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn serialize_f32(&mut self, _v: f32) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn serialize_f64(&mut self, _v: f64) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn serialize_char(&mut self, _v: char) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn serialize_str(&mut self, _v: &str) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn serialize_none(&mut self) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn serialize_some<V>(&mut self, _value: V) -> Result<(), Error>
+        where V: serde::Serialize,
+    {
+        Err(Error)
+    }
+
+    fn serialize_seq<V>(&mut self, _visitor: V) -> Result<(), Error>
+        where V: serde::ser::SeqVisitor,
+    {
+        Err(Error)
+    }
+
+    fn serialize_seq_elt<T>(&mut self, _value: T) -> Result<(), Error>
+        where T: serde::Serialize
+    {
+        Err(Error)
+    }
+
+    fn serialize_map<V>(&mut self, _visitor: V) -> Result<(), Error>
+        where V: serde::ser::MapVisitor,
+    {
+        Err(Error)
+    }
+
+    fn serialize_map_elt<K, V>(&mut self, _key: K, _value: V) -> Result<(), Error>
+        where K: serde::Serialize,
+              V: serde::Serialize,
+    {
+        Err(Error)
+    }
+
+    fn serialize_bytes(&mut self, bytes: &[u8]) -> Result<(), Error> {
+        assert_eq!(self.bytes, bytes);
+        Ok(())
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct BytesDeserializer {
+    bytes: Option<Vec<u8>>,
+}
+
+impl BytesDeserializer {
+    fn new(bytes: Vec<u8>) -> Self {
+        BytesDeserializer {
+            bytes: Some(bytes),
+        }
+    }
+}
+
+impl serde::Deserializer for BytesDeserializer {
+    type Error = Error;
+
+    fn deserialize<V>(&mut self, _visitor: V) -> Result<V::Value, Error>
+        where V: serde::de::Visitor,
+    {
+        Err(Error)
+    }
+
+    fn deserialize_bytes<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: serde::de::Visitor,
+    {
+        visitor.visit_byte_buf(self.bytes.take().unwrap())
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#[test]
+fn test_bytes_ser_bytes() {
+    let buf = vec![];
+    let bytes = Bytes::from(&buf);
+    let mut ser = BytesSerializer::new(vec![]);
+    bytes.serialize(&mut ser).unwrap();
+
+    let buf = vec![1, 2, 3];
+    let bytes = Bytes::from(&buf);
+    let mut ser = BytesSerializer::new(vec![1, 2, 3]);
+    bytes.serialize(&mut ser).unwrap();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#[test]
+fn test_byte_buf_de_bytes() {
+    let mut de = BytesDeserializer::new(vec![]);
+    let bytes = serde::Deserialize::deserialize(&mut de);
+    assert_eq!(bytes, Ok(ByteBuf::new()));
+
+    let mut de = BytesDeserializer::new(vec![1, 2, 3]);
+    let bytes = serde::Deserialize::deserialize(&mut de);
+    assert_eq!(bytes, Ok(ByteBuf::from(vec![1, 2, 3])));
+}

testing/tests/test_de.rs

@@ -0,0 +1,779 @@
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::net;
+use std::path::PathBuf;
+
+extern crate fnv;
+use self::fnv::FnvHasher;
+
+use token::{
+    Error,
+    Token,
+    assert_de_tokens,
+    assert_de_tokens_ignore,
+    assert_de_tokens_error,
+};
+
+//////////////////////////////////////////////////////////////////////////
+
+#[derive(Copy, Clone, PartialEq, Debug, Deserialize)]
+struct UnitStruct;
+
+#[derive(PartialEq, Debug, Deserialize)]
+struct TupleStruct(i32, i32, i32);
+
+#[derive(PartialEq, Debug, Deserialize)]
+struct Struct {
+    a: i32,
+    b: i32,
+    #[serde(skip_deserializing)]
+    c: i32,
+}
+
+#[derive(PartialEq, Debug, Deserialize)]
+enum Enum {
+    Unit,
+    Simple(i32),
+    Seq(i32, i32, i32),
+    Map { a: i32, b: i32, c: i32 }
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+macro_rules! declare_test {
+    ($name:ident { $($value:expr => $tokens:expr,)+ }) => {
+        #[test]
+        fn $name() {
+            $(
+                // Test ser/de roundtripping
+                assert_de_tokens(&$value, $tokens);
+
+                // Test that the tokens are ignorable
+                assert_de_tokens_ignore($tokens);
+            )+
+        }
+    }
+}
+
+macro_rules! declare_tests {
+    ($($name:ident { $($value:expr => $tokens:expr,)+ })+) => {
+        $(
+            declare_test!($name { $($value => $tokens,)+ });
+        )+
+    }
+}
+
+macro_rules! declare_error_tests {
+    ($($name:ident<$target:ident> { $tokens:expr, $expected:expr, })+) => {
+        $(
+            #[test]
+            fn $name() {
+                assert_de_tokens_error::<$target>($tokens, $expected);
+            }
+        )+
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+declare_tests! {
+    test_bool {
+        true => vec![Token::Bool(true)],
+        false => vec![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.)],
+    }
+    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)],
+    }
+    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)],
+    }
+    test_floats {
+        0f32 => vec![Token::F32(0.)],
+        0f64 => vec![Token::F64(0.)],
+    }
+    test_char {
+        'a' => vec![Token::Char('a')],
+        'a' => vec![Token::Str("a")],
+        'a' => vec![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')],
+    }
+    test_option {
+        None::<i32> => vec![Token::Unit],
+        None::<i32> => vec![Token::Option(false)],
+        Some(1) => vec![Token::I32(1)],
+        Some(1) => vec![
+            Token::Option(true),
+            Token::I32(1),
+        ],
+    }
+    test_result {
+        Ok::<i32, i32>(0) => vec![
+            Token::EnumStart("Result"),
+            Token::Str("Ok"),
+            Token::I32(0),
+        ],
+        Err::<i32, i32>(1) => vec![
+            Token::EnumStart("Result"),
+            Token::Str("Err"),
+            Token::I32(1),
+        ],
+    }
+    test_unit {
+        () => vec![Token::Unit],
+        () => vec![
+            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![
+            Token::UnitStruct("UnitStruct"),
+        ],
+        UnitStruct => vec![
+            Token::SeqStart(Some(0)),
+            Token::SeqEnd,
+        ],
+        UnitStruct => vec![
+            Token::SeqStart(None),
+            Token::SeqEnd,
+        ],
+    }
+    test_tuple_struct {
+        TupleStruct(1, 2, 3) => vec![
+            Token::SeqStart(Some(3)),
+                Token::SeqSep,
+                Token::I32(1),
+
+                Token::SeqSep,
+                Token::I32(2),
+
+                Token::SeqSep,
+                Token::I32(3),
+            Token::SeqEnd,
+        ],
+        TupleStruct(1, 2, 3) => vec![
+            Token::SeqStart(None),
+                Token::SeqSep,
+                Token::I32(1),
+
+                Token::SeqSep,
+                Token::I32(2),
+
+                Token::SeqSep,
+                Token::I32(3),
+            Token::SeqEnd,
+        ],
+        TupleStruct(1, 2, 3) => vec![
+            Token::TupleStructStart("TupleStruct", Some(3)),
+                Token::TupleStructSep,
+                Token::I32(1),
+
+                Token::TupleStructSep,
+                Token::I32(2),
+
+                Token::TupleStructSep,
+                Token::I32(3),
+            Token::TupleStructEnd,
+        ],
+        TupleStruct(1, 2, 3) => vec![
+            Token::TupleStructStart("TupleStruct", None),
+                Token::TupleStructSep,
+                Token::I32(1),
+
+                Token::TupleStructSep,
+                Token::I32(2),
+
+                Token::TupleStructSep,
+                Token::I32(3),
+            Token::TupleStructEnd,
+        ],
+    }
+    test_btreeset {
+        BTreeSet::<isize>::new() => vec![
+            Token::Unit,
+        ],
+        BTreeSet::<isize>::new() => vec![
+            Token::SeqStart(Some(0)),
+            Token::SeqEnd,
+        ],
+        btreeset![btreeset![], btreeset![1], btreeset![2, 3]] => vec![
+            Token::SeqStart(Some(3)),
+                Token::SeqSep,
+                Token::SeqStart(Some(0)),
+                Token::SeqEnd,
+
+                Token::SeqSep,
+                Token::SeqStart(Some(1)),
+                    Token::SeqSep,
+                    Token::I32(1),
+                Token::SeqEnd,
+
+                Token::SeqSep,
+                Token::SeqStart(Some(2)),
+                    Token::SeqSep,
+                    Token::I32(2),
+
+                    Token::SeqSep,
+                    Token::I32(3),
+                Token::SeqEnd,
+            Token::SeqEnd,
+        ],
+        BTreeSet::<isize>::new() => vec![
+            Token::UnitStruct("Anything"),
+        ],
+        BTreeSet::<isize>::new() => vec![
+            Token::TupleStructStart("Anything", Some(0)),
+            Token::SeqEnd,
+        ],
+    }
+    test_hashset {
+        HashSet::<isize>::new() => vec![
+            Token::Unit,
+        ],
+        HashSet::<isize>::new() => vec![
+            Token::SeqStart(Some(0)),
+            Token::SeqEnd,
+        ],
+        hashset![1, 2, 3] => vec![
+            Token::SeqStart(Some(3)),
+                Token::SeqSep,
+                Token::I32(1),
+
+                Token::SeqSep,
+                Token::I32(2),
+
+                Token::SeqSep,
+                Token::I32(3),
+            Token::SeqEnd,
+        ],
+        HashSet::<isize>::new() => vec![
+            Token::UnitStruct("Anything"),
+        ],
+        HashSet::<isize>::new() => vec![
+            Token::TupleStructStart("Anything", Some(0)),
+            Token::SeqEnd,
+        ],
+        hashset![FnvHasher @ 1, 2, 3] => vec![
+            Token::SeqStart(Some(3)),
+                Token::SeqSep,
+                Token::I32(1),
+
+                Token::SeqSep,
+                Token::I32(2),
+
+                Token::SeqSep,
+                Token::I32(3),
+            Token::SeqEnd,
+        ],
+    }
+    test_vec {
+        Vec::<isize>::new() => vec![
+            Token::Unit,
+        ],
+        Vec::<isize>::new() => vec![
+            Token::SeqStart(Some(0)),
+            Token::SeqEnd,
+        ],
+        vec![vec![], vec![1], vec![2, 3]] => vec![
+            Token::SeqStart(Some(3)),
+                Token::SeqSep,
+                Token::SeqStart(Some(0)),
+                Token::SeqEnd,
+
+                Token::SeqSep,
+                Token::SeqStart(Some(1)),
+                    Token::SeqSep,
+                    Token::I32(1),
+                Token::SeqEnd,
+
+                Token::SeqSep,
+                Token::SeqStart(Some(2)),
+                    Token::SeqSep,
+                    Token::I32(2),
+
+                    Token::SeqSep,
+                    Token::I32(3),
+                Token::SeqEnd,
+            Token::SeqEnd,
+        ],
+        Vec::<isize>::new() => vec![
+            Token::UnitStruct("Anything"),
+        ],
+        Vec::<isize>::new() => vec![
+            Token::TupleStructStart("Anything", Some(0)),
+            Token::SeqEnd,
+        ],
+    }
+    test_array {
+        [0; 0] => vec![
+            Token::Unit,
+        ],
+        [0; 0] => vec![
+            Token::SeqStart(Some(0)),
+            Token::SeqEnd,
+        ],
+        [0; 0] => vec![
+            Token::SeqArrayStart(0),
+            Token::SeqEnd,
+        ],
+        ([0; 0], [1], [2, 3]) => vec![
+            Token::SeqStart(Some(3)),
+                Token::SeqSep,
+                Token::SeqStart(Some(0)),
+                Token::SeqEnd,
+
+                Token::SeqSep,
+                Token::SeqStart(Some(1)),
+                    Token::SeqSep,
+                    Token::I32(1),
+                Token::SeqEnd,
+
+                Token::SeqSep,
+                Token::SeqStart(Some(2)),
+                    Token::SeqSep,
+                    Token::I32(2),
+
+                    Token::SeqSep,
+                    Token::I32(3),
+                Token::SeqEnd,
+            Token::SeqEnd,
+        ],
+        ([0; 0], [1], [2, 3]) => vec![
+            Token::SeqArrayStart(3),
+                Token::SeqSep,
+                Token::SeqArrayStart(0),
+                Token::SeqEnd,
+
+                Token::SeqSep,
+                Token::SeqArrayStart(1),
+                    Token::SeqSep,
+                    Token::I32(1),
+                Token::SeqEnd,
+
+                Token::SeqSep,
+                Token::SeqArrayStart(2),
+                    Token::SeqSep,
+                    Token::I32(2),
+
+                    Token::SeqSep,
+                    Token::I32(3),
+                Token::SeqEnd,
+            Token::SeqEnd,
+        ],
+        [0; 0] => vec![
+            Token::UnitStruct("Anything"),
+        ],
+        [0; 0] => vec![
+            Token::TupleStructStart("Anything", Some(0)),
+            Token::SeqEnd,
+        ],
+    }
+    test_tuple {
+        (1,) => vec![
+            Token::SeqStart(Some(1)),
+                Token::SeqSep,
+                Token::I32(1),
+            Token::SeqEnd,
+        ],
+        (1, 2, 3) => vec![
+            Token::SeqStart(Some(3)),
+                Token::SeqSep,
+                Token::I32(1),
+
+                Token::SeqSep,
+                Token::I32(2),
+
+                Token::SeqSep,
+                Token::I32(3),
+            Token::SeqEnd,
+        ],
+        (1,) => vec![
+            Token::TupleStart(1),
+                Token::TupleSep,
+                Token::I32(1),
+            Token::TupleEnd,
+        ],
+        (1, 2, 3) => vec![
+            Token::TupleStart(3),
+                Token::TupleSep,
+                Token::I32(1),
+
+                Token::TupleSep,
+                Token::I32(2),
+
+                Token::TupleSep,
+                Token::I32(3),
+            Token::TupleEnd,
+        ],
+    }
+    test_btreemap {
+        BTreeMap::<isize, isize>::new() => vec![
+            Token::Unit,
+        ],
+        BTreeMap::<isize, isize>::new() => vec![
+            Token::MapStart(Some(0)),
+            Token::MapEnd,
+        ],
+        btreemap![1 => 2] => vec![
+            Token::MapStart(Some(1)),
+                Token::MapSep,
+                Token::I32(1),
+                Token::I32(2),
+            Token::MapEnd,
+        ],
+        btreemap![1 => 2, 3 => 4] => vec![
+            Token::MapStart(Some(2)),
+                Token::MapSep,
+                Token::I32(1),
+                Token::I32(2),
+
+                Token::MapSep,
+                Token::I32(3),
+                Token::I32(4),
+            Token::MapEnd,
+        ],
+        btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]] => vec![
+            Token::MapStart(Some(2)),
+                Token::MapSep,
+                Token::I32(1),
+                Token::MapStart(Some(0)),
+                Token::MapEnd,
+
+                Token::MapSep,
+                Token::I32(2),
+                Token::MapStart(Some(2)),
+                    Token::MapSep,
+                    Token::I32(3),
+                    Token::I32(4),
+
+                    Token::MapSep,
+                    Token::I32(5),
+                    Token::I32(6),
+                Token::MapEnd,
+            Token::MapEnd,
+        ],
+        BTreeMap::<isize, isize>::new() => vec![
+            Token::UnitStruct("Anything"),
+        ],
+        BTreeMap::<isize, isize>::new() => vec![
+            Token::StructStart("Anything", Some(0)),
+            Token::MapEnd,
+        ],
+    }
+    test_hashmap {
+        HashMap::<isize, isize>::new() => vec![
+            Token::Unit,
+        ],
+        HashMap::<isize, isize>::new() => vec![
+            Token::MapStart(Some(0)),
+            Token::MapEnd,
+        ],
+        hashmap![1 => 2] => vec![
+            Token::MapStart(Some(1)),
+                Token::MapSep,
+                Token::I32(1),
+                Token::I32(2),
+            Token::MapEnd,
+        ],
+        hashmap![1 => 2, 3 => 4] => vec![
+            Token::MapStart(Some(2)),
+                Token::MapSep,
+                Token::I32(1),
+                Token::I32(2),
+
+                Token::MapSep,
+                Token::I32(3),
+                Token::I32(4),
+            Token::MapEnd,
+        ],
+        hashmap![1 => hashmap![], 2 => hashmap![3 => 4, 5 => 6]] => vec![
+            Token::MapStart(Some(2)),
+                Token::MapSep,
+                Token::I32(1),
+                Token::MapStart(Some(0)),
+                Token::MapEnd,
+
+                Token::MapSep,
+                Token::I32(2),
+                Token::MapStart(Some(2)),
+                    Token::MapSep,
+                    Token::I32(3),
+                    Token::I32(4),
+
+                    Token::MapSep,
+                    Token::I32(5),
+                    Token::I32(6),
+                Token::MapEnd,
+            Token::MapEnd,
+        ],
+        HashMap::<isize, isize>::new() => vec![
+            Token::UnitStruct("Anything"),
+        ],
+        HashMap::<isize, isize>::new() => vec![
+            Token::StructStart("Anything", Some(0)),
+            Token::MapEnd,
+        ],
+        hashmap![FnvHasher @ 1 => 2, 3 => 4] => vec![
+            Token::MapStart(Some(2)),
+                Token::MapSep,
+                Token::I32(1),
+                Token::I32(2),
+
+                Token::MapSep,
+                Token::I32(3),
+                Token::I32(4),
+            Token::MapEnd,
+        ],
+    }
+    test_struct {
+        Struct { a: 1, b: 2, c: 0 } => vec![
+            Token::MapStart(Some(3)),
+                Token::MapSep,
+                Token::Str("a"),
+                Token::I32(1),
+
+                Token::MapSep,
+                Token::Str("b"),
+                Token::I32(2),
+            Token::MapEnd,
+        ],
+        Struct { a: 1, b: 2, c: 0 } => vec![
+            Token::StructStart("Struct", Some(3)),
+                Token::StructSep,
+                Token::Str("a"),
+                Token::I32(1),
+
+                Token::StructSep,
+                Token::Str("b"),
+                Token::I32(2),
+            Token::StructEnd,
+        ],
+        Struct { a: 1, b: 2, c: 0 } => vec![
+            Token::SeqStart(Some(3)),
+                Token::SeqSep,
+                Token::I32(1),
+
+                Token::SeqSep,
+                Token::I32(2),
+            Token::SeqEnd,
+        ],
+    }
+    test_struct_with_skip {
+        Struct { a: 1, b: 2, c: 0 } => vec![
+            Token::MapStart(Some(3)),
+                Token::MapSep,
+                Token::Str("a"),
+                Token::I32(1),
+
+                Token::MapSep,
+                Token::Str("b"),
+                Token::I32(2),
+
+                Token::MapSep,
+                Token::Str("c"),
+                Token::I32(3),
+
+                Token::MapSep,
+                Token::Str("d"),
+                Token::I32(4),
+            Token::MapEnd,
+        ],
+        Struct { a: 1, b: 2, c: 0 } => vec![
+            Token::StructStart("Struct", Some(3)),
+                Token::StructSep,
+                Token::Str("a"),
+                Token::I32(1),
+
+                Token::StructSep,
+                Token::Str("b"),
+                Token::I32(2),
+
+                Token::StructSep,
+                Token::Str("c"),
+                Token::I32(3),
+
+                Token::StructSep,
+                Token::Str("d"),
+                Token::I32(4),
+            Token::StructEnd,
+        ],
+    }
+    test_enum_unit {
+        Enum::Unit => vec![
+            Token::EnumUnit("Enum", "Unit"),
+        ],
+    }
+    test_enum_simple {
+        Enum::Simple(1) => vec![
+            Token::EnumNewType("Enum", "Simple"),
+            Token::I32(1),
+        ],
+    }
+    test_enum_seq {
+        Enum::Seq(1, 2, 3) => vec![
+            Token::EnumSeqStart("Enum", "Seq", Some(3)),
+                Token::EnumSeqSep,
+                Token::I32(1),
+
+                Token::EnumSeqSep,
+                Token::I32(2),
+
+                Token::EnumSeqSep,
+                Token::I32(3),
+            Token::EnumSeqEnd,
+        ],
+    }
+    test_enum_map {
+        Enum::Map { a: 1, b: 2, c: 3 } => vec![
+            Token::EnumMapStart("Enum", "Map", Some(3)),
+                Token::EnumMapSep,
+                Token::Str("a"),
+                Token::I32(1),
+
+                Token::EnumMapSep,
+                Token::Str("b"),
+                Token::I32(2),
+
+                Token::EnumMapSep,
+                Token::Str("c"),
+                Token::I32(3),
+            Token::EnumMapEnd,
+        ],
+    }
+    test_enum_unit_usize {
+        Enum::Unit => vec![
+            Token::EnumStart("Enum"),
+            Token::Usize(0),
+            Token::Unit,
+        ],
+    }
+    test_enum_unit_bytes {
+        Enum::Unit => vec![
+            Token::EnumStart("Enum"),
+            Token::Bytes(b"Unit"),
+            Token::Unit,
+        ],
+    }
+    test_box {
+        Box::new(0i32) => vec![Token::I32(0)],
+    }
+    test_boxed_slice {
+        Box::new([0, 1, 2]) => vec![
+            Token::SeqStart(Some(3)),
+            Token::SeqSep,
+            Token::I32(0),
+            Token::SeqSep,
+            Token::I32(1),
+            Token::SeqSep,
+            Token::I32(2),
+            Token::SeqEnd,
+        ],
+    }
+    test_net_ipv4addr {
+        "1.2.3.4".parse::<net::Ipv4Addr>().unwrap() => vec![Token::Str("1.2.3.4")],
+    }
+    test_net_ipv6addr {
+        "::1".parse::<net::Ipv6Addr>().unwrap() => vec![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")],
+    }
+    test_path_buf {
+        PathBuf::from("/usr/local/lib") => vec![
+            Token::String("/usr/local/lib".to_owned()),
+        ],
+    }
+}
+
+#[cfg(feature = "nightly")]
+#[test]
+fn test_net_ipaddr() {
+    assert_de_tokens(
+        "1.2.3.4".parse::<net::IpAddr>().unwrap(),
+        vec![Token::Str("1.2.3.4")],
+    );
+}
+
+declare_error_tests! {
+    test_unknown_variant<Enum> {
+        vec![
+            Token::EnumUnit("Enum", "Foo"),
+        ],
+        Error::UnknownVariantError("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"),
+                Token::I32(1),
+
+                Token::MapSep,
+                Token::Str("a"),
+                Token::I32(3),
+            Token::MapEnd,
+        ],
+        Error::DuplicateFieldError("a"),
+    }
+    test_duplicate_field_enum<Enum> {
+        vec![
+            Token::EnumMapStart("Enum", "Map", Some(3)),
+                Token::EnumMapSep,
+                Token::Str("a"),
+                Token::I32(1),
+
+                Token::EnumMapSep,
+                Token::Str("a"),
+                Token::I32(3),
+            Token::EnumMapEnd,
+        ],
+        Error::DuplicateFieldError("a"),
+    }
+}

testing/tests/test_gen.rs

@@ -0,0 +1,134 @@
+// These just test that serde_codegen is able to produce code that compiles
+// successfully when there are a variety of generics and non-(de)serializable
+// types involved.
+
+extern crate serde;
+use self::serde::ser::{Serialize, Serializer};
+use self::serde::de::{Deserialize, Deserializer};
+
+//////////////////////////////////////////////////////////////////////////
+
+#[derive(Serialize, Deserialize)]
+struct With<T> {
+    t: T,
+    #[serde(serialize_with="ser_x", deserialize_with="de_x")]
+    x: X,
+}
+
+#[derive(Serialize, Deserialize)]
+struct WithRef<'a, T: 'a> {
+    #[serde(skip_deserializing)]
+    t: Option<&'a T>,
+    #[serde(serialize_with="ser_x", deserialize_with="de_x")]
+    x: X,
+}
+
+#[derive(Serialize, Deserialize)]
+struct Bounds<T: Serialize + Deserialize> {
+    t: T,
+    option: Option<T>,
+    boxed: Box<T>,
+    option_boxed: Option<Box<T>>,
+}
+
+#[derive(Serialize, Deserialize)]
+struct NoBounds<T> {
+    t: T,
+    option: Option<T>,
+    boxed: Box<T>,
+    option_boxed: Option<Box<T>>,
+}
+
+#[derive(Serialize, Deserialize)]
+enum EnumWith<T> {
+    Unit,
+    Newtype(
+        #[serde(serialize_with="ser_x", deserialize_with="de_x")]
+        X),
+    Tuple(
+        T,
+        #[serde(serialize_with="ser_x", deserialize_with="de_x")]
+        X),
+    Struct {
+        t: T,
+        #[serde(serialize_with="ser_x", deserialize_with="de_x")]
+        x: X },
+}
+
+#[derive(Serialize)]
+struct MultipleRef<'a, 'b, 'c, T> where T: 'c, 'c: 'b, 'b: 'a {
+    t: T,
+    rrrt: &'a &'b &'c T,
+}
+
+#[derive(Serialize, Deserialize)]
+struct Newtype(
+    #[serde(serialize_with="ser_x", deserialize_with="de_x")]
+    X
+);
+
+#[derive(Serialize, Deserialize)]
+struct Tuple<T>(
+    T,
+    #[serde(serialize_with="ser_x", deserialize_with="de_x")]
+    X,
+);
+
+#[derive(Serialize, Deserialize)]
+enum TreeNode<D> {
+    Split {
+        left: Box<TreeNode<D>>,
+        right: Box<TreeNode<D>>,
+    },
+    Leaf {
+        data: D,
+    },
+}
+
+#[derive(Serialize, Deserialize)]
+struct ListNode<D> {
+    data: D,
+    next: Box<ListNode<D>>,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(bound="D: SerializeWith + DeserializeWith")]
+struct WithTraits1<D, E> {
+    #[serde(serialize_with="SerializeWith::serialize_with",
+            deserialize_with="DeserializeWith::deserialize_with")]
+    d: D,
+    #[serde(serialize_with="SerializeWith::serialize_with",
+            deserialize_with="DeserializeWith::deserialize_with",
+            bound="E: SerializeWith + DeserializeWith")]
+    e: E,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(bound(serialize="D: SerializeWith",
+              deserialize="D: DeserializeWith"))]
+struct WithTraits2<D, E> {
+    #[serde(serialize_with="SerializeWith::serialize_with",
+            deserialize_with="DeserializeWith::deserialize_with")]
+    d: D,
+    #[serde(serialize_with="SerializeWith::serialize_with",
+            bound(serialize="E: SerializeWith"))]
+    #[serde(deserialize_with="DeserializeWith::deserialize_with",
+            bound(deserialize="E: DeserializeWith"))]
+    e: E,
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+trait SerializeWith {
+    fn serialize_with<S: Serializer>(_: &Self, _: &mut S) -> Result<(), S::Error>;
+}
+
+trait DeserializeWith: Sized {
+    fn deserialize_with<D: Deserializer>(_: &mut D) -> Result<Self, D::Error>;
+}
+
+// Implements neither Serialize nor Deserialize
+struct X;
+fn ser_x<S: Serializer>(_: &X, _: &mut S) -> Result<(), S::Error> { panic!() }
+fn de_x<D: Deserializer>(_: &mut D) -> Result<X, D::Error> { panic!() }
+

testing/tests/test_macros.rs

@@ -0,0 +1,633 @@
+use std::marker::PhantomData;
+use token::{Token, assert_tokens, assert_ser_tokens, assert_de_tokens};
+
+/*
+trait Trait {
+    type Type;
+}
+*/
+
+// That tests that the derived Serialize implementation doesn't trigger
+// any warning about `serializer` not being used, in case of empty enums.
+#[derive(Serialize)]
+#[allow(dead_code)]
+#[deny(unused_variables)]
+enum Void {}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+struct NamedUnit;
+
+#[derive(Debug, PartialEq, Serialize)]
+struct SerNamedTuple<'a, 'b, A: 'a, B: 'b, C>(&'a A, &'b mut B, C);
+
+#[derive(Debug, PartialEq, Deserialize)]
+struct DeNamedTuple<A, B, C>(A, B, C);
+
+#[derive(Debug, PartialEq, Serialize)]
+struct SerNamedMap<'a, 'b, A: 'a, B: 'b, C> {
+    a: &'a A,
+    b: &'b mut B,
+    c: C,
+}
+
+#[derive(Debug, PartialEq, Deserialize)]
+struct DeNamedMap<A, B, C> {
+    a: A,
+    b: B,
+    c: C,
+}
+
+#[derive(Debug, PartialEq, Serialize)]
+enum SerEnum<'a, B: 'a, C: /* Trait + */ 'a, D> where D: /* Trait + */ 'a {
+    Unit,
+    Seq(
+        i8,
+        B,
+        &'a C,
+        //C::Type,
+        &'a mut D,
+        //<D as Trait>::Type,
+    ),
+    Map {
+        a: i8,
+        b: B,
+        c: &'a C,
+        //d: C::Type,
+        e: &'a mut D,
+        //f: <D as Trait>::Type,
+    },
+
+    // Make sure we can support more than one variant.
+    _Unit2,
+    _Seq2(
+        i8,
+        B,
+        &'a C,
+        //C::Type,
+        &'a mut D,
+        //<D as Trait>::Type,
+    ),
+    _Map2 {
+        a: i8,
+        b: B,
+        c: &'a C,
+        //d: C::Type,
+        e: &'a mut D,
+        //f: <D as Trait>::Type,
+    },
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+enum DeEnum<B, C: /* Trait */, D> /* where D: Trait */ {
+    Unit,
+    Seq(
+        i8,
+        B,
+        C,
+        //C::Type,
+        D,
+        //<D as Trait>::Type,
+    ),
+    Map {
+        a: i8,
+        b: B,
+        c: C,
+        //d: C::Type,
+        e: D,
+        //f: <D as Trait>::Type,
+    },
+
+    // Make sure we can support more than one variant.
+    _Unit2,
+    _Seq2(
+        i8,
+        B,
+        C,
+        //C::Type,
+        D,
+        //<D as Trait>::Type,
+    ),
+    _Map2 {
+        a: i8,
+        b: B,
+        c: C,
+        //d: C::Type,
+        e: D,
+        //f: <D as Trait>::Type,
+    },
+}
+
+#[derive(Serialize)]
+enum Lifetimes<'a> {
+    LifetimeSeq(&'a i32),
+    NoLifetimeSeq(i32),
+    LifetimeMap { a: &'a i32 },
+    NoLifetimeMap { a: i32 },
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub struct GenericStruct<T> {
+    x: T,
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub struct GenericNewTypeStruct<T>(T);
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub struct GenericTupleStruct<T, U>(T, U);
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub enum GenericEnum<T, U> {
+    Unit,
+    NewType(T),
+    Seq(T, U),
+    Map { x: T, y: U },
+}
+
+trait AssociatedType {
+    type X;
+}
+
+impl AssociatedType for i32 {
+    type X = i32;
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+struct DefaultTyParam<T: AssociatedType<X=i32> = i32> {
+    phantom: PhantomData<T>
+}
+
+#[test]
+fn test_named_unit() {
+    assert_tokens(
+        &NamedUnit,
+        vec![Token::UnitStruct("NamedUnit")]
+    );
+}
+
+#[test]
+fn test_ser_named_tuple() {
+    let a = 5;
+    let mut b = 6;
+    let c = 7;
+    assert_ser_tokens(
+        &SerNamedTuple(&a, &mut b, c),
+        &[
+            Token::TupleStructStart("SerNamedTuple", Some(3)),
+            Token::TupleStructSep,
+            Token::I32(5),
+
+            Token::TupleStructSep,
+            Token::I32(6),
+
+            Token::TupleStructSep,
+            Token::I32(7),
+
+            Token::TupleStructEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_de_named_tuple() {
+    assert_de_tokens(
+        &DeNamedTuple(5, 6, 7),
+        vec![
+            Token::SeqStart(Some(3)),
+            Token::SeqSep,
+            Token::I32(5),
+
+            Token::SeqSep,
+            Token::I32(6),
+
+            Token::SeqSep,
+            Token::I32(7),
+
+            Token::SeqEnd,
+        ]
+    );
+
+    assert_de_tokens(
+        &DeNamedTuple(5, 6, 7),
+        vec![
+            Token::TupleStructStart("DeNamedTuple", Some(3)),
+            Token::TupleStructSep,
+            Token::I32(5),
+
+            Token::TupleStructSep,
+            Token::I32(6),
+
+            Token::TupleStructSep,
+            Token::I32(7),
+
+            Token::TupleStructEnd,
+        ]
+    );
+}
+
+#[test]
+fn test_ser_named_map() {
+    let a = 5;
+    let mut b = 6;
+    let c = 7;
+
+    assert_ser_tokens(
+        &SerNamedMap {
+            a: &a,
+            b: &mut b,
+            c: c,
+        },
+        &[
+            Token::StructStart("SerNamedMap", Some(3)),
+
+            Token::StructSep,
+            Token::Str("a"),
+            Token::I32(5),
+
+            Token::StructSep,
+            Token::Str("b"),
+            Token::I32(6),
+
+            Token::StructSep,
+            Token::Str("c"),
+            Token::I32(7),
+
+            Token::StructEnd,
+        ]
+    );
+}
+
+#[test]
+fn test_de_named_map() {
+    assert_de_tokens(
+        &DeNamedMap {
+            a: 5,
+            b: 6,
+            c: 7,
+        },
+        vec![
+            Token::StructStart("DeNamedMap", Some(3)),
+
+            Token::StructSep,
+            Token::Str("a"),
+            Token::I32(5),
+
+            Token::StructSep,
+            Token::Str("b"),
+            Token::I32(6),
+
+            Token::StructSep,
+            Token::Str("c"),
+            Token::I32(7),
+
+            Token::StructEnd,
+        ]
+    );
+}
+
+#[test]
+fn test_ser_enum_unit() {
+    assert_ser_tokens(
+        &SerEnum::Unit::<u32, u32, u32>,
+        &[
+            Token::EnumUnit("SerEnum", "Unit"),
+        ]
+    );
+}
+
+#[test]
+fn test_ser_enum_seq() {
+    let a = 1;
+    let b = 2;
+    let c = 3;
+    //let d = 4;
+    let mut e = 5;
+    //let f = 6;
+
+    assert_ser_tokens(
+        &SerEnum::Seq(
+            a,
+            b,
+            &c,
+            //d,
+            &mut e,
+            //f,
+        ),
+        &[
+            Token::EnumSeqStart("SerEnum", "Seq", Some(4)),
+
+            Token::EnumSeqSep,
+            Token::I8(1),
+
+            Token::EnumSeqSep,
+            Token::I32(2),
+
+            Token::EnumSeqSep,
+            Token::I32(3),
+
+            Token::EnumSeqSep,
+            Token::I32(5),
+
+            Token::EnumSeqEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_ser_enum_map() {
+    let a = 1;
+    let b = 2;
+    let c = 3;
+    //let d = 4;
+    let mut e = 5;
+    //let f = 6;
+
+    assert_ser_tokens(
+        &SerEnum::Map {
+            a: a,
+            b: b,
+            c: &c,
+            //d: d,
+            e: &mut e,
+            //f: f,
+        },
+        &[
+            Token::EnumMapStart("SerEnum", "Map", Some(4)),
+
+            Token::EnumMapSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::EnumMapSep,
+            Token::Str("b"),
+            Token::I32(2),
+
+            Token::EnumMapSep,
+            Token::Str("c"),
+            Token::I32(3),
+
+            Token::EnumMapSep,
+            Token::Str("e"),
+            Token::I32(5),
+
+            Token::EnumMapEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_de_enum_unit() {
+    assert_tokens(
+        &DeEnum::Unit::<u32, u32, u32>,
+        vec![
+            Token::EnumUnit("DeEnum", "Unit"),
+        ],
+    );
+}
+
+#[test]
+fn test_de_enum_seq() {
+    let a = 1;
+    let b = 2;
+    let c = 3;
+    //let d = 4;
+    let e = 5;
+    //let f = 6;
+
+    assert_tokens(
+        &DeEnum::Seq(
+            a,
+            b,
+            c,
+            //d,
+            e,
+            //f,
+        ),
+        vec![
+            Token::EnumSeqStart("DeEnum", "Seq", Some(4)),
+
+            Token::EnumSeqSep,
+            Token::I8(1),
+
+            Token::EnumSeqSep,
+            Token::I32(2),
+
+            Token::EnumSeqSep,
+            Token::I32(3),
+
+            Token::EnumSeqSep,
+            Token::I32(5),
+
+            Token::EnumSeqEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_de_enum_map() {
+    let a = 1;
+    let b = 2;
+    let c = 3;
+    //let d = 4;
+    let e = 5;
+    //let f = 6;
+
+    assert_tokens(
+        &DeEnum::Map {
+            a: a,
+            b: b,
+            c: c,
+            //d: d,
+            e: e,
+            //f: f,
+        },
+        vec![
+            Token::EnumMapStart("DeEnum", "Map", Some(4)),
+
+            Token::EnumMapSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::EnumMapSep,
+            Token::Str("b"),
+            Token::I32(2),
+
+            Token::EnumMapSep,
+            Token::Str("c"),
+            Token::I32(3),
+
+            Token::EnumMapSep,
+            Token::Str("e"),
+            Token::I32(5),
+
+            Token::EnumMapEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_lifetimes() {
+    let value = 5;
+
+    assert_ser_tokens(
+        &Lifetimes::LifetimeSeq(&value),
+        &[
+            Token::EnumNewType("Lifetimes", "LifetimeSeq"),
+            Token::I32(5),
+        ]
+    );
+
+    assert_ser_tokens(
+        &Lifetimes::NoLifetimeSeq(5),
+        &[
+            Token::EnumNewType("Lifetimes", "NoLifetimeSeq"),
+            Token::I32(5),
+        ]
+    );
+
+    assert_ser_tokens(
+        &Lifetimes::LifetimeMap { a: &value },
+        &[
+            Token::EnumMapStart("Lifetimes", "LifetimeMap", Some(1)),
+
+            Token::EnumMapSep,
+            Token::Str("a"),
+            Token::I32(5),
+
+            Token::EnumMapEnd,
+        ]
+    );
+
+    assert_ser_tokens(
+        &Lifetimes::NoLifetimeMap { a: 5 },
+        &[
+            Token::EnumMapStart("Lifetimes", "NoLifetimeMap", Some(1)),
+
+            Token::EnumMapSep,
+            Token::Str("a"),
+            Token::I32(5),
+
+            Token::EnumMapEnd,
+        ]
+    );
+}
+
+#[test]
+fn test_generic_struct() {
+    assert_tokens(
+        &GenericStruct { x: 5u32 },
+        vec![
+            Token::StructStart("GenericStruct", Some(1)),
+
+            Token::StructSep,
+            Token::Str("x"),
+            Token::U32(5),
+
+            Token::StructEnd,
+        ]
+    );
+}
+
+#[test]
+fn test_generic_newtype_struct() {
+    assert_tokens(
+        &GenericNewTypeStruct(5u32),
+        vec![
+            Token::StructNewType("GenericNewTypeStruct"),
+            Token::U32(5),
+        ]
+    );
+}
+
+#[test]
+fn test_generic_tuple_struct() {
+    assert_tokens(
+        &GenericTupleStruct(5u32, 6u32),
+        vec![
+            Token::TupleStructStart("GenericTupleStruct", Some(2)),
+
+            Token::TupleStructSep,
+            Token::U32(5),
+
+            Token::TupleStructSep,
+            Token::U32(6),
+
+            Token::TupleStructEnd,
+        ]
+    );
+}
+
+#[test]
+fn test_generic_enum_unit() {
+    assert_tokens(
+        &GenericEnum::Unit::<u32, u32>,
+        vec![
+            Token::EnumUnit("GenericEnum", "Unit"),
+        ]
+    );
+}
+
+#[test]
+fn test_generic_enum_newtype() {
+    assert_tokens(
+        &GenericEnum::NewType::<u32, u32>(5),
+        vec![
+            Token::EnumNewType("GenericEnum", "NewType"),
+            Token::U32(5),
+        ]
+    );
+}
+
+#[test]
+fn test_generic_enum_seq() {
+    assert_tokens(
+        &GenericEnum::Seq::<u32, u32>(5, 6),
+        vec![
+            Token::EnumSeqStart("GenericEnum", "Seq", Some(2)),
+
+            Token::EnumSeqSep,
+            Token::U32(5),
+
+            Token::EnumSeqSep,
+            Token::U32(6),
+
+            Token::EnumSeqEnd,
+        ]
+    );
+}
+
+#[test]
+fn test_generic_enum_map() {
+    assert_tokens(
+        &GenericEnum::Map::<u32, u32> { x: 5, y: 6 },
+        vec![
+            Token::EnumMapStart("GenericEnum", "Map", Some(2)),
+
+            Token::EnumMapSep,
+            Token::Str("x"),
+            Token::U32(5),
+
+            Token::EnumMapSep,
+            Token::Str("y"),
+            Token::U32(6),
+
+            Token::EnumMapEnd,
+        ]
+    );
+}
+
+#[test]
+fn test_default_ty_param() {
+    assert_tokens(
+        &DefaultTyParam::<i32> { phantom: PhantomData },
+        vec![
+            Token::StructStart("DefaultTyParam", Some(1)),
+
+            Token::StructSep,
+            Token::Str("phantom"),
+            Token::UnitStruct("PhantomData"),
+
+            Token::StructEnd,
+        ]
+    );
+}

testing/tests/test_ser.rs

@@ -0,0 +1,370 @@
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::net;
+use std::path::{Path, PathBuf};
+use std::str;
+
+use token::{self, Token};
+
+extern crate fnv;
+use self::fnv::FnvHasher;
+
+//////////////////////////////////////////////////////////////////////////
+
+#[derive(Serialize)]
+struct UnitStruct;
+
+#[derive(Serialize)]
+struct TupleStruct(i32, i32, i32);
+
+#[derive(Serialize)]
+struct Struct {
+    a: i32,
+    b: i32,
+    c: i32,
+}
+
+#[derive(Serialize)]
+enum Enum {
+    Unit,
+    One(i32),
+    Seq(i32, i32),
+    Map { a: i32, b: i32 },
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+declare_ser_tests! {
+    test_unit {
+        () => &[Token::Unit],
+    }
+    test_bool {
+        true => &[Token::Bool(true)],
+        false => &[Token::Bool(false)],
+    }
+    test_isizes {
+        0isize => &[Token::Isize(0)],
+        0i8 => &[Token::I8(0)],
+        0i16 => &[Token::I16(0)],
+        0i32 => &[Token::I32(0)],
+        0i64 => &[Token::I64(0)],
+    }
+    test_usizes {
+        0usize => &[Token::Usize(0)],
+        0u8 => &[Token::U8(0)],
+        0u16 => &[Token::U16(0)],
+        0u32 => &[Token::U32(0)],
+        0u64 => &[Token::U64(0)],
+    }
+    test_floats {
+        0f32 => &[Token::F32(0.)],
+        0f64 => &[Token::F64(0.)],
+    }
+    test_char {
+        'a' => &[Token::Char('a')],
+    }
+    test_str {
+        "abc" => &[Token::Str("abc")],
+        "abc".to_owned() => &[Token::Str("abc")],
+    }
+    test_option {
+        None::<i32> => &[Token::Option(false)],
+        Some(1) => &[
+            Token::Option(true),
+            Token::I32(1),
+        ],
+    }
+    test_result {
+        Ok::<i32, i32>(0) => &[
+            Token::EnumNewType("Result", "Ok"),
+            Token::I32(0),
+        ],
+        Err::<i32, i32>(1) => &[
+            Token::EnumNewType("Result", "Err"),
+            Token::I32(1),
+        ],
+    }
+    test_slice {
+        &[0][..0] => &[
+            Token::SeqStart(Some(0)),
+            Token::SeqEnd,
+        ],
+        &[1, 2, 3][..] => &[
+            Token::SeqStart(Some(3)),
+                Token::SeqSep,
+                Token::I32(1),
+
+                Token::SeqSep,
+                Token::I32(2),
+
+                Token::SeqSep,
+                Token::I32(3),
+            Token::SeqEnd,
+        ],
+    }
+    test_array {
+        [0; 0] => &[
+            Token::SeqArrayStart(0),
+            Token::SeqEnd,
+        ],
+        [1, 2, 3] => &[
+            Token::SeqArrayStart(3),
+                Token::SeqSep,
+                Token::I32(1),
+
+                Token::SeqSep,
+                Token::I32(2),
+
+                Token::SeqSep,
+                Token::I32(3),
+            Token::SeqEnd,
+        ],
+    }
+    test_vec {
+        Vec::<isize>::new() => &[
+            Token::SeqStart(Some(0)),
+            Token::SeqEnd,
+        ],
+        vec![vec![], vec![1], vec![2, 3]] => &[
+            Token::SeqStart(Some(3)),
+                Token::SeqSep,
+                Token::SeqStart(Some(0)),
+                Token::SeqEnd,
+
+                Token::SeqSep,
+                Token::SeqStart(Some(1)),
+                    Token::SeqSep,
+                    Token::I32(1),
+                Token::SeqEnd,
+
+                Token::SeqSep,
+                Token::SeqStart(Some(2)),
+                    Token::SeqSep,
+                    Token::I32(2),
+
+                    Token::SeqSep,
+                    Token::I32(3),
+                Token::SeqEnd,
+            Token::SeqEnd,
+        ],
+    }
+    test_hashset {
+        HashSet::<isize>::new() => &[
+            Token::SeqStart(Some(0)),
+            Token::SeqEnd,
+        ],
+        hashset![1] => &[
+            Token::SeqStart(Some(1)),
+                Token::SeqSep,
+                Token::I32(1),
+            Token::SeqEnd,
+        ],
+        hashset![FnvHasher @ 1] => &[
+            Token::SeqStart(Some(1)),
+                Token::SeqSep,
+                Token::I32(1),
+            Token::SeqEnd,
+        ],
+    }
+    test_tuple {
+        (1,) => &[
+            Token::TupleStart(1),
+                Token::TupleSep,
+                Token::I32(1),
+            Token::TupleEnd,
+        ],
+        (1, 2, 3) => &[
+            Token::TupleStart(3),
+                Token::TupleSep,
+                Token::I32(1),
+
+                Token::TupleSep,
+                Token::I32(2),
+
+                Token::TupleSep,
+                Token::I32(3),
+            Token::TupleEnd,
+        ],
+    }
+    test_btreemap {
+        btreemap![1 => 2] => &[
+            Token::MapStart(Some(1)),
+                Token::MapSep,
+                Token::I32(1),
+                Token::I32(2),
+            Token::MapEnd,
+        ],
+        btreemap![1 => 2, 3 => 4] => &[
+            Token::MapStart(Some(2)),
+                Token::MapSep,
+                Token::I32(1),
+                Token::I32(2),
+
+                Token::MapSep,
+                Token::I32(3),
+                Token::I32(4),
+            Token::MapEnd,
+        ],
+        btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]] => &[
+            Token::MapStart(Some(2)),
+                Token::MapSep,
+                Token::I32(1),
+                Token::MapStart(Some(0)),
+                Token::MapEnd,
+
+                Token::MapSep,
+                Token::I32(2),
+                Token::MapStart(Some(2)),
+                    Token::MapSep,
+                    Token::I32(3),
+                    Token::I32(4),
+
+                    Token::MapSep,
+                    Token::I32(5),
+                    Token::I32(6),
+                Token::MapEnd,
+            Token::MapEnd,
+        ],
+    }
+    test_hashmap {
+        HashMap::<isize, isize>::new() => &[
+            Token::MapStart(Some(0)),
+            Token::MapEnd,
+        ],
+        hashmap![1 => 2] => &[
+            Token::MapStart(Some(1)),
+                Token::MapSep,
+                Token::I32(1),
+                Token::I32(2),
+            Token::MapEnd,
+        ],
+        hashmap![FnvHasher @ 1 => 2] => &[
+            Token::MapStart(Some(1)),
+                Token::MapSep,
+                Token::I32(1),
+                Token::I32(2),
+            Token::MapEnd,
+        ],
+    }
+    test_unit_struct {
+        UnitStruct => &[Token::UnitStruct("UnitStruct")],
+    }
+    test_tuple_struct {
+        TupleStruct(1, 2, 3) => &[
+            Token::TupleStructStart("TupleStruct", Some(3)),
+                Token::TupleStructSep,
+                Token::I32(1),
+
+                Token::TupleStructSep,
+                Token::I32(2),
+
+                Token::TupleStructSep,
+                Token::I32(3),
+            Token::TupleStructEnd,
+        ],
+    }
+    test_struct {
+        Struct { a: 1, b: 2, c: 3 } => &[
+            Token::StructStart("Struct", Some(3)),
+                Token::StructSep,
+                Token::Str("a"),
+                Token::I32(1),
+
+                Token::StructSep,
+                Token::Str("b"),
+                Token::I32(2),
+
+                Token::StructSep,
+                Token::Str("c"),
+                Token::I32(3),
+            Token::StructEnd,
+        ],
+    }
+    test_enum {
+        Enum::Unit => &[Token::EnumUnit("Enum", "Unit")],
+        Enum::One(42) => &[Token::EnumNewType("Enum", "One"), Token::I32(42)],
+        Enum::Seq(1, 2) => &[
+            Token::EnumSeqStart("Enum", "Seq", Some(2)),
+                Token::EnumSeqSep,
+                Token::I32(1),
+
+                Token::EnumSeqSep,
+                Token::I32(2),
+            Token::EnumSeqEnd,
+        ],
+        Enum::Map { a: 1, b: 2 } => &[
+            Token::EnumMapStart("Enum", "Map", Some(2)),
+                Token::EnumMapSep,
+                Token::Str("a"),
+                Token::I32(1),
+
+                Token::EnumMapSep,
+                Token::Str("b"),
+                Token::I32(2),
+            Token::EnumMapEnd,
+        ],
+    }
+    test_box {
+        Box::new(0i32) => &[Token::I32(0)],
+    }
+    test_boxed_slice {
+        Box::new([0, 1, 2]) => &[
+            Token::SeqArrayStart(3),
+            Token::SeqSep,
+            Token::I32(0),
+            Token::SeqSep,
+            Token::I32(1),
+            Token::SeqSep,
+            Token::I32(2),
+            Token::SeqEnd,
+        ],
+    }
+    test_net_ipv4addr {
+        "1.2.3.4".parse::<net::Ipv4Addr>().unwrap() => &[Token::Str("1.2.3.4")],
+    }
+    test_net_ipv6addr {
+        "::1".parse::<net::Ipv6Addr>().unwrap() => &[Token::Str("::1")],
+    }
+    test_net_socketaddr {
+        "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 {
+        Path::new("/usr/local/lib") => &[
+            Token::Str("/usr/local/lib"),
+        ],
+    }
+    test_path_buf {
+        PathBuf::from("/usr/local/lib") => &[
+            Token::Str("/usr/local/lib"),
+        ],
+    }
+}
+
+#[cfg(feature = "nightly")]
+#[test]
+fn test_net_ipaddr() {
+    assert_ser_tokens(
+        "1.2.3.4".parse::<net::IpAddr>().unwrap(),
+        &[Token::Str("1.2.3.4")],
+    );
+}
+
+#[test]
+fn test_cannot_serialize_paths() {
+    let path = unsafe {
+        str::from_utf8_unchecked(b"Hello \xF0\x90\x80World")
+    };
+    token::assert_ser_tokens_error(
+        &Path::new(path),
+        &[Token::Str("Hello �World")],
+        token::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(
+        &path_buf,
+        &[Token::Str("Hello �World")],
+        token::Error::InvalidValue("Path contains invalid UTF-8 characters".to_owned()));
+}