Skip to content

Commit bcaebdb

Browse files
dtolnaydtolnay
authored
Merge pull request #1662 from eupn/use-macrotest
Implement expansion tests
2 parents 43a9f59 + 9a0e4e0 commit bcaebdb

25 files changed

+4952
-0
lines changed

‎test_suite/Cargo.toml

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,7 @@ version = "0.0.0"
44
authors = ["Erick Tryzelaar <[email protected]>", "David Tolnay <[email protected]>"]
55
edition = "2018"
66
publish = false
7+
build = "build.rs"
78

89
[features]
910
unstable = ["serde/unstable"]
@@ -18,3 +19,4 @@ serde = { path = "../serde", features = ["rc", "derive"] }
1819
serde_derive = { path = "../serde_derive", features = ["deserialize_in_place"] }
1920
serde_test = { path = "../serde_test" }
2021
trybuild = "1.0"
22+
macrotest = "0.1"

‎test_suite/build.rs

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
use std::env;
2+
use std::path::PathBuf;
3+
4+
#[cfg(not(windows))]
5+
const CARGO_EXPAND_BIN: &str = "cargo-expand";
6+
7+
#[cfg(windows)]
8+
const CARGO_EXPAND_BIN: &str = "cargo-expand.exe";
9+
10+
/// Scans paths in PATH env variable for a presence of `CARGO_EXPAND_BIN` file.
11+
fn is_cargo_expand_present() -> bool {
12+
if let Ok(var) = env::var("PATH") {
13+
for path in var.split(":").map(PathBuf::from) {
14+
let cargo_expand_path = path.join(CARGO_EXPAND_BIN);
15+
if cargo_expand_path.exists() {
16+
return true;
17+
}
18+
}
19+
}
20+
21+
false
22+
}
23+
24+
pub fn main() {
25+
if is_cargo_expand_present() {
26+
println!("cargo:rustc-cfg=cargo_expand");
27+
}
28+
}

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

Lines changed: 1166 additions & 0 deletions
Large diffs are not rendered by default.

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

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
use serde::Deserialize;
2+
3+
#[derive(Serialize, Deserialize)]
4+
enum DeEnum<B, C, D> {
5+
Unit,
6+
Seq(i8, B, C, D),
7+
Map { a: i8, b: B, c: C, d: D },
8+
9+
// Make sure we can support more than one variant.
10+
_Unit2,
11+
_Seq2(i8, B, C, D),
12+
_Map2 { a: i8, b: B, c: C, d: D },
13+
}

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

Lines changed: 582 additions & 0 deletions
Large diffs are not rendered by default.

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

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,9 @@
1+
use serde::{Serialize, Deserialize};
2+
3+
#[derive(Serialize, Deserialize)]
4+
pub enum GenericEnum<T, U> {
5+
Unit,
6+
NewType(T),
7+
Seq(T, U),
8+
Map { x: T, y: U },
9+
}

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

