1 use toml::map::Map;
2 use toml::Value::{Array, Boolean, Float, Integer, String, Table};
3 
4 macro_rules! map( ($($k:expr => $v:expr),*) => ({
5     let mut _m = Map::new();
6     $(_m.insert($k.to_string(), $v);)*
7     _m
8 }) );
9 
10 #[test]
simple_show()11 fn simple_show() {
12     assert_eq!(String("foo".to_string()).to_string(), "\"foo\"");
13     assert_eq!(Integer(10).to_string(), "10");
14     assert_eq!(Float(10.0).to_string(), "10.0");
15     assert_eq!(Float(2.4).to_string(), "2.4");
16     assert_eq!(Boolean(true).to_string(), "true");
17     assert_eq!(Array(vec![]).to_string(), "[]");
18     assert_eq!(Array(vec![Integer(1), Integer(2)]).to_string(), "[1, 2]");
19 }
20 
21 #[test]
table()22 fn table() {
23     assert_eq!(map! {}.to_string(), "");
24     assert_eq!(
25         map! {
26         "test" => Integer(2),
27         "test2" => Integer(3) }
28         .to_string(),
29         "test = 2\ntest2 = 3\n"
30     );
31     assert_eq!(
32         map! {
33              "test" => Integer(2),
34              "test2" => Table(map! {
35                  "test" => String("wut".to_string())
36              })
37         }
38         .to_string(),
39         "test = 2\n\
40          \n\
41          [test2]\n\
42          test = \"wut\"\n"
43     );
44     assert_eq!(
45         map! {
46              "test" => Integer(2),
47              "test2" => Table(map! {
48                  "test" => String("wut".to_string())
49              })
50         }
51         .to_string(),
52         "test = 2\n\
53          \n\
54          [test2]\n\
55          test = \"wut\"\n"
56     );
57     assert_eq!(
58         map! {
59              "test" => Integer(2),
60              "test2" => Array(vec![Table(map! {
61                  "test" => String("wut".to_string())
62              })])
63         }
64         .to_string(),
65         "test = 2\n\
66          \n\
67          [[test2]]\n\
68          test = \"wut\"\n"
69     );
70     #[cfg(feature = "preserve_order")]
71     assert_eq!(
72         map! {
73              "foo.bar" => Integer(2),
74              "foo\"bar" => Integer(2)
75         }
76         .to_string(),
77         "\"foo.bar\" = 2\n\
78          \"foo\\\"bar\" = 2\n"
79     );
80     assert_eq!(
81         map! {
82              "test" => Integer(2),
83              "test2" => Array(vec![Table(map! {
84                  "test" => Array(vec![Integer(2)])
85              })])
86         }
87         .to_string(),
88         "test = 2\n\
89          \n\
90          [[test2]]\n\
91          test = [2]\n"
92     );
93     let table = map! {
94         "test" => Integer(2),
95         "test2" => Array(vec![Table(map! {
96             "test" => Array(vec![Array(vec![Integer(2), Integer(3)]),
97             Array(vec![String("foo".to_string()), String("bar".to_string())])])
98         })])
99     };
100     assert_eq!(
101         table.to_string(),
102         "test = 2\n\
103          \n\
104          [[test2]]\n\
105          test = [[2, 3], [\"foo\", \"bar\"]]\n"
106     );
107     assert_eq!(
108         map! {
109              "test" => Array(vec![Integer(2)]),
110              "test2" => Integer(2)
111         }
112         .to_string(),
113         "test = [2]\n\
114          test2 = 2\n"
115     );
116 }
117