Debian Codegraph @

Utilities/cmcppdap/src/json_serializer_test.cpp

raw
1 // Copyright 2019 Google LLC
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include "json_serializer.h"
16
17 #include "dap/typeinfo.h"
18 #include "dap/typeof.h"
19
20 #include "gmock/gmock.h"
21 #include "gtest/gtest.h"
22
23 namespace dap {
24
25 struct JSONInnerTestObject {
26 integer i;
27 };
28
29 DAP_STRUCT_TYPEINFO(JSONInnerTestObject,
30 "json-inner-test-object",
31 DAP_FIELD(i, "i"));
32
33 struct JSONTestObject {
34 boolean b;
35 integer i;
36 number n;
37 array<integer> a;
38 object o;
39 string s;
40 optional<integer> o1;
41 optional<integer> o2;
42 JSONInnerTestObject inner;
43 };
44
45 DAP_STRUCT_TYPEINFO(JSONTestObject,
46 "json-test-object",
47 DAP_FIELD(b, "b"),
48 DAP_FIELD(i, "i"),
49 DAP_FIELD(n, "n"),
50 DAP_FIELD(a, "a"),
51 DAP_FIELD(o, "o"),
52 DAP_FIELD(s, "s"),
53 DAP_FIELD(o1, "o1"),
54 DAP_FIELD(o2, "o2"),
55 DAP_FIELD(inner, "inner"));
56
57 struct JSONObjectNoFields {};
58
59 DAP_STRUCT_TYPEINFO(JSONObjectNoFields, "json-object-no-fields");
60
61 struct SimpleJSONTestObject {
62 boolean b;
63 integer i;
64 };
65 DAP_STRUCT_TYPEINFO(SimpleJSONTestObject,
66 "simple-json-test-object",
67 DAP_FIELD(b, "b"),
68 DAP_FIELD(i, "i"));
69
70 } // namespace dap
71
72 class JSONSerializer : public testing::Test {
73 protected:
74 static dap::object GetSimpleObject() {
75 return dap::object({{"one", dap::integer(1)},
76 {"two", dap::number(2)},
77 {"three", dap::string("three")},
78 {"four", dap::boolean(true)}});
79 }
80 void TEST_SIMPLE_OBJECT(const dap::object& obj) {
81 NESTED_TEST_FAILED = true;
82 auto ref_obj = GetSimpleObject();
83 ASSERT_EQ(obj.size(), ref_obj.size());
84 ASSERT_TRUE(obj.at("one").is<dap::integer>());
85 ASSERT_TRUE(obj.at("two").is<dap::number>());
86 ASSERT_TRUE(obj.at("three").is<dap::string>());
87 ASSERT_TRUE(obj.at("four").is<dap::boolean>());
88
89 ASSERT_EQ(ref_obj.at("one").get<dap::integer>(),
90 obj.at("one").get<dap::integer>());
91 ASSERT_EQ(ref_obj.at("two").get<dap::number>(),
92 obj.at("two").get<dap::number>());
93 ASSERT_EQ(ref_obj.at("three").get<dap::string>(),
94 obj.at("three").get<dap::string>());
95 ASSERT_EQ(ref_obj.at("four").get<dap::boolean>(),
96 obj.at("four").get<dap::boolean>());
97 NESTED_TEST_FAILED = false;
98 }
99 template <typename T>
100 void TEST_SERIALIZING_DESERIALIZING(const T& encoded, T& decoded) {
101 NESTED_TEST_FAILED = true;
102 dap::json::Serializer s;
103 ASSERT_TRUE(s.serialize(encoded));
104 dap::json::Deserializer d(s.dump());
105 ASSERT_TRUE(d.deserialize(&decoded));
106 NESTED_TEST_FAILED = false;
107 }
108 bool NESTED_TEST_FAILED = false;
109 #define _ASSERT_PASS(NESTED_TEST) \
110 NESTED_TEST; \
111 ASSERT_FALSE(NESTED_TEST_FAILED);
112 };
113
114 TEST_F(JSONSerializer, SerializeDeserialize) {
115 dap::JSONTestObject encoded;
116 encoded.b = true;
117 encoded.i = 32;
118 encoded.n = 123.456;
119 encoded.a = {2, 4, 6, 8, 0x100000000, -2, -4, -6, -8, -0x100000000};
120 encoded.o["one"] = dap::integer(1);
121 encoded.o["two"] = dap::number(2);
122 encoded.s = "hello world";
123 encoded.o2 = 42;
124 encoded.inner.i = 70;
125
126 dap::json::Serializer s;
127 ASSERT_TRUE(s.serialize(encoded));
128
129 dap::JSONTestObject decoded;
130 dap::json::Deserializer d(s.dump());
131 ASSERT_TRUE(d.deserialize(&decoded));
132
133 ASSERT_EQ(encoded.b, decoded.b);
134 ASSERT_EQ(encoded.i, decoded.i);
135 ASSERT_EQ(encoded.n, decoded.n);
136 ASSERT_EQ(encoded.a, decoded.a);
137 ASSERT_EQ(encoded.o["one"].get<dap::integer>(),
138 decoded.o["one"].get<dap::integer>());
139 ASSERT_EQ(encoded.o["two"].get<dap::number>(),
140 decoded.o["two"].get<dap::number>());
141 ASSERT_EQ(encoded.s, decoded.s);
142 ASSERT_EQ(encoded.o2, decoded.o2);
143 ASSERT_EQ(encoded.inner.i, decoded.inner.i);
144 }
145
146 TEST_F(JSONSerializer, SerializeObjectNoFields) {
147 dap::JSONObjectNoFields obj;
148 dap::json::Serializer s;
149 ASSERT_TRUE(s.serialize(obj));
150 ASSERT_EQ(s.dump(), "{}");
151 }
152
153 TEST_F(JSONSerializer, SerializeDeserializeObject) {
154 dap::object encoded = GetSimpleObject();
155 dap::object decoded;
156 _ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));
157 _ASSERT_PASS(TEST_SIMPLE_OBJECT(decoded));
158 }
159
160 TEST_F(JSONSerializer, SerializeDeserializeEmbeddedObject) {
161 dap::object encoded;
162 dap::object decoded;
163 // object nested inside object
164 dap::object encoded_embed_obj = GetSimpleObject();
165 dap::object decoded_embed_obj;
166 encoded["embed_obj"] = encoded_embed_obj;
167 _ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));
168 ASSERT_TRUE(decoded["embed_obj"].is<dap::object>());
169 decoded_embed_obj = decoded["embed_obj"].get<dap::object>();
170 _ASSERT_PASS(TEST_SIMPLE_OBJECT(decoded_embed_obj));
171 }
172
173 TEST_F(JSONSerializer, SerializeDeserializeEmbeddedStruct) {
174 dap::object encoded;
175 dap::object decoded;
176 // object nested inside object
177 dap::SimpleJSONTestObject encoded_embed_struct;
178 encoded_embed_struct.b = true;
179 encoded_embed_struct.i = 50;
180 encoded["embed_struct"] = encoded_embed_struct;
181
182 dap::object decoded_embed_obj;
183 _ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));
184 ASSERT_TRUE(decoded["embed_struct"].is<dap::object>());
185 decoded_embed_obj = decoded["embed_struct"].get<dap::object>();
186 ASSERT_TRUE(decoded_embed_obj.at("b").is<dap::boolean>());
187 ASSERT_TRUE(decoded_embed_obj.at("i").is<dap::integer>());
188
189 ASSERT_EQ(encoded_embed_struct.b, decoded_embed_obj["b"].get<dap::boolean>());
190 ASSERT_EQ(encoded_embed_struct.i, decoded_embed_obj["i"].get<dap::integer>());
191 }
192
193 TEST_F(JSONSerializer, SerializeDeserializeEmbeddedIntArray) {
194 dap::object encoded;
195 dap::object decoded;
196 // array nested inside object
197 dap::array<dap::integer> encoded_embed_arr = {1, 2, 3, 4};
198 dap::array<dap::any> decoded_embed_arr;
199
200 encoded["embed_arr"] = encoded_embed_arr;
201
202 _ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));
203 // TODO: Deserializing array should infer basic member types
204 ASSERT_TRUE(decoded["embed_arr"].is<dap::array<dap::any>>());
205 decoded_embed_arr = decoded["embed_arr"].get<dap::array<dap::any>>();
206 ASSERT_EQ(encoded_embed_arr.size(), decoded_embed_arr.size());
207 for (std::size_t i = 0; i < decoded_embed_arr.size(); i++) {
208 ASSERT_TRUE(decoded_embed_arr[i].is<dap::integer>());
209 ASSERT_EQ(encoded_embed_arr[i], decoded_embed_arr[i].get<dap::integer>());
210 }
211 }
212
213 TEST_F(JSONSerializer, SerializeDeserializeEmbeddedObjectArray) {
214 dap::object encoded;
215 dap::object decoded;
216
217 dap::array<dap::object> encoded_embed_arr = {GetSimpleObject(),
218 GetSimpleObject()};
219 dap::array<dap::any> decoded_embed_arr;
220
221 encoded["embed_arr"] = encoded_embed_arr;
222
223 _ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));
224 // TODO: Deserializing array should infer basic member types
225 ASSERT_TRUE(decoded["embed_arr"].is<dap::array<dap::any>>());
226 decoded_embed_arr = decoded["embed_arr"].get<dap::array<dap::any>>();
227 ASSERT_EQ(encoded_embed_arr.size(), decoded_embed_arr.size());
228 for (std::size_t i = 0; i < decoded_embed_arr.size(); i++) {
229 ASSERT_TRUE(decoded_embed_arr[i].is<dap::object>());
230 _ASSERT_PASS(TEST_SIMPLE_OBJECT(decoded_embed_arr[i].get<dap::object>()));
231 }
232 }
233
234 TEST_F(JSONSerializer, DeserializeSerializeEmptyObject) {
235 auto empty_obj = "{}";
236 dap::object decoded;
237 dap::json::Deserializer d(empty_obj);
238 ASSERT_TRUE(d.deserialize(&decoded));
239 dap::json::Serializer s;
240 ASSERT_TRUE(s.serialize(decoded));
241 ASSERT_EQ(s.dump(), empty_obj);
242 }
243
244 TEST_F(JSONSerializer, SerializeDeserializeEmbeddedEmptyObject) {
245 dap::object encoded_empty_obj;
246 dap::object encoded = {{"empty_obj", encoded_empty_obj}};
247 dap::object decoded;
248
249 _ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));
250 ASSERT_TRUE(decoded["empty_obj"].is<dap::object>());
251 dap::object decoded_empty_obj = decoded["empty_obj"].get<dap::object>();
252 ASSERT_EQ(encoded_empty_obj.size(), decoded_empty_obj.size());
253 }
254
255 TEST_F(JSONSerializer, SerializeDeserializeObjectWithNulledField) {
256 auto thing = dap::any(dap::null());
257 dap::object encoded;
258 encoded["nulled_field"] = dap::null();
259 dap::json::Serializer s;
260 ASSERT_TRUE(s.serialize(encoded));
261 dap::object decoded;
262 auto dump = s.dump();
263 dap::json::Deserializer d(dump);
264 ASSERT_TRUE(d.deserialize(&decoded));
265 ASSERT_TRUE(encoded["nulled_field"].is<dap::null>());
266 }