Merge pull request #458 from serde-rs/testgen

Add tests for concrete instantiations in test_gen

testing/tests/test_gen.rs

@@ -10,152 +10,174 @@ use std::marker::PhantomData;
 
 //////////////////////////////////////////////////////////////////////////
 
-#[derive(Serialize, Deserialize)]
+#[test]
-struct With<T> {
+fn test_gen() {
-    t: T,
+    #[derive(Serialize, Deserialize)]
-    #[serde(serialize_with="ser_x", deserialize_with="de_x")]
+    struct With<T> {
-    x: X,
-}
-
-#[derive(Serialize, Deserialize)]
-struct WithRef<'a, T: 'a> {
-    #[serde(skip_deserializing)]
-    t: Option<&'a T>,
-    #[serde(serialize_with="ser_x", deserialize_with="de_x")]
-    x: X,
-}
-
-#[derive(Serialize, Deserialize)]
-struct PhantomX {
-    x: PhantomData<X>,
-}
-
-#[derive(Serialize, Deserialize)]
-struct Bounds<T: Serialize + Deserialize> {
-    t: T,
-    option: Option<T>,
-    boxed: Box<T>,
-    option_boxed: Option<Box<T>>,
-}
-
-#[derive(Serialize, Deserialize)]
-struct NoBounds<T> {
-    t: T,
-    option: Option<T>,
-    boxed: Box<T>,
-    option_boxed: Option<Box<T>>,
-}
-
-#[derive(Serialize, Deserialize)]
-enum EnumWith<T> {
-    Unit,
-    Newtype(
-        #[serde(serialize_with="ser_x", deserialize_with="de_x")]
-        X),
-    Tuple(
-        T,
-        #[serde(serialize_with="ser_x", deserialize_with="de_x")]
-        X),
-    Struct {
         t: T,
         #[serde(serialize_with="ser_x", deserialize_with="de_x")]
-        x: X },
+        x: X,
-}
+    }
+    assert::<With<i32>>();
 
-#[derive(Serialize)]
+    #[derive(Serialize, Deserialize)]
-#[allow(dead_code)]
+    struct WithRef<'a, T: 'a> {
-struct MultipleRef<'a, 'b, 'c, T> where T: 'c, 'c: 'b, 'b: 'a {
+        #[serde(skip_deserializing)]
-    t: T,
+        t: Option<&'a T>,
-    rrrt: &'a &'b &'c T,
+        #[serde(serialize_with="ser_x", deserialize_with="de_x")]
-}
+        x: X,
+    }
+    assert::<WithRef<i32>>();
 
-#[derive(Serialize, Deserialize)]
+    #[derive(Serialize, Deserialize)]
-struct Newtype(
+    struct PhantomX {
-    #[serde(serialize_with="ser_x", deserialize_with="de_x")]
+        x: PhantomData<X>,
-    X
+    }
-);
+    assert::<PhantomX>();
 
-#[derive(Serialize, Deserialize)]
+    #[derive(Serialize, Deserialize)]
-struct Tuple<T>(
+    struct Bounds<T: Serialize + Deserialize> {
-    T,
+        t: T,
-    #[serde(serialize_with="ser_x", deserialize_with="de_x")]
+        option: Option<T>,
-    X,
+        boxed: Box<T>,
-);
+        option_boxed: Option<Box<T>>,
+    }
+    assert::<Bounds<i32>>();
 
-#[derive(Serialize, Deserialize)]
+    #[derive(Serialize, Deserialize)]
-enum TreeNode<D> {
+    struct NoBounds<T> {
-    Split {
+        t: T,
-        left: Box<TreeNode<D>>,
+        option: Option<T>,
-        right: Box<TreeNode<D>>,
+        boxed: Box<T>,
-    },
+        option_boxed: Option<Box<T>>,
-    Leaf {
+    }
+    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)]
+    #[derive(Serialize, Deserialize)]
-struct ListNode<D> {
+    struct RecursiveA {
-    data: D,
+        b: Box<RecursiveB>,
-    next: Box<ListNode<D>>,
+    }
-}
+    assert::<RecursiveA>();
 
-#[derive(Serialize, Deserialize)]
+    #[derive(Serialize, Deserialize)]
-struct RecursiveA {
+    enum RecursiveB {
-    b: Box<RecursiveB>,
+        A(RecursiveA),
-}
+    }
+    assert::<RecursiveB>();
 
-#[derive(Serialize, Deserialize)]
+    #[derive(Serialize, Deserialize)]
-enum RecursiveB {
+    struct RecursiveGenericA<T> {
-    A(RecursiveA),
+        t: T,
-}
+        b: Box<RecursiveGenericB<T>>,
+    }
+    assert::<RecursiveGenericA<i32>>();
 
-#[derive(Serialize, Deserialize)]
+    #[derive(Serialize, Deserialize)]
-struct RecursiveGenericA<T> {
+    enum RecursiveGenericB<T> {
-    t: T,
+        T(T),
-    b: Box<RecursiveGenericB<T>>,
+        A(RecursiveGenericA<T>),
-}
+    }
+    assert::<RecursiveGenericB<i32>>();
 
-#[derive(Serialize, Deserialize)]
+    #[derive(Serialize)]
-enum RecursiveGenericB<T> {
+    struct OptionStatic<'a> {
-    T(T),
+        a: Option<&'a str>,
-    A(RecursiveGenericA<T>),
+        b: Option<&'static str>,
-}
+    }
+    assert_ser::<OptionStatic>();
 
