Consistent underscores in root directory

test_suite/tests/compile-fail/duplicate-attribute/rename-and-ser.rs

@@ -0,0 +1,10 @@
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Serialize)] //~ ERROR: custom derive attribute panicked
+struct S {
+    #[serde(rename="x", serialize="y")] //~^^ HELP: unknown serde field attribute `serialize`
+    x: (),
+}
+
+fn main() {}

test_suite/tests/compile-fail/duplicate-attribute/rename-rename-de.rs

@@ -0,0 +1,11 @@
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Serialize)] //~ ERROR: custom derive attribute panicked
+struct S {
+    #[serde(rename="x")]
+    #[serde(rename(deserialize="y"))] //~^^^ HELP: duplicate serde attribute `rename`
+    x: (),
+}
+
+fn main() {}

test_suite/tests/compile-fail/duplicate-attribute/rename-ser-rename-ser.rs

@@ -0,0 +1,10 @@
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Serialize)] //~ ERROR: custom derive attribute panicked
+struct S {
+    #[serde(rename(serialize="x"), rename(serialize="y"))] //~^^ HELP: duplicate serde attribute `rename`
+    x: (),
+}
+
+fn main() {}

test_suite/tests/compile-fail/duplicate-attribute/rename-ser-rename.rs

@@ -0,0 +1,11 @@
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Serialize)] //~ ERROR: custom derive attribute panicked
+struct S {
+    #[serde(rename(serialize="x"))]
+    #[serde(rename="y")] //~^^^ HELP: duplicate serde attribute `rename`
+    x: (),
+}
+
+fn main() {}

test_suite/tests/compile-fail/duplicate-attribute/rename-ser-ser.rs

@@ -0,0 +1,10 @@
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Serialize)] //~ ERROR: custom derive attribute panicked
+struct S {
+    #[serde(rename(serialize="x", serialize="y"))] //~^^ HELP: duplicate serde attribute `rename`
+    x: (),
+}
+
+fn main() {}

test_suite/tests/compile-fail/duplicate-attribute/two-rename-ser.rs

@@ -0,0 +1,11 @@
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Serialize)] //~ ERROR: custom derive attribute panicked
+struct S {
+    #[serde(rename(serialize="x"))]
+    #[serde(rename(serialize="y"))] //~^^^ HELP: duplicate serde attribute `rename`
+    x: (),
+}
+
+fn main() {}

test_suite/tests/compile-fail/str_ref_deser.rs

@@ -0,0 +1,9 @@
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Serialize, Deserialize)] //~ ERROR: custom derive attribute panicked
+struct Test<'a> {
+    s: &'a str, //~^^ HELP: Serde does not support deserializing fields of type &str
+}
+
+fn main() {}

test_suite/tests/compile-fail/unknown-attribute/container.rs

@@ -0,0 +1,10 @@
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Serialize)] //~ ERROR: custom derive attribute panicked
+#[serde(abc="xyz")] //~^ HELP: unknown serde container attribute `abc`
+struct A {
+    x: u32,
+}
+
+fn main() { }

test_suite/tests/compile-fail/unknown-attribute/field.rs

@@ -0,0 +1,10 @@
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Serialize)] //~ ERROR: custom derive attribute panicked
+struct C {
+    #[serde(abc="xyz")] //~^^ HELP: unknown serde field attribute `abc`
+    x: u32,
+}
+
+fn main() { }

test_suite/tests/compile-fail/unknown-attribute/variant.rs

@@ -0,0 +1,10 @@
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Serialize)] //~ ERROR: custom derive attribute panicked
+enum E {
+    #[serde(abc="xyz")] //~^^ HELP: unknown serde variant attribute `abc`
+    V,
+}
+
+fn main() { }

test_suite/tests/compile_tests.rs

@@ -0,0 +1,30 @@
+extern crate compiletest_rs as compiletest;
+
+use std::path::PathBuf;
+use std::env::var;
+
+fn run_mode(mode: &'static str) {
+    let mut config = compiletest::default_config();
+
+    let cfg_mode = mode.parse().expect("Invalid mode");
+
+    config.target_rustcflags = Some("-L target/debug/ -L target/debug/deps/".to_owned());
+    if let Ok(name) = var::<&str>("TESTNAME") {
+        let s : String = name.to_owned();
+        config.filter = Some(s)
+    }
+    config.mode = cfg_mode;
+    config.src_base = PathBuf::from(format!("tests/{}", mode));
+
+    compiletest::run_tests(&config);
+}
+
+#[test]
+fn compile_fail() {
+    run_mode("compile-fail");
+}
+
+#[test]
+fn run_pass() {
+    run_mode("run-pass");
+}

test_suite/tests/macros.rs

