Implement derive macros expansion tests using macrotest

test_suite/tests/expand/derive/enum/de_enum.rs

@@ -0,0 +1,13 @@
+use serde::Deserialize;
+
+#[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 },
+}

test_suite/tests/expand/derive/enum/generic_enum.rs

@@ -0,0 +1,9 @@
+use serde::{Serialize, Deserialize};
+
+#[derive(Serialize, Deserialize)]
+pub enum GenericEnum<T, U> {
+    Unit,
+    NewType(T),
+    Seq(T, U),
+    Map { x: T, y: U },
+}

test_suite/tests/expand/derive/enum/lifetimes.rs

@@ -0,0 +1,9 @@
+use serde::{Serialize, Deserialize};
+
+#[derive(Serialize, Deserialize)]
+enum Lifetimes<'a> {
+    LifetimeSeq(&'a i32),
+    NoLifetimeSeq(i32),
+    LifetimeMap { a: &'a i32 },
+    NoLifetimeMap { a: i32 },
+}

test_suite/tests/expand/derive/enum/ser_enum.rs

@@ -0,0 +1,16 @@
+use serde::Serialize;
+
+#[derive(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 },
+}

test_suite/tests/expand/derive/enum/void.rs

@@ -0,0 +1,4 @@
+use serde::{Serialize, Deserialize};
+
+#[derive(Serialize, Deserialize)]
+enum Void {}

test_suite/tests/expand/derive/struct/default_ty_param.rs

@@ -0,0 +1,14 @@
+use serde::{Serialize, Deserialize};
+
+trait AssociatedType {
+    type X;
+}
+
+impl AssociatedType for i32 {
+    type X = i32;
+}
+
+#[derive(Serialize, Deserialize)]
+struct DefaultTyParam<T: AssociatedType<X = i32> = i32> {
+    phantom: PhantomData<T>,
+}

test_suite/tests/expand/derive/struct/generic_struct.rs

@@ -0,0 +1,9 @@
+use serde::{Serialize, Deserialize};
+
+#[derive(Serialize, Deserialize)]
+pub struct GenericStruct<T> {
+    x: T,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct GenericNewTypeStruct<T>(T);

test_suite/tests/expand/derive/struct/generic_tuple_struct.rs

@@ -0,0 +1,4 @@
+use serde::{Serialize, Deserialize};
+
+#[derive(Deserialize)]
+pub struct GenericTupleStruct<T, U>(T, U);

test_suite/tests/expand/derive/struct/named_map.rs

@@ -0,0 +1,15 @@
+use serde::{Serialize, Deserialize};
+
+#[derive(Serialize)]
+struct SerNamedMap<'a, 'b, A: 'a, B: 'b, C> {
+    a: &'a A,
+    b: &'b mut B,
+    c: C,
+}
+
+#[derive(Deserialize)]
+struct DeNamedMap<A, B, C> {
+    a: A,
+    b: B,
+    c: C,
+}

test_suite/tests/expand/derive/struct/named_tuple.rs

@@ -0,0 +1,7 @@
+use serde::{Serialize, Deserialize};
+
+#[derive(Serialize)]
+struct SerNamedTuple<'a, 'b, A: 'a, B: 'b, C>(&'a A, &'b mut B, C);
+
+#[derive(Deserialize)]
+struct DeNamedTuple<A, B, C>(A, B, C);

test_suite/tests/expand/derive/struct/named_unit.rs

@@ -0,0 +1,4 @@
+use serde::{Serialize, Deserialize};
+
+#[derive(Serialize, Deserialize)]
+struct NamedUnit;

test_suite/tests/expandtest.rs

@@ -0,0 +1,7 @@
+#[cfg(not(target_os = "emscripten"))]
+#[rustversion::attr(not(nightly), ignore)]
+#[test]
+fn expandtest() {
+    macrotest::expand("tests/expand/**/enum/*.rs");
+    macrotest::expand("tests/expand/**/struct/*.rs");
+}