-#[derive(Serialize)]
+    #[derive(Serialize, Deserialize)]
-#[allow(dead_code)]
+    #[serde(bound="D: SerializeWith + DeserializeWith")]
-struct OptionStatic<'a> {
+    struct WithTraits1<D, E> {
-    a: Option<&'a str>,
+        #[serde(serialize_with="SerializeWith::serialize_with",
-    b: Option<&'static str>,
+                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)]
+    #[derive(Serialize, Deserialize)]
-#[serde(bound="D: SerializeWith + DeserializeWith")]
+    #[serde(bound(serialize="D: SerializeWith",
-struct WithTraits1<D, E> {
+                deserialize="D: DeserializeWith"))]
-    #[serde(serialize_with="SerializeWith::serialize_with",
+    struct WithTraits2<D, E> {
-            deserialize_with="DeserializeWith::deserialize_with")]
+        #[serde(serialize_with="SerializeWith::serialize_with",
-    d: D,
+                deserialize_with="DeserializeWith::deserialize_with")]
-    #[serde(serialize_with="SerializeWith::serialize_with",
+        d: D,
-            deserialize_with="DeserializeWith::deserialize_with",
+        #[serde(serialize_with="SerializeWith::serialize_with",
-            bound="E: SerializeWith + DeserializeWith")]
+                bound(serialize="E: SerializeWith"))]
-    e: E,
+        #[serde(deserialize_with="DeserializeWith::deserialize_with",
-}
+                bound(deserialize="E: DeserializeWith"))]
-
+        e: E,
-#[derive(Serialize, Deserialize)]
+    }
-#[serde(bound(serialize="D: SerializeWith",
+    assert::<WithTraits2<X, X>>();
-              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,
 }
 
 //////////////////////////////////////////////////////////////////////////
 
+fn assert<T: Serialize + Deserialize>() {}
+fn assert_ser<T: Serialize>() {}
+
 trait SerializeWith {
     fn serialize_with<S: Serializer>(_: &Self, _: &mut S) -> Result<(), S::Error>;
 }
@@ -166,5 +188,23 @@ trait DeserializeWith: Sized {
 
 // Implements neither Serialize nor Deserialize
 struct X;
-fn ser_x<S: Serializer>(_: &X, _: &mut S) -> Result<(), S::Error> { panic!() }
+
-fn de_x<D: Deserializer>(_: &mut D) -> Result<X, D::Error> { panic!() }
+fn ser_x<S: Serializer>(_: &X, _: &mut S) -> Result<(), S::Error> {
+    unimplemented!()
+}
+
+fn de_x<D: Deserializer>(_: &mut D) -> Result<X, D::Error> {
+    unimplemented!()
+}
+
+impl SerializeWith for X {
+    fn serialize_with<S: Serializer>(_: &Self, _: &mut S) -> Result<(), S::Error> {
+        unimplemented!()
+    }
+}
+
+impl DeserializeWith for X {
+    fn deserialize_with<D: Deserializer>(_: &mut D) -> Result<Self, D::Error> {
+        unimplemented!()
+    }
+}