Add tests for concrete instantiations in test_gen

testing/tests/test_gen.rs

@@ -10,12 +10,15 @@ use std::marker::PhantomData;
 
 //////////////////////////////////////////////////////////////////////////
 
+#[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> {
@@ -24,11 +27,13 @@ struct WithRef<'a, T: 'a> {
         #[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 Bounds<T: Serialize + Deserialize> {
@@ -37,6 +42,7 @@ struct Bounds<T: Serialize + Deserialize> {
         boxed: Box<T>,
         option_boxed: Option<Box<T>>,
     }
+    assert::<Bounds<i32>>();
 
     #[derive(Serialize, Deserialize)]
     struct NoBounds<T> {
@@ -45,6 +51,7 @@ struct NoBounds<T> {
         boxed: Box<T>,
         option_boxed: Option<Box<T>>,
     }
+    assert::<NoBounds<i32>>();
 
     #[derive(Serialize, Deserialize)]
     enum EnumWith<T> {
@@ -61,19 +68,21 @@ enum EnumWith<T> {
             #[serde(serialize_with="ser_x", deserialize_with="de_x")]
             x: X },
     }
+    assert::<EnumWith<i32>>();
 
     #[derive(Serialize)]
-#[allow(dead_code)]
     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>(
@@ -81,6 +90,7 @@ struct Tuple<T>(
         #[serde(serialize_with="ser_x", deserialize_with="de_x")]
         X,
     );
+    assert::<Tuple<i32>>();
 
     #[derive(Serialize, Deserialize)]
     enum TreeNode<D> {
@@ -92,41 +102,47 @@ enum TreeNode<D> {
             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)]
-#[allow(dead_code)]
     struct OptionStatic<'a> {
         a: Option<&'a str>,
         b: Option<&'static str>,
     }
+    assert_ser::<OptionStatic>();
 
     #[derive(Serialize, Deserialize)]
     #[serde(bound="D: SerializeWith + DeserializeWith")]
@@ -139,6 +155,7 @@ struct WithTraits1<D, E> {
                 bound="E: SerializeWith + DeserializeWith")]
         e: E,
     }
+    assert::<WithTraits1<X, X>>();
 
     #[derive(Serialize, Deserialize)]
     #[serde(bound(serialize="D: SerializeWith",
@@ -153,9 +170,14 @@ struct WithTraits2<D, E> {
                 bound(deserialize="E: DeserializeWith"))]
         e: E,
     }
+    assert::<WithTraits2<X, X>>();
+}
 
 //////////////////////////////////////////////////////////////////////////
 
+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!()
+    }
+}