1 use std::collections::HashMap;
2
3 use serde::Deserialize;
4 use serde::Serialize;
5
6 #[test]
always_works()7 fn always_works() {
8 // Ensure this works without the removed "toml::ser::tables_last"
9 #[derive(Serialize)]
10 struct A {
11 vals: HashMap<&'static str, Value>,
12 }
13
14 #[derive(Serialize)]
15 #[serde(untagged)]
16 enum Value {
17 Map(HashMap<&'static str, &'static str>),
18 Int(i32),
19 }
20
21 let mut a = A {
22 vals: HashMap::new(),
23 };
24 a.vals.insert("foo", Value::Int(0));
25
26 let mut sub = HashMap::new();
27 sub.insert("foo", "bar");
28 a.vals.insert("bar", Value::Map(sub));
29
30 toml::to_string(&a).unwrap();
31 }
32
33 #[test]
vec_of_vec_issue_387()34 fn vec_of_vec_issue_387() {
35 #[derive(Deserialize, Serialize, Debug)]
36 struct Glyph {
37 components: Vec<Component>,
38 contours: Vec<Contour>,
39 }
40
41 #[derive(Deserialize, Serialize, Debug)]
42 struct Point {
43 x: f64,
44 y: f64,
45 pt_type: String,
46 }
47
48 type Contour = Vec<Point>;
49
50 #[derive(Deserialize, Serialize, Debug)]
51 struct Component {
52 base: String,
53 transform: (f64, f64, f64, f64, f64, f64),
54 }
55
56 let comp1 = Component {
57 base: "b".to_owned(),
58 transform: (1.0, 0.0, 0.0, 1.0, 0.0, 0.0),
59 };
60 let comp2 = Component {
61 base: "c".to_owned(),
62 transform: (1.0, 0.0, 0.0, 1.0, 0.0, 0.0),
63 };
64 let components = vec![comp1, comp2];
65
66 let contours = vec![
67 vec![
68 Point {
69 x: 3.0,
70 y: 4.0,
71 pt_type: "line".to_owned(),
72 },
73 Point {
74 x: 5.0,
75 y: 6.0,
76 pt_type: "line".to_owned(),
77 },
78 ],
79 vec![
80 Point {
81 x: 0.0,
82 y: 0.0,
83 pt_type: "move".to_owned(),
84 },
85 Point {
86 x: 7.0,
87 y: 9.0,
88 pt_type: "offcurve".to_owned(),
89 },
90 Point {
91 x: 8.0,
92 y: 10.0,
93 pt_type: "offcurve".to_owned(),
94 },
95 Point {
96 x: 11.0,
97 y: 12.0,
98 pt_type: "curve".to_owned(),
99 },
100 ],
101 ];
102 let g1 = Glyph {
103 components,
104 contours,
105 };
106
107 let s = toml::to_string_pretty(&g1).unwrap();
108 let _g2: Glyph = toml::from_str(&s).unwrap();
109 }
110
111 #[test]
vec_order_issue_356()112 fn vec_order_issue_356() {
113 #[derive(Serialize, Deserialize)]
114 struct Outer {
115 v1: Vec<Inner>,
116 v2: Vec<Inner>,
117 }
118
119 #[derive(Serialize, Deserialize)]
120 struct Inner {}
121
122 let outer = Outer {
123 v1: vec![Inner {}],
124 v2: vec![],
125 };
126 let s = toml::to_string_pretty(&outer).unwrap();
127 let _o: Outer = toml::from_str(&s).unwrap();
128 }
129
130 #[test]
values_before_tables_issue_403()131 fn values_before_tables_issue_403() {
132 #[derive(Serialize, Deserialize)]
133 struct A {
134 a: String,
135 b: String,
136 }
137
138 #[derive(Serialize, Deserialize)]
139 struct B {
140 a: String,
141 b: Vec<String>,
142 }
143
144 #[derive(Serialize, Deserialize)]
145 struct C {
146 a: A,
147 b: Vec<String>,
148 c: Vec<B>,
149 }
150 toml::to_string(&C {
151 a: A {
152 a: "aa".to_owned(),
153 b: "ab".to_owned(),
154 },
155 b: vec!["b".to_owned()],
156 c: vec![B {
157 a: "cba".to_owned(),
158 b: vec!["cbb".to_owned()],
159 }],
160 })
161 .unwrap();
162 }
163