yamlserialized.unittests source code

1 module yamlserialized.unittests;
2 
3 unittest {
4     import std.conv : to;
5     import dunit.toolkit;
6     import yaml;
7 
8     import yamlserialized : deserializeInto, deserializeTo, toYAMLNode;
9 
10     struct TestSubStruct {
11         int anotherInt;
12         string anotherString;
13     }
14 
15     struct TestStruct {
16         struct NestedStruct {
17             int nestedInt;
18             string nestedString;
19         }
20 
21         int singleInt;
22         int[] intArray;
23         int[][] arrayOfIntArrays;
24         int[string] intStringAssocArray;
25         int[int] intIntAssocArray;
26         char singleChar;
27         char[] charArray;
28         string singleString;
29         string[] stringArray;
30         string[][] arrayOfStringArrays;
31         string[string] stringAssocArray;
32         string[string][string] stringAssocArrayOfAssocArrays;
33         bool trueBool;
34         bool falseBool;
35 
36         TestSubStruct subStruct;
37         NestedStruct nestedStruct;
38         NestedStruct[] arrayOfNestedStructs;
39         NestedStruct[string] nestedStructAssocArray;
40     }
41 
42     // Create test struct and set it up with some test values
43     TestStruct ts;
44     with (ts) {
45         singleInt = 1234;
46         intArray = [1, 2, 3, 4];
47         arrayOfIntArrays = [[1, 2], [3, 4]];
48         intStringAssocArray = ["one": 1, "two": 2, "three": 3];
49         intIntAssocArray = [1: 3, 2: 1, 3: 2];
50         singleChar = 'A';
51         charArray = ['A', 'B', 'C', 'D'];
52         singleString = "just a string";
53         stringArray = ["a", "few", "strings"];
54         arrayOfStringArrays = [["a", "b"], ["c", "d"]];
55         stringAssocArray = ["a": "A", "b": "B", "c": "C"];
56         stringAssocArrayOfAssocArrays = ["a": ["a": "A", "b": "B"], "b": ["c": "C", "d": "D"]];
57         trueBool = true;
58         falseBool = false;
59         subStruct.anotherInt = 42;
60         subStruct.anotherString = "Another string";
61         nestedStruct.nestedInt = 53;
62         nestedStruct.nestedString = "Nested string";
63         arrayOfNestedStructs = [NestedStruct(1, "One"), NestedStruct(2, "Two")];
64         nestedStructAssocArray = ["one": NestedStruct(1, "One"), "two": NestedStruct(2, "Two")];
65     }
66 
67     // Serialize the struct to YAML
68     auto node = ts.toYAMLNode();
69 
70     // Create a new empty struct
71     TestStruct ts2;
72 
73     // Deserialize the JSONValue into it
74     node.deserializeInto(ts2);
75 
76     // Assert that both structs are identical
77     assertEqual(ts2.singleInt, ts.singleInt);
78     assertEqual(ts2.intArray, ts.intArray);
79     assertEqual(ts2.arrayOfIntArrays, ts.arrayOfIntArrays);
80     assertEqual(ts2.intStringAssocArray, ts.intStringAssocArray);
81     assertEqual(ts2.intIntAssocArray, ts.intIntAssocArray);
82     assertEqual(ts2.singleChar, ts.singleChar);
83     assertEqual(ts2.charArray, ts.charArray);
84     assertEqual(ts2.singleString, ts.singleString);
85     assertEqual(ts2.stringArray, ts.stringArray);
86     assertEqual(ts2.arrayOfStringArrays, ts.arrayOfStringArrays);
87     assertEqual(ts2.stringAssocArray, ts.stringAssocArray);
88     assertEqual(ts2.stringAssocArrayOfAssocArrays, ts.stringAssocArrayOfAssocArrays);
89     assertEqual(ts2.trueBool, ts.trueBool);
90     assertEqual(ts2.falseBool, ts.falseBool);
91     assertEqual(ts2.subStruct, ts.subStruct);
92     assertEqual(ts2.subStruct.anotherInt, ts.subStruct.anotherInt);
93     assertEqual(ts2.subStruct.anotherString, ts.subStruct.anotherString);
94     assertEqual(ts2.nestedStruct, ts.nestedStruct);
95     assertEqual(ts2.nestedStruct.nestedInt, ts.nestedStruct.nestedInt);
96     assertEqual(ts2.nestedStruct.nestedString, ts.nestedStruct.nestedString);
97     assertEqual(ts2.arrayOfNestedStructs, ts.arrayOfNestedStructs);
98     assertEqual(ts2.arrayOfNestedStructs[0].nestedInt, ts.arrayOfNestedStructs[0].nestedInt);
99     assertEqual(ts2.arrayOfNestedStructs[0].nestedString, ts.arrayOfNestedStructs[0].nestedString);
100     assertEqual(ts2.arrayOfNestedStructs[1].nestedInt, ts.arrayOfNestedStructs[1].nestedInt);
101     assertEqual(ts2.arrayOfNestedStructs[1].nestedString, ts.arrayOfNestedStructs[1].nestedString);
102     assertEqual(ts2.nestedStructAssocArray, ts.nestedStructAssocArray);
103     assertEqual(ts2.nestedStructAssocArray["one"].nestedInt, ts.nestedStructAssocArray["one"].nestedInt);
104     assertEqual(ts2.nestedStructAssocArray["two"].nestedString, ts.nestedStructAssocArray["two"].nestedString);
105 
106     // Attempt to deserialize partial YAML
107     TestStruct ts3;
108     Loader.fromString(`{ singleInt: 42, singleString: "Don't panic." }`.to!(char[])).load().deserializeInto(ts3);
109 
110     ts3.singleInt.assertEqual(42);
111     ts3.singleString.assertEqual("Don't panic.");
112 
113     // Attempt to deserialize YAML containing a property that does not exist in the struct
114     TestStruct ts4;
115     Loader.fromString(`{ nonexistentString: "Move along, nothing to see here." }`.to!(char[])).load().deserializeInto(ts4);
116 
117     auto ts5 = Loader.fromString(`{ singleInt: 42, singleString: "Don't panic." }`.to!(char[])).load().deserializeTo!TestStruct;
118     ts5.singleInt.assertEqual(42);
119     ts5.singleString.assertEqual("Don't panic.");
120 }
121 
122 
123 unittest {
124     import dunit.toolkit;
125     import yaml;
126 
127     import yamlserialized : deserializeInto, toYAMLNode;
128 
129     class TestSubClass {
130         int anotherInt;
131     }
132 
133     class TestClass {
134         static class NestedClass {
135             int nestedInt;
136 
137             pure this() {
138             }
139 
140             this(in int initInt) {
141                 nestedInt = initInt;
142             }
143         }
144 
145         int singleInt;
146         int[] intArray;
147         int[][] arrayOfIntArrays;
148         int[string] intStringAssocArray;
149         int[int] intIntAssocArray;
150         char singleChar;
151         char[] charArray;
152         string singleString;
153         string[] stringArray;
154         string[][] arrayOfStringArrays;
155         string[string] stringAssocArray;
156         string[string][string] stringAssocArrayOfAssocArrays;
157         NestedClass[] arrayOfNestedClasses;
158         NestedClass[string] nestedClassAssocArray;
159 
160         auto subClass = new TestSubClass();
161         auto nestedClass = new NestedClass(53);
162     }
163 
164     // Create test struct and set it up with some test values
165     auto tc = new TestClass();
166     with (tc) {
167         singleInt = 1234;
168         intArray = [1, 2, 3, 4];
169         arrayOfIntArrays = [[1, 2], [3, 4]];
170         intStringAssocArray = ["one": 1, "two": 2, "three": 3];
171         intIntAssocArray = [1: 3, 2: 1, 3: 2];
172         singleChar = 'A';
173         charArray = ['A', 'B', 'C', 'D'];
174         singleString = "just a string";
175         stringArray = ["a", "few", "strings"];
176         arrayOfStringArrays = [["a", "b"], ["c", "d"]];
177         stringAssocArray = ["a": "A", "b": "B", "c": "C"];
178         stringAssocArrayOfAssocArrays = ["a": ["a": "A", "b": "B"], "b": ["c": "C", "d": "D"]];
179         arrayOfNestedClasses = [new NestedClass(1), new NestedClass(2)];
180         nestedClassAssocArray = ["one": new NestedClass(1), "two": new NestedClass(2)];
181         subClass.anotherInt = 42;
182     }
183 
184     // Serialize the struct to a Node
185     auto node = tc.toYAMLNode();
186 
187     // Create a new empty struct
188     auto tc2 = new TestClass();
189 
190     // Deserialize the node into it
191     node.deserializeInto(tc2);
192 
193     // Assert that both structs are identical
194     assertEqual(tc2.singleInt, tc.singleInt);
195     assertEqual(tc2.intArray, tc.intArray);
196     assertEqual(tc2.arrayOfIntArrays, tc.arrayOfIntArrays);
197     assertEqual(tc2.intStringAssocArray, tc.intStringAssocArray);
198     assertEqual(tc2.intIntAssocArray, tc.intIntAssocArray);
199     assertEqual(tc2.singleChar, tc.singleChar);
200     assertEqual(tc2.charArray, tc.charArray);
201     assertEqual(tc2.singleString, tc.singleString);
202     assertEqual(tc2.stringArray, tc.stringArray);
203     assertEqual(tc2.arrayOfStringArrays, tc.arrayOfStringArrays);
204     assertEqual(tc2.stringAssocArray, tc.stringAssocArray);
205     assertEqual(tc2.stringAssocArrayOfAssocArrays, tc.stringAssocArrayOfAssocArrays);
206     assertEqual(tc2.subClass.anotherInt, tc.subClass.anotherInt);
207     assertEqual(tc2.nestedClass.nestedInt, tc.nestedClass.nestedInt);
208     assertEqual(tc2.arrayOfNestedClasses[0].nestedInt, tc.arrayOfNestedClasses[0].nestedInt);
209     assertEqual(tc2.arrayOfNestedClasses[1].nestedInt, tc.arrayOfNestedClasses[1].nestedInt);
210     assertEqual(tc2.nestedClassAssocArray["one"].nestedInt, tc.nestedClassAssocArray["one"].nestedInt);
211     assertEqual(tc2.nestedClassAssocArray["two"].nestedInt, tc.nestedClassAssocArray["two"].nestedInt);
212 }
213 
214 unittest {
215     import std.conv : to;
216     import dunit.toolkit;
217     import yaml;
218 
219     import yamlserialized : deserializeInto;
220 
221     string[string] aa;
222     auto node = Loader.fromString(`{ aString: theString, anInt: 42 }`.to!(char[])).load();
223 
224     node.deserializeInto(aa);
225 
226     assertEqual(aa["aString"], "theString");
227     assertEqual(aa["anInt"], "42");
228 }