@@ -0,0 +1,95 @@
+#[macro_export]
+macro_rules! declare_ser_tests {
+    ($($name:ident { $($value:expr => $tokens:expr,)+ })+) => {
+        $(
+            #[test]
+            fn $name() {
+                $(
+                    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
+        }
+    }
+}

test_suite/tests/run-pass/identity-op.rs

@@ -0,0 +1,12 @@
+#![deny(identity_op)]
+
+#[macro_use]
+extern crate serde_derive;
+
+// The derived implementation uses 0+1 to add up the number of fields
+// serialized, which Clippy warns about. If the expansion info is registered
+// correctly, the Clippy lint is not triggered.
+#[derive(Serialize)]
+struct A { b: u8 }
+
+fn main() {}

test_suite/tests/test.rs

@@ -0,0 +1,26 @@
+#![cfg_attr(feature = "clippy", feature(plugin))]
+#![cfg_attr(feature = "clippy", plugin(clippy))]
+
+#![cfg_attr(feature = "unstable-testing", feature(test, non_ascii_idents))]
+
+#[cfg(feature = "unstable-testing")]
+extern crate test;
+
+#[macro_use]
+extern crate serde_derive;
+
+extern crate serde;
+extern crate serde_test;
+
+#[macro_use]
+mod macros;
+
+mod test_annotations;
+mod test_bytes;
+mod test_de;
+mod test_gen;
+mod test_macros;
+mod test_ser;
+
+#[cfg(feature = "unstable-testing")]
+mod compile_tests;

test_suite/tests/test_annotations.rs

@@ -0,0 +1,976 @@
+extern crate serde;
+use self::serde::{Serialize, Serializer, Deserialize, Deserializer};
+
+extern crate serde_test;
+use self::serde_test::{
+    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: S) -> Result<S::Ok, S::Error>
+        where S: Serializer;
+}
+
+trait DeserializeWith: Sized {
+    fn deserialize_with<D>(de: 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: S) -> Result<S::Ok, S::Error>
+        where S: Serializer
+    {
+        if *self == 123 {
+            true.serialize(ser)
+        } else {
+            false.serialize(ser)
+        }
+    }
+}
+
+impl DeserializeWith for i32 {
+    fn deserialize_with<D>(de: 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 },
+        &[
+            Token::StructStart("DefaultStruct", 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 },
+        &[
+            Token::StructStart("DefaultStruct", 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 },
+        &[
+            Token::EnumMapStart("DefaultEnum", "Struct", 3),
+
+            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 },
+        &[
+            Token::EnumMapStart("DefaultEnum", "Struct", 3),
+
+            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) },
+        &[
+            Token::StructStart("ContainsNoStdDefault", 1),
+            Token::StructEnd,
+        ]
+    );
+
+    assert_de_tokens(
+        &ContainsNoStdDefault { a: NoStdDefault(8) },
+        &[
+            Token::StructStart("ContainsNoStdDefault", 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>(_: 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,
+        },
+        &[
+            Token::StructStart("ContainsNotDeserialize", 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 },
+        &[
+            Token::StructStart("DefaultStruct", 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>(
+        &[
+            Token::StructStart("DenyUnknown", 2),
+
+            Token::StructSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::StructSep,
+            Token::Str("whoops"),
+        ],
+        Error::Message("unknown field `whoops`, expected `a1`".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 },
+        &[
+            Token::StructStart("Superhero", 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", 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 },
+        &[
+            Token::StructStart("SuperheroDe", 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,
+        &[
+            Token::EnumUnit("Superhero", "bruce_wayne"),
+        ]
+    );
+
+    assert_tokens(
+        &RenameEnum::Superman(0),
+        &[
+            Token::EnumNewType("Superhero", "clark_kent"),
+            Token::I8(0),
+        ]
+    );
+
+    assert_tokens(
+        &RenameEnum::WonderWoman(0, 1),
+        &[
+            Token::EnumSeqStart("Superhero", "diana_prince", 2),
+
+            Token::EnumSeqSep,
+            Token::I8(0),
+
+            Token::EnumSeqSep,
+            Token::I8(1),
+
+            Token::EnumSeqEnd,
+        ]
+    );
+
+    assert_tokens(
+        &RenameEnum::Flash { a: 1 },
+        &[
+            Token::EnumMapStart("Superhero", "barry_allan", 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", 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(),
+        },
+        &[
+            Token::EnumMapStart("SuperheroDe", "jason_todd", 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", 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", 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", 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", 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: S) -> Result<S::Ok, 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", 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", 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", 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", 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", 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,
+        },
+        &[
+            Token::StructStart("DeserializeWithStruct", 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,
+        },
+        &[
+            Token::StructStart("DeserializeWithStruct", 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,
+        },
+        &[
+            Token::EnumMapStart("DeserializeWithEnum", "Struct", 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,
+        },
+        &[
+            Token::EnumMapStart("DeserializeWithEnum", "Struct", 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>(
+        &[
+            Token::StructStart("Superhero", 2),
+
+            Token::StructSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::StructEnd,
+        ],
+        Error::Message("missing field `a3`".to_owned()),
+    );
+
+    assert_de_tokens_error::<RenameStructSerializeDeserialize>(
+        &[
+            Token::StructStart("SuperheroDe", 2),
+
+            Token::StructSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::StructEnd,
+        ],
+        Error::Message("missing field `a5`".to_owned()),
+    );
+}
+
+#[test]
+fn test_missing_renamed_field_enum() {
+    assert_de_tokens_error::<RenameEnum>(
+        &[
+            Token::EnumMapStart("Superhero", "barry_allan", 1),
+
+            Token::EnumMapEnd,
+        ],
+        Error::Message("missing field `b`".to_owned()),
+    );
+
+    assert_de_tokens_error::<RenameEnumSerializeDeserialize<i8>>(
+        &[
+            Token::EnumMapStart("SuperheroDe", "jason_todd", 2),
+
+            Token::EnumMapSep,
+            Token::Str("a"),
+            Token::I8(0),
+
+            Token::EnumMapEnd,
+        ],
+        Error::Message("missing field `d`".to_owned()),
+    );
+}
+
+#[derive(Debug, PartialEq, Deserialize)]
+enum InvalidLengthEnum {
+    A(i32, i32, i32),
+    B(#[serde(skip_deserializing)] i32, i32, i32),
+}
+
+#[test]
+fn test_invalid_length_enum() {
+    assert_de_tokens_error::<InvalidLengthEnum>(
+        &[
+            Token::EnumSeqStart("InvalidLengthEnum", "A", 3),
+                Token::EnumSeqSep,
+                Token::I32(1),
+            Token::EnumSeqEnd,
+        ],
+        Error::Message("invalid length 1, expected tuple of 3 elements".to_owned()),
+    );
+    assert_de_tokens_error::<InvalidLengthEnum>(
+        &[
+            Token::EnumSeqStart("InvalidLengthEnum", "B", 3),
+                Token::EnumSeqSep,
+                Token::I32(1),
+            Token::EnumSeqEnd,
+        ],
+        Error::Message("invalid length 1, expected tuple of 2 elements".to_owned()),
+    );
+}

test_suite/tests/test_bytes.rs

@@ -0,0 +1,55 @@
+use serde::bytes::{ByteBuf, Bytes};
+use serde_test::{assert_tokens, assert_ser_tokens, assert_de_tokens, Token};
+
+#[test]
+fn test_bytes() {
+    let empty = Bytes::new(&[]);
+    assert_ser_tokens(&empty, &[Token::Bytes(b"")]);
+
+    let buf = vec![65, 66, 67];
+    let bytes = Bytes::new(&buf);
+    assert_ser_tokens(&bytes, &[Token::Bytes(b"ABC")]);
+}
+
+#[test]
+fn test_byte_buf() {
+    let empty = ByteBuf::new();
+    assert_tokens(&empty, &[Token::Bytes(b"")]);
+    assert_de_tokens(&empty, &[Token::ByteBuf(Vec::new())]);
+    assert_de_tokens(&empty, &[Token::Str("")]);
+    assert_de_tokens(&empty, &[Token::String(String::new())]);
+    assert_de_tokens(&empty, &[
+        Token::SeqStart(None),
+        Token::SeqEnd,
+    ]);
+    assert_de_tokens(&empty, &[
+        Token::SeqStart(Some(0)),
+        Token::SeqEnd,
+    ]);
+
+    let buf = ByteBuf::from(vec![65, 66, 67]);
+    assert_tokens(&buf, &[Token::Bytes(b"ABC")]);
+    assert_de_tokens(&buf, &[Token::ByteBuf(vec![65, 66, 67])]);
+    assert_de_tokens(&buf, &[Token::Str("ABC")]);
+    assert_de_tokens(&buf, &[Token::String("ABC".to_owned())]);
+    assert_de_tokens(&buf, &[
+        Token::SeqStart(None),
+        Token::SeqSep,
+        Token::U8(65),
+        Token::SeqSep,
+        Token::U8(66),
+        Token::SeqSep,
+        Token::U8(67),
+        Token::SeqEnd,
+    ]);
+    assert_de_tokens(&buf, &[
+        Token::SeqStart(Some(3)),
+        Token::SeqSep,
+        Token::U8(65),
+        Token::SeqSep,
+        Token::U8(66),
+        Token::SeqSep,
+        Token::U8(67),
+        Token::SeqEnd,
+    ]);
+}

test_suite/tests/test_de.rs

@@ -0,0 +1,939 @@
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::net;
+use std::path::PathBuf;
+use std::time::Duration;
+
+use serde::Deserialize;
+
+extern crate fnv;
+use self::fnv::FnvHasher;
+
+extern crate serde_test;
+use self::serde_test::{
+    Error,
+    Token,
+    assert_de_tokens,
+    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)]
+#[serde(deny_unknown_fields)]
+struct StructDenyUnknown {
+    a: i32,
+    #[serde(skip_deserializing)]
+    b: i32,
+}
+
+#[derive(PartialEq, Debug, Deserialize)]
+struct StructSkipAll {
+    #[serde(skip_deserializing)]
+    a: i32,
+}
+
+#[derive(PartialEq, Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct StructSkipAllDenyUnknown {
+    #[serde(skip_deserializing)]
+    a: i32,
+}
+
+#[derive(PartialEq, Debug, Deserialize)]
+enum Enum {
+    #[allow(dead_code)]
+    #[serde(skip_deserializing)]
+    Skipped,
+    Unit,
+    Simple(i32),
+    Seq(i32, i32, i32),
+    Map { a: i32, b: i32, c: i32 },
+}
+
+#[derive(PartialEq, Debug, Deserialize)]
+enum EnumSkipAll {
+    #[allow(dead_code)]
+    #[serde(skip_deserializing)]
+    Skipped,
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+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);
+            }
+        )+
+    }
+}
+
+fn assert_de_tokens_ignore(ignorable_tokens: &[Token<'static>]) {
+    #[derive(PartialEq, Debug, Deserialize)]
+    struct IgnoreBase {
+        a: i32,
+    }
+
+    let expected = IgnoreBase{a: 1};
+
+    // Embed the tokens to be ignored in the normal token
+    // stream for an IgnoreBase type
+    let concated_tokens : Vec<Token<'static>> = vec![
+            Token::MapStart(Some(2)),
+                Token::MapSep,
+                Token::Str("a"),
+                Token::I32(1),
+
+                Token::MapSep,
+                Token::Str("ignored")
+        ]
+        .into_iter()
+        .chain(ignorable_tokens.to_vec().into_iter())
+        .chain(vec![
+            Token::MapEnd,
+        ].into_iter())
+        .collect();
+
+    let mut de = serde_test::Deserializer::new(concated_tokens.into_iter());
+    let v: Result<IgnoreBase, Error> = Deserialize::deserialize(&mut de);
+
+    // We run this test on every token stream for convenience, but
+    // some token streams don't make sense embedded as a map value,
+    // so we ignore those. SyntaxError is the real sign of trouble.
+    if let Err(Error::UnexpectedToken(_)) = v {
+        return;
+    }
+
+    assert_eq!(v.as_ref(), Ok(&expected));
+    assert_eq!(de.next_token(), None);
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+declare_tests! {
+    test_bool {
+        true => &[Token::Bool(true)],
+        false => &[Token::Bool(false)],
+    }
+    test_isize {
+        0isize => &[Token::I8(0)],
+        0isize => &[Token::I16(0)],
+        0isize => &[Token::I32(0)],
+        0isize => &[Token::I64(0)],
+        0isize => &[Token::U8(0)],
+        0isize => &[Token::U16(0)],
+        0isize => &[Token::U32(0)],
+        0isize => &[Token::U64(0)],
+        0isize => &[Token::F32(0.)],
+        0isize => &[Token::F64(0.)],
+    }
+    test_ints {
+        0i8 => &[Token::I8(0)],
+        0i16 => &[Token::I16(0)],
+        0i32 => &[Token::I32(0)],
+        0i64 => &[Token::I64(0)],
+    }
+    test_uints {
+        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')],
+        'a' => &[Token::Str("a")],
+        'a' => &[Token::String("a".to_owned())],
+    }
+    test_string {
+        "abc".to_owned() => &[Token::Str("abc")],
+        "abc".to_owned() => &[Token::String("abc".to_owned())],
+        "a".to_owned() => &[Token::Char('a')],
+    }
+    test_option {
+        None::<i32> => &[Token::Unit],
+        None::<i32> => &[Token::Option(false)],
+        Some(1) => &[Token::I32(1)],
+        Some(1) => &[
+            Token::Option(true),
+            Token::I32(1),
+        ],
+    }
+    test_result {
+        Ok::<i32, i32>(0) => &[
+            Token::EnumStart("Result"),
+            Token::Str("Ok"),
+            Token::I32(0),
+        ],
+        Err::<i32, i32>(1) => &[
+            Token::EnumStart("Result"),
+            Token::Str("Err"),
+            Token::I32(1),
+        ],
+    }
+    test_unit {
+        () => &[Token::Unit],
+        () => &[
+            Token::SeqStart(Some(0)),
+            Token::SeqEnd,
+        ],
+        () => &[
+            Token::SeqStart(None),
+            Token::SeqEnd,
+        ],
+        () => &[
+            Token::TupleStructStart("Anything", 0),
+            Token::SeqEnd,
+        ],
+    }
+    test_unit_struct {
+        UnitStruct => &[Token::Unit],
+        UnitStruct => &[
+            Token::UnitStruct("UnitStruct"),
+        ],
+        UnitStruct => &[
+            Token::SeqStart(Some(0)),
+            Token::SeqEnd,
+        ],
+        UnitStruct => &[
+            Token::SeqStart(None),
+            Token::SeqEnd,
+        ],
+    }
+    test_unit_string {
+        String::new() => &[Token::Unit],
+    }
+    test_tuple_struct {
+        TupleStruct(1, 2, 3) => &[
+            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) => &[
+            Token::SeqStart(None),
+                Token::SeqSep,
+                Token::I32(1),
+
+                Token::SeqSep,
+                Token::I32(2),
+
+                Token::SeqSep,
+                Token::I32(3),
+            Token::SeqEnd,
+        ],
+        TupleStruct(1, 2, 3) => &[
+            Token::TupleStructStart("TupleStruct", 3),
+                Token::TupleStructSep,
+                Token::I32(1),
+
+                Token::TupleStructSep,
+                Token::I32(2),
+
+                Token::TupleStructSep,
+                Token::I32(3),
+            Token::TupleStructEnd,
+        ],
+        TupleStruct(1, 2, 3) => &[
+            Token::TupleStructStart("TupleStruct", 3),
+                Token::TupleStructSep,
+                Token::I32(1),
+
+                Token::TupleStructSep,
+                Token::I32(2),
+
+                Token::TupleStructSep,
+                Token::I32(3),
+            Token::TupleStructEnd,
+        ],
+    }
+    test_btreeset {
+        BTreeSet::<isize>::new() => &[
+            Token::Unit,
+        ],
+        BTreeSet::<isize>::new() => &[
+            Token::SeqStart(Some(0)),
+            Token::SeqEnd,
+        ],
+        btreeset![btreeset![], btreeset![1], btreeset![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,
+        ],
+        BTreeSet::<isize>::new() => &[
+            Token::UnitStruct("Anything"),
+        ],
+        BTreeSet::<isize>::new() => &[
+            Token::TupleStructStart("Anything", 0),
+            Token::SeqEnd,
+        ],
+    }
+    test_hashset {
+        HashSet::<isize>::new() => &[
+            Token::Unit,
+        ],
+        HashSet::<isize>::new() => &[
+            Token::SeqStart(Some(0)),
+            Token::SeqEnd,
+        ],
+        hashset![1, 2, 3] => &[
+            Token::SeqStart(Some(3)),
+                Token::SeqSep,
+                Token::I32(1),
+
+                Token::SeqSep,
+                Token::I32(2),
+
+                Token::SeqSep,
+                Token::I32(3),
+            Token::SeqEnd,
+        ],
+        HashSet::<isize>::new() => &[
+            Token::UnitStruct("Anything"),
+        ],
+        HashSet::<isize>::new() => &[
+            Token::TupleStructStart("Anything", 0),
+            Token::SeqEnd,
+        ],
+        hashset![FnvHasher @ 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_vec {
+        Vec::<isize>::new() => &[
+            Token::Unit,
+        ],
+        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,
+        ],
+        Vec::<isize>::new() => &[
+            Token::UnitStruct("Anything"),
+        ],
+        Vec::<isize>::new() => &[
+            Token::TupleStructStart("Anything", 0),
+            Token::SeqEnd,
+        ],
+    }
+    test_array {
+        [0; 0] => &[
+            Token::Unit,
+        ],
+        [0; 0] => &[
+            Token::SeqStart(Some(0)),
+            Token::SeqEnd,
+        ],
+        [0; 0] => &[
+            Token::SeqArrayStart(0),
+            Token::SeqEnd,
+        ],
+        ([0; 0], [1], [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,
+        ],
+        ([0; 0], [1], [2, 3]) => &[
+            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] => &[
+            Token::UnitStruct("Anything"),
+        ],
+        [0; 0] => &[
+            Token::TupleStructStart("Anything", 0),
+            Token::SeqEnd,
+        ],
+    }
+    test_tuple {
+        (1,) => &[
+            Token::SeqStart(Some(1)),
+                Token::SeqSep,
+                Token::I32(1),
+            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,
+        ],
+        (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::<isize, isize>::new() => &[
+            Token::Unit,
+        ],
+        BTreeMap::<isize, isize>::new() => &[
+            Token::MapStart(Some(0)),
+            Token::MapEnd,
+        ],
+        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,
+        ],
+        BTreeMap::<isize, isize>::new() => &[
+            Token::UnitStruct("Anything"),
+        ],
+        BTreeMap::<isize, isize>::new() => &[
+            Token::StructStart("Anything", 0),
+            Token::MapEnd,
+        ],
+    }
+    test_hashmap {
+        HashMap::<isize, isize>::new() => &[
+            Token::Unit,
+        ],
+        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![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,
+        ],
+        hashmap![1 => hashmap![], 2 => hashmap![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,
+        ],
+        HashMap::<isize, isize>::new() => &[
+            Token::UnitStruct("Anything"),
+        ],
+        HashMap::<isize, isize>::new() => &[
+            Token::StructStart("Anything", 0),
+            Token::MapEnd,
+        ],
+        hashmap![FnvHasher @ 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,
+        ],
+    }
+    test_struct {
+        Struct { a: 1, b: 2, c: 0 } => &[
+            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 } => &[
+            Token::StructStart("Struct", 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 } => &[
+            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 } => &[
+            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 } => &[
+            Token::StructStart("Struct", 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_struct_skip_all {
+        StructSkipAll { a: 0 } => &[
+            Token::StructStart("StructSkipAll", 0),
+            Token::StructEnd,
+        ],
+        StructSkipAll { a: 0 } => &[
+            Token::StructStart("StructSkipAll", 1),
+                Token::StructSep,
+                Token::Str("a"),
+                Token::I32(1),
+
+                Token::StructSep,
+                Token::Str("b"),
+                Token::I32(2),
+            Token::StructEnd,
+        ],
+    }
+    test_struct_skip_all_deny_unknown {
+        StructSkipAllDenyUnknown { a: 0 } => &[
+            Token::StructStart("StructSkipAllDenyUnknown", 0),
+            Token::StructEnd,
+        ],
+    }
+    test_enum_unit {
+        Enum::Unit => &[
+            Token::EnumUnit("Enum", "Unit"),
+        ],
+    }
+    test_enum_simple {
+        Enum::Simple(1) => &[
+            Token::EnumNewType("Enum", "Simple"),
+            Token::I32(1),
+        ],
+    }
+    test_enum_seq {
+        Enum::Seq(1, 2, 3) => &[
+            Token::EnumSeqStart("Enum", "Seq", 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 } => &[
+            Token::EnumMapStart("Enum", "Map", 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 => &[
+            Token::EnumStart("Enum"),
+            Token::U32(0),
+            Token::Unit,
+        ],
+    }
+    test_enum_unit_bytes {
+        Enum::Unit => &[
+            Token::EnumStart("Enum"),
+            Token::Bytes(b"Unit"),
+            Token::Unit,
+        ],
+    }
+    test_box {
+        Box::new(0i32) => &[Token::I32(0)],
+    }
+    test_boxed_slice {
+        Box::new([0, 1, 2]) => &[
+            Token::SeqStart(Some(3)),
+            Token::SeqSep,
+            Token::I32(0),
+            Token::SeqSep,
+            Token::I32(1),
+            Token::SeqSep,
+            Token::I32(2),
+            Token::SeqEnd,
+        ],
+    }
+    test_duration {
+        Duration::new(1, 2) => &[
+            Token::StructStart("Duration", 2),
+                Token::StructSep,
+                Token::Str("secs"),
+                Token::U64(1),
+
+                Token::StructSep,
+                Token::Str("nanos"),
+                Token::U32(2),
+            Token::StructEnd,
+        ],
+        Duration::new(1, 2) => &[
+            Token::SeqStart(Some(2)),
+                Token::SeqSep,
+                Token::I64(1),
+
+                Token::SeqSep,
+                Token::I64(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_buf {
+        PathBuf::from("/usr/local/lib") => &[
+            Token::String("/usr/local/lib".to_owned()),
+        ],
+    }
+}
+
+#[cfg(feature = "unstable")]
+#[test]
+fn test_net_ipaddr() {
+    assert_de_tokens(
+        "1.2.3.4".parse::<net::IpAddr>().unwrap(),
+        &[Token::Str("1.2.3.4")],
+    );
+}
+
+declare_error_tests! {
+    test_unknown_field<StructDenyUnknown> {
+        &[
+            Token::StructStart("StructDenyUnknown", 2),
+                Token::StructSep,
+                Token::Str("a"),
+                Token::I32(0),
+
+                Token::StructSep,
+                Token::Str("d"),
+        ],
+        Error::Message("unknown field `d`, expected `a`".to_owned()),
+    }
+    test_skipped_field_is_unknown<StructDenyUnknown> {
+        &[
+            Token::StructStart("StructDenyUnknown", 2),
+                Token::StructSep,
+                Token::Str("b"),
+        ],
+        Error::Message("unknown field `b`, expected `a`".to_owned()),
+    }
+    test_skip_all_deny_unknown<StructSkipAllDenyUnknown> {
+        &[
+            Token::StructStart("StructSkipAllDenyUnknown", 1),
+                Token::StructSep,
+                Token::Str("a"),
+        ],
+        Error::Message("unknown field `a`, there are no fields".to_owned()),
+    }
+    test_unknown_variant<Enum> {
+        &[
+            Token::EnumUnit("Enum", "Foo"),
+        ],
+        Error::Message("unknown variant `Foo`, expected one of `Unit`, `Simple`, `Seq`, `Map`".to_owned()),
+    }
+    test_enum_skipped_variant<Enum> {
+        &[
+            Token::EnumUnit("Enum", "Skipped"),
+        ],
+        Error::Message("unknown variant `Skipped`, expected one of `Unit`, `Simple`, `Seq`, `Map`".to_owned()),
+    }
+    test_enum_skip_all<EnumSkipAll> {
+        &[
+            Token::EnumUnit("EnumSkipAll", "Skipped"),
+        ],
+        Error::Message("unknown variant `Skipped`, there are no variants".to_owned()),
+    }
+    test_struct_seq_too_long<Struct> {
+        &[
+            Token::SeqStart(Some(4)),
+                Token::SeqSep, Token::I32(1),
+                Token::SeqSep, Token::I32(2),
+                Token::SeqSep, Token::I32(3),
+        ],
+        Error::UnexpectedToken(Token::SeqSep),
+    }
+    test_duplicate_field_struct<Struct> {
+        &[
+            Token::MapStart(Some(3)),
+                Token::MapSep,
+                Token::Str("a"),
+                Token::I32(1),
+
+                Token::MapSep,
+                Token::Str("a"),
+        ],
+        Error::Message("duplicate field `a`".to_owned()),
+    }
+    test_duplicate_field_enum<Enum> {
+        &[
+            Token::EnumMapStart("Enum", "Map", 3),
+                Token::EnumMapSep,
+                Token::Str("a"),
+                Token::I32(1),
+
+                Token::EnumMapSep,
+                Token::Str("a"),
+        ],
+        Error::Message("duplicate field `a`".to_owned()),
+    }
+    test_enum_out_of_range<Enum> {
+        &[
+            Token::EnumStart("Enum"),
+            Token::U32(4),
+            Token::Unit,
+        ],
+        Error::Message("invalid value: integer `4`, expected variant index 0 <= i < 4".into()),
+    }
+}

test_suite/tests/test_gen.rs

@@ -0,0 +1,326 @@
+// 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};
+
+use std::borrow::Cow;
+use std::marker::PhantomData;
+
+// Try to trip up the generated code if it fails to use fully qualified paths.
+#[allow(dead_code)]
+struct Result;
+use std::result::Result as StdResult;
+
+//////////////////////////////////////////////////////////////////////////
+
+#[test]
+fn test_gen() {
+    #[derive(Serialize, Deserialize)]
+    struct With<T> {
+        t: T,
+        #[serde(serialize_with="ser_x", deserialize_with="de_x")]
+        x: X,
+    }
+    assert::<With<i32>>();
+
+    #[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,
+    }
+    assert::<WithRef<i32>>();
+
+    #[derive(Serialize, Deserialize)]
+    struct PhantomX {
+        x: PhantomData<X>,
+    }
+    assert::<PhantomX>();
+
+    #[derive(Serialize, Deserialize)]
+    struct PhantomT<T> {
+        t: PhantomData<T>,
+    }
+    assert::<PhantomT<X>>();
+
+    #[derive(Serialize, Deserialize)]
+    struct Bounds<T: Serialize + Deserialize> {
+        t: T,
+        option: Option<T>,
+        boxed: Box<T>,
+        option_boxed: Option<Box<T>>,
+    }
+    assert::<Bounds<i32>>();
+
+    #[derive(Serialize, Deserialize)]
+    struct NoBounds<T> {
+        t: T,
+        option: Option<T>,
+        boxed: Box<T>,
+        option_boxed: Option<Box<T>>,
+    }
+    assert::<NoBounds<i32>>();
+
+    #[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 },
+    }
+    assert::<EnumWith<i32>>();
+
+    #[derive(Serialize)]
+    struct MultipleRef<'a, 'b, 'c, T> where T: 'c, 'c: 'b, 'b: 'a {
+        t: T,
+        rrrt: &'a &'b &'c T,
+    }
+    assert_ser::<MultipleRef<i32>>();
+
+    #[derive(Serialize, Deserialize)]
+    struct Newtype(
+        #[serde(serialize_with="ser_x", deserialize_with="de_x")]
+        X
+    );
+    assert::<Newtype>();
+
+    #[derive(Serialize, Deserialize)]
+    struct Tuple<T>(
+        T,
+        #[serde(serialize_with="ser_x", deserialize_with="de_x")]
+        X,
+    );
+    assert::<Tuple<i32>>();
+
+    #[derive(Serialize, Deserialize)]
+    enum TreeNode<D> {
+        Split {
+            left: Box<TreeNode<D>>,
+            right: Box<TreeNode<D>>,
+        },
+        Leaf {
+            data: D,
+        },
+    }
+    assert::<TreeNode<i32>>();
+
+    #[derive(Serialize, Deserialize)]
+    struct ListNode<D> {
+        data: D,
+        next: Box<ListNode<D>>,
+    }
+    assert::<ListNode<i32>>();
+
+    #[derive(Serialize, Deserialize)]
+    struct RecursiveA {
+        b: Box<RecursiveB>,
+    }
+    assert::<RecursiveA>();
+
+    #[derive(Serialize, Deserialize)]
+    enum RecursiveB {
+        A(RecursiveA),
+    }
+    assert::<RecursiveB>();
+
+    #[derive(Serialize, Deserialize)]
+    struct RecursiveGenericA<T> {
+        t: T,
+        b: Box<RecursiveGenericB<T>>,
+    }
+    assert::<RecursiveGenericA<i32>>();
+
+    #[derive(Serialize, Deserialize)]
+    enum RecursiveGenericB<T> {
+        T(T),
+        A(RecursiveGenericA<T>),
+    }
+    assert::<RecursiveGenericB<i32>>();
+
+    #[derive(Serialize)]
+    struct OptionStatic<'a> {
+        a: Option<&'a str>,
+        b: Option<&'static str>,
+    }
+    assert_ser::<OptionStatic>();
+
+    #[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,
+    }
+    assert::<WithTraits1<X, X>>();
+
+    #[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,
+    }
+    assert::<WithTraits2<X, X>>();
+
+    #[derive(Serialize, Deserialize)]
+    struct CowStr<'a>(Cow<'a, str>);
+    assert::<CowStr>();
+
+    #[derive(Serialize, Deserialize)]
+    #[serde(bound(deserialize = "T::Owned: Deserialize"))]
+    struct CowT<'a, T: ?Sized + 'a + ToOwned>(Cow<'a, T>);
+    assert::<CowT<str>>();
+
+    #[derive(Serialize, Deserialize)]
+    struct EmptyStruct {}
+    assert::<EmptyStruct>();
+
+    #[derive(Serialize, Deserialize)]
+    enum EmptyEnumVariant {
+        EmptyStruct {},
+    }
+    assert::<EmptyEnumVariant>();
+
+    #[cfg(feature = "unstable-testing")]
+    #[cfg_attr(feature = "unstable-testing", derive(Serialize, Deserialize))]
+    struct NonAsciiIdents {
+        σ: f64
+    }
+
+    #[derive(Serialize, Deserialize)]
+    struct EmptyBraced {}
+
+    #[derive(Serialize, Deserialize)]
+    #[serde(deny_unknown_fields)]
+    struct EmptyBracedDenyUnknown {}
+
+    #[derive(Serialize, Deserialize)]
+    struct BracedSkipAll {
+        #[serde(skip_deserializing)]
+        f: u8,
+    }
+
+    #[derive(Serialize, Deserialize)]
+    #[serde(deny_unknown_fields)]
+    struct BracedSkipAllDenyUnknown {
+        #[serde(skip_deserializing)]
+        f: u8,
+    }
+
+    #[cfg(feature = "unstable-testing")]
+    #[cfg_attr(feature = "unstable-testing", derive(Serialize, Deserialize))]
+    struct EmptyTuple();
+
+    #[cfg(feature = "unstable-testing")]
+    #[cfg_attr(feature = "unstable-testing", derive(Serialize, Deserialize))]
+    #[serde(deny_unknown_fields)]
+    struct EmptyTupleDenyUnknown();
+
+    #[derive(Serialize, Deserialize)]
+    struct TupleSkipAll(#[serde(skip_deserializing)] u8);
+
+    #[derive(Serialize, Deserialize)]
+    #[serde(deny_unknown_fields)]
+    struct TupleSkipAllDenyUnknown(#[serde(skip_deserializing)] u8);
+
+    #[derive(Serialize, Deserialize)]
+    enum EmptyEnum {}
+
+    #[derive(Serialize, Deserialize)]
+    #[serde(deny_unknown_fields)]
+    enum EmptyEnumDenyUnknown {}
+
+    #[derive(Serialize, Deserialize)]
+    enum EnumSkipAll {
+        #[serde(skip_deserializing)]
+        #[allow(dead_code)]
+        Variant,
+    }
+
+    #[cfg(feature = "unstable-testing")]
+    #[cfg_attr(feature = "unstable-testing", derive(Serialize, Deserialize))]
+    enum EmptyVariants {
+        Braced {},
+        Tuple(),
+        BracedSkip {
+            #[serde(skip_deserializing)]
+            f: u8,
+        },
+        TupleSkip(#[serde(skip_deserializing)] u8),
+    }
+
+    #[cfg(feature = "unstable-testing")]
+    #[cfg_attr(feature = "unstable-testing", derive(Serialize, Deserialize))]
+    #[serde(deny_unknown_fields)]
+    enum EmptyVariantsDenyUnknown {
+        Braced {},
+        Tuple(),
+        BracedSkip {
+            #[serde(skip_deserializing)]
+            f: u8,
+        },
+        TupleSkip(#[serde(skip_deserializing)] u8),
+    }
+
+    #[derive(Serialize, Deserialize)]
+    #[serde(deny_unknown_fields)]
+    struct UnitDenyUnknown;
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+fn assert<T: Serialize + Deserialize>() {}
+fn assert_ser<T: Serialize>() {}
+
+trait SerializeWith {
+    fn serialize_with<S: Serializer>(_: &Self, _: S) -> StdResult<S::Ok, S::Error>;
+}
+
+trait DeserializeWith: Sized {
+    fn deserialize_with<D: Deserializer>(_: D) -> StdResult<Self, D::Error>;
+}
+
+// Implements neither Serialize nor Deserialize
+struct X;
+
+fn ser_x<S: Serializer>(_: &X, _: S) -> StdResult<S::Ok, S::Error> {
+    unimplemented!()
+}
+
+fn de_x<D: Deserializer>(_: D) -> StdResult<X, D::Error> {
+    unimplemented!()
+}
+
+impl SerializeWith for X {
+    fn serialize_with<S: Serializer>(_: &Self, _: S) -> StdResult<S::Ok, S::Error> {
+        unimplemented!()
+    }
+}
+
+impl DeserializeWith for X {
+    fn deserialize_with<D: Deserializer>(_: D) -> StdResult<Self, D::Error> {
+        unimplemented!()
+    }
+}

test_suite/tests/test_macros.rs

@@ -0,0 +1,627 @@
+extern crate serde_test;
+use self::serde_test::{
+    Token,
+    assert_tokens,
+    assert_ser_tokens,
+    assert_de_tokens,
+};
+
+use std::marker::PhantomData;
+
+// That tests that the derived Serialize implementation doesn't trigger
+// any warning about `serializer` not being used, in case of empty enums.
+#[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: 'a, D> where D: 'a {
+    Unit,
+    Seq(
+        i8,
+        B,
+        &'a C,
+        &'a mut D,
+    ),
+    Map {
+        a: i8,
+        b: B,
+        c: &'a C,
+        d: &'a mut D,
+    },
+
+    // Make sure we can support more than one variant.
+    _Unit2,
+    _Seq2(
+        i8,
+        B,
+        &'a C,
+        &'a mut D,
+    ),
+    _Map2 {
+        a: i8,
+        b: B,
+        c: &'a C,
+        d: &'a mut D,
+    },
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+enum DeEnum<B, C, D> {
+    Unit,
+    Seq(
+        i8,
+        B,
+        C,
+        D,
+    ),
+    Map {
+        a: i8,
+        b: B,
+        c: C,
+        d: D,
+    },
+
+    // Make sure we can support more than one variant.
+    _Unit2,
+    _Seq2(
+        i8,
+        B,
+        C,
+        D,
+    ),
+    _Map2 {
+        a: i8,
+        b: B,
+        c: C,
+        d: D,
+    },
+}
+
+#[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,
+        &[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", 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),
+        &[
+            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),
+        &[
+            Token::TupleStructStart("DeNamedTuple", 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", 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,
+        },
+        &[
+            Token::StructStart("DeNamedMap", 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 mut d = 4;
+
+    assert_ser_tokens(
+        &SerEnum::Seq(
+            a,
+            b,
+            &c,
+            &mut d,
+        ),
+        &[
+            Token::EnumSeqStart("SerEnum", "Seq", 4),
+
+            Token::EnumSeqSep,
+            Token::I8(1),
+
+            Token::EnumSeqSep,
+            Token::I32(2),
+
+            Token::EnumSeqSep,
+            Token::I32(3),
+
+            Token::EnumSeqSep,
+            Token::I32(4),
+
+            Token::EnumSeqEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_ser_enum_map() {
+    let a = 1;
+    let b = 2;
+    let c = 3;
+    let mut d = 4;
+
+    assert_ser_tokens(
+        &SerEnum::Map {
+            a: a,
+            b: b,
+            c: &c,
+            d: &mut d,
+        },
+        &[
+            Token::EnumMapStart("SerEnum", "Map", 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("d"),
+            Token::I32(4),
+
+            Token::EnumMapEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_de_enum_unit() {
+    assert_tokens(
+        &DeEnum::Unit::<u32, u32, u32>,
+        &[
+            Token::EnumUnit("DeEnum", "Unit"),
+        ],
+    );
+}
+
+#[test]
+fn test_de_enum_seq() {
+    let a = 1;
+    let b = 2;
+    let c = 3;
+    let d = 4;
+
+    assert_tokens(
+        &DeEnum::Seq(
+            a,
+            b,
+            c,
+            d,
+        ),
+        &[
+            Token::EnumSeqStart("DeEnum", "Seq", 4),
+
+            Token::EnumSeqSep,
+            Token::I8(1),
+
+            Token::EnumSeqSep,
+            Token::I32(2),
+
+            Token::EnumSeqSep,
+            Token::I32(3),
+
+            Token::EnumSeqSep,
+            Token::I32(4),
+
+            Token::EnumSeqEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_de_enum_map() {
+    let a = 1;
+    let b = 2;
+    let c = 3;
+    let d = 4;
+
+    assert_tokens(
+        &DeEnum::Map {
+            a: a,
+            b: b,
+            c: c,
+            d: d,
+        },
+        &[
+            Token::EnumMapStart("DeEnum", "Map", 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("d"),
+            Token::I32(4),
+
+            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", 1),
+
+            Token::EnumMapSep,
+            Token::Str("a"),
+            Token::I32(5),
+
+            Token::EnumMapEnd,
+        ]
+    );
+
+    assert_ser_tokens(
+        &Lifetimes::NoLifetimeMap { a: 5 },
+        &[
+            Token::EnumMapStart("Lifetimes", "NoLifetimeMap", 1),
+
+            Token::EnumMapSep,
+            Token::Str("a"),
+            Token::I32(5),
+
+            Token::EnumMapEnd,
+        ]
+    );
+}
+
+#[test]
+fn test_generic_struct() {
+    assert_tokens(
+        &GenericStruct { x: 5u32 },
+        &[
+            Token::StructStart("GenericStruct", 1),
+
+            Token::StructSep,
+            Token::Str("x"),
+            Token::U32(5),
+
+            Token::StructEnd,
+        ]
+    );
+}
+
+#[test]
+fn test_generic_newtype_struct() {
+    assert_tokens(
+        &GenericNewTypeStruct(5u32),
+        &[
+            Token::StructNewType("GenericNewTypeStruct"),
+            Token::U32(5),
+        ]
+    );
+}
+
+#[test]
+fn test_generic_tuple_struct() {
+    assert_tokens(
+        &GenericTupleStruct(5u32, 6u32),
+        &[
+            Token::TupleStructStart("GenericTupleStruct", 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>,
+        &[
+            Token::EnumUnit("GenericEnum", "Unit"),
+        ]
+    );
+}
+
+#[test]
+fn test_generic_enum_newtype() {
+    assert_tokens(
+        &GenericEnum::NewType::<u32, u32>(5),
+        &[
+            Token::EnumNewType("GenericEnum", "NewType"),
+            Token::U32(5),
+        ]
+    );
+}
+
+#[test]
+fn test_generic_enum_seq() {
+    assert_tokens(
+        &GenericEnum::Seq::<u32, u32>(5, 6),
+        &[
+            Token::EnumSeqStart("GenericEnum", "Seq", 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 },
+        &[
+            Token::EnumMapStart("GenericEnum", "Map", 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 },
+        &[
+            Token::StructStart("DefaultTyParam", 1),
+
+            Token::StructSep,
+            Token::Str("phantom"),
+            Token::UnitStruct("PhantomData"),
+
+            Token::StructEnd,
+        ]
+    );
+}
+
+#[test]
+fn test_enum_state_field() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    enum SomeEnum {
+        Key { key: char, state: bool },
+    }
+
+    assert_tokens(
+        &SomeEnum::Key { key: 'a', state: true },
+        &[
+            Token::EnumMapStart("SomeEnum", "Key", 2),
+
+            Token::EnumMapSep,
+            Token::Str("key"),
+            Token::Char('a'),
+
+            Token::EnumMapSep,
+            Token::Str("state"),
+            Token::Bool(true),
+
+            Token::EnumMapEnd,
+        ]
+    );
+}

test_suite/tests/test_ser.rs

@@ -0,0 +1,462 @@
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::net;
+use std::path::{Path, PathBuf};
+use std::str;
+use std::time::Duration;
+
+extern crate serde_test;
+use self::serde_test::{
+    Error,
+    Token,
+    assert_ser_tokens,
+    assert_ser_tokens_error,
+};
+
+extern crate fnv;
+use self::fnv::FnvHasher;
+
+#[cfg(feature = "unstable")]
+use serde::ser::iterator;
+
+//////////////////////////////////////////////////////////////////////////
+
+#[derive(Serialize)]
+struct UnitStruct;
+
+#[derive(Serialize)]
+struct TupleStruct(i32, i32, i32);
+
+#[derive(Serialize)]
+struct Struct {
+    a: i32,
+    b: i32,
+    c: i32,
+}
+
+#[derive(Serialize, PartialEq, Debug)]
+enum Enum {
+    Unit,
+    One(i32),
+    Seq(i32, i32),
+    Map { a: i32, b: i32 },
+    #[serde(skip_serializing)]
+    SkippedUnit,
+    #[serde(skip_serializing)]
+    SkippedOne(i32),
+    #[serde(skip_serializing)]
+    SkippedSeq(i32, i32),
+    #[serde(skip_serializing)]
+    SkippedMap { _a: i32, _b: i32 },
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+declare_ser_tests! {
+    test_unit {
+        () => &[Token::Unit],
+    }
+    test_bool {
+        true => &[Token::Bool(true)],
+        false => &[Token::Bool(false)],
+    }
+    test_isizes {
+        0i8 => &[Token::I8(0)],
+        0i16 => &[Token::I16(0)],
+        0i32 => &[Token::I32(0)],
+        0i64 => &[Token::I64(0)],
+    }
+    test_usizes {
+        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", 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", 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", 2),
+                Token::EnumSeqSep,
+                Token::I32(1),
+
+                Token::EnumSeqSep,
+                Token::I32(2),
+            Token::EnumSeqEnd,
+        ],
+        Enum::Map { a: 1, b: 2 } => &[
+            Token::EnumMapStart("Enum", "Map", 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_duration {
+        Duration::new(1, 2) => &[
+            Token::StructStart("Duration", 2),
+                Token::StructSep,
+                Token::Str("secs"),
+                Token::U64(1),
+
+                Token::StructSep,
+                Token::Str("nanos"),
+                Token::U32(2),
+            Token::StructEnd,
+        ],
+    }
+    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 = "unstable")]
+#[test]
+fn test_iterator() {
+    assert_ser_tokens(iterator([0; 0].iter()), &[
+        Token::SeqStart(Some(0)),
+        Token::SeqEnd,
+    ]);
+    assert_ser_tokens(iterator([1, 2, 3].iter()), &[
+        Token::SeqStart(Some(3)),
+            Token::SeqSep,
+            Token::I32(1),
+
+            Token::SeqSep,
+            Token::I32(2),
+
+            Token::SeqSep,
+            Token::I32(3),
+        Token::SeqEnd,
+    ]);
+    assert_ser_tokens(iterator([1, 2, 3].iter().map(|x| x * 2)), &[
+        Token::SeqStart(Some(3)),
+            Token::SeqSep,
+            Token::I32(2),
+
+            Token::SeqSep,
+            Token::I32(4),
+
+            Token::SeqSep,
+            Token::I32(6),
+        Token::SeqEnd,
+    ]);
+    assert_ser_tokens(iterator([1, 2, 3].iter().filter(|&x| x % 2 != 0)), &[
+        Token::SeqStart(None),
+            Token::SeqSep,
+            Token::I32(1),
+
+            Token::SeqSep,
+            Token::I32(3),
+        Token::SeqEnd,
+    ]);
+}
+
+#[cfg(feature = "unstable")]
+#[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")
+    };
+    assert_ser_tokens_error(
+        &Path::new(path),
+        &[],
+        Error::Message("path contains invalid UTF-8 characters".to_owned()));
+
+    let mut path_buf = PathBuf::new();
+    path_buf.push(path);
+
+    assert_ser_tokens_error(
+        &path_buf,
+        &[],
+        Error::Message("path contains invalid UTF-8 characters".to_owned()));
+}
+
+#[test]
+fn test_enum_skipped() {
+    assert_ser_tokens_error(
+        &Enum::SkippedUnit,
+        &[],
+        Error::Message("the enum variant Enum::SkippedUnit cannot be serialized".to_owned()));
+    assert_ser_tokens_error(
+        &Enum::SkippedOne(42),
+        &[],
+        Error::Message("the enum variant Enum::SkippedOne cannot be serialized".to_owned()));
+    assert_ser_tokens_error(
+        &Enum::SkippedSeq(1, 2),
+        &[],
+        Error::Message("the enum variant Enum::SkippedSeq cannot be serialized".to_owned()));
+    assert_ser_tokens_error(
+        &Enum::SkippedMap { _a: 1, _b: 2 },
+        &[],
+        Error::Message("the enum variant Enum::SkippedMap cannot be serialized".to_owned()));
+}