Lines changed: 601 additions & 0 deletions
Large diffs are not rendered by default.

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

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,9 @@
1+
use serde::{Serialize, Deserialize};
2+
3+
#[derive(Serialize, Deserialize)]
4+
enum Lifetimes<'a> {
5+
LifetimeSeq(&'a i32),
6+
NoLifetimeSeq(i32),
7+
LifetimeMap { a: &'a i32 },
8+
NoLifetimeMap { a: i32 },
9+
}

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

Lines changed: 268 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,268 @@
1+
use serde::Serialize;
2+
enum SerEnum<'a, B: 'a, C: 'a, D>
3+
where
4+
D: 'a,
5+
{
6+
Unit,
7+
Seq(i8, B, &'a C, &'a mut D),
8+
Map { a: i8, b: B, c: &'a C, d: &'a mut D },
9+
_Unit2,
10+
_Seq2(i8, B, &'a C, &'a mut D),
11+
_Map2 { a: i8, b: B, c: &'a C, d: &'a mut D },
12+
}
13+
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
14+
const _IMPL_SERIALIZE_FOR_SerEnum: () = {
15+
#[allow(unknown_lints)]
16+
#[allow(rust_2018_idioms)]
17+
extern crate serde as _serde;
18+
#[automatically_derived]
19+
impl<'a, B: 'a, C: 'a, D> _serde::Serialize for SerEnum<'a, B, C, D>
20+
where
21+
D: 'a,
22+
B: _serde::Serialize,
23+
C: _serde::Serialize,
24+
D: _serde::Serialize,
25+
{
26+
fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
27+
where
28+
__S: _serde::Serializer,
29+
{
30+
match *self {
31+
SerEnum::Unit => _serde::Serializer::serialize_unit_variant(
32+
__serializer,
33+
"SerEnum",
34+
0u32,
35+
"Unit",
36+
),
37+
SerEnum::Seq(ref __field0, ref __field1, ref __field2, ref __field3) => {
38+
let mut __serde_state = match _serde::Serializer::serialize_tuple_variant(
39+
__serializer,
40+
"SerEnum",
41+
1u32,
42+
"Seq",
43+
0 + 1 + 1 + 1 + 1,
44+
) {
45+
_serde::export::Ok(__val) => __val,
46+
_serde::export::Err(__err) => {
47+
return _serde::export::Err(__err);
48+
}
49+
};
50+
match _serde::ser::SerializeTupleVariant::serialize_field(
51+
&mut __serde_state,
52+
__field0,
53+
) {
54+
_serde::export::Ok(__val) => __val,
55+
_serde::export::Err(__err) => {
56+
return _serde::export::Err(__err);
57+
}
58+
};
59+
match _serde::ser::SerializeTupleVariant::serialize_field(
60+
&mut __serde_state,
61+
__field1,
62+
) {
63+
_serde::export::Ok(__val) => __val,
64+
_serde::export::Err(__err) => {
65+
return _serde::export::Err(__err);
66+
}
67+
};
68+
match _serde::ser::SerializeTupleVariant::serialize_field(
69+
&mut __serde_state,
70+
__field2,
71+
) {
72+
_serde::export::Ok(__val) => __val,
73+
_serde::export::Err(__err) => {
74+
return _serde::export::Err(__err);
75+
}
76+
};
77+
match _serde::ser::SerializeTupleVariant::serialize_field(
78+
&mut __serde_state,
79+
__field3,
80+
) {
81+
_serde::export::Ok(__val) => __val,
82+
_serde::export::Err(__err) => {
83+
return _serde::export::Err(__err);
84+
}
85+
};
86+
_serde::ser::SerializeTupleVariant::end(__serde_state)
87+
}
88+
SerEnum::Map {
89+
ref a,
90+
ref b,
91+
ref c,
92+
ref d,
93+
} => {
94+
let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
95+
__serializer,
96+
"SerEnum",
97+
2u32,
98+
"Map",
99+
0 + 1 + 1 + 1 + 1,
100+
) {
101+
_serde::export::Ok(__val) => __val,
102+
_serde::export::Err(__err) => {
103+
return _serde::export::Err(__err);
104+
}
105+
};
106+
match _serde::ser::SerializeStructVariant::serialize_field(
107+
&mut __serde_state,
108+
"a",
109+
a,
110+
) {
111+
_serde::export::Ok(__val) => __val,
112+
_serde::export::Err(__err) => {
113+
return _serde::export::Err(__err);
114+
}
115+
};
116+
match _serde::ser::SerializeStructVariant::serialize_field(
117+
&mut __serde_state,
118+
"b",
119+
b,
120+
) {
121+
_serde::export::Ok(__val) => __val,
122+
_serde::export::Err(__err) => {
123+
return _serde::export::Err(__err);
124+
}
125+
};
126+
match _serde::ser::SerializeStructVariant::serialize_field(
127+
&mut __serde_state,
128+
"c",
129+
c,
130+
) {
131+
_serde::export::Ok(__val) => __val,
132+
_serde::export::Err(__err) => {
133+
return _serde::export::Err(__err);
134+
}
135+
};
136+
match _serde::ser::SerializeStructVariant::serialize_field(
137+
&mut __serde_state,
138+
"d",
139+
d,
140+
) {
141+
_serde::export::Ok(__val) => __val,
142+
_serde::export::Err(__err) => {
143+
return _serde::export::Err(__err);
144+
}
145+
};
146+
_serde::ser::SerializeStructVariant::end(__serde_state)
147+
}
148+
SerEnum::_Unit2 => _serde::Serializer::serialize_unit_variant(
149+
__serializer,
150+
"SerEnum",
151+
3u32,
152+
"_Unit2",
153+
),
154+
SerEnum::_Seq2(ref __field0, ref __field1, ref __field2, ref __field3) => {
155+
let mut __serde_state = match _serde::Serializer::serialize_tuple_variant(
156+
__serializer,
157+
"SerEnum",
158+
4u32,
159+
"_Seq2",
160+
0 + 1 + 1 + 1 + 1,
161+
) {
162+
_serde::export::Ok(__val) => __val,
163+
_serde::export::Err(__err) => {
164+
return _serde::export::Err(__err);
165+
}
166+
};
167+
match _serde::ser::SerializeTupleVariant::serialize_field(
168+
&mut __serde_state,
169+
__field0,
170+
) {
171+
_serde::export::Ok(__val) => __val,
172+
_serde::export::Err(__err) => {
173+
return _serde::export::Err(__err);
174+
}
175+
};
176+
match _serde::ser::SerializeTupleVariant::serialize_field(
177+
&mut __serde_state,
178+
__field1,
179+
) {
180+
_serde::export::Ok(__val) => __val,
181+
_serde::export::Err(__err) => {
182+
return _serde::export::Err(__err);
183+
}
184+
};
185+
match _serde::ser::SerializeTupleVariant::serialize_field(
186+
&mut __serde_state,
187+
__field2,
188+
) {
189+
_serde::export::Ok(__val) => __val,
190+
_serde::export::Err(__err) => {
191+
return _serde::export::Err(__err);
192+
}
193+
};
194+
match _serde::ser::SerializeTupleVariant::serialize_field(
195+
&mut __serde_state,
196+
__field3,
197+
) {
198+
_serde::export::Ok(__val) => __val,
199+
_serde::export::Err(__err) => {
200+
return _serde::export::Err(__err);
201+
}
202+
};
203+
_serde::ser::SerializeTupleVariant::end(__serde_state)
204+
}
205+
SerEnum::_Map2 {
206+
ref a,
207+
ref b,
208+
ref c,
209+
ref d,
210+
} => {
211+
let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
212+
__serializer,
213+
"SerEnum",
214+
5u32,
215+
"_Map2",
216+
0 + 1 + 1 + 1 + 1,
217+
) {
218+
_serde::export::Ok(__val) => __val,
219+
_serde::export::Err(__err) => {
220+
return _serde::export::Err(__err);
221+
}
222+
};
223+
match _serde::ser::SerializeStructVariant::serialize_field(
224+
&mut __serde_state,
225+
"a",
226+
a,
227+
) {
228+
_serde::export::Ok(__val) => __val,
229+
_serde::export::Err(__err) => {
230+
return _serde::export::Err(__err);
231+
}
232+
};
233+
match _serde::ser::SerializeStructVariant::serialize_field(
234+
&mut __serde_state,
235+
"b",
236+
b,
237+
) {
238+
_serde::export::Ok(__val) => __val,
239+
_serde::export::Err(__err) => {
240+
return _serde::export::Err(__err);
241+
}
242+
};
243+
match _serde::ser::SerializeStructVariant::serialize_field(
244+
&mut __serde_state,
245+
"c",
246+
c,
247+
) {
248+
_serde::export::Ok(__val) => __val,
249+
_serde::export::Err(__err) => {
250+
return _serde::export::Err(__err);
251+
}
252+
};
253+
match _serde::ser::SerializeStructVariant::serialize_field(
254+
&mut __serde_state,
255+
"d",
256+
d,
257+
) {
258+
_serde::export::Ok(__val) => __val,
259+
_serde::export::Err(__err) => {
260+
return _serde::export::Err(__err);
261+
}
262+
};
263+
_serde::ser::SerializeStructVariant::end(__serde_state)
264+
}
265+
}
266+
}
267+
}
268+
};

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

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
use serde::Serialize;
2+
3+
#[derive(Serialize)]
4+
enum SerEnum<'a, B: 'a, C: 'a, D>
5+
where
6+
D: 'a,
7+
{
8+
Unit,
9+
Seq(i8, B, &'a C, &'a mut D),
10+
Map { a: i8, b: B, c: &'a C, d: &'a mut D },
11+
12+
// Make sure we can support more than one variant.
13+
_Unit2,
14+
_Seq2(i8, B, &'a C, &'a mut D),
15+
_Map2 { a: i8, b: B, c: &'a C, d: &'a mut D },
16+
}

0 commit comments

Comments
 (0)