GCC Code Coverage Report | |||||||||||||||||||||
|
|||||||||||||||||||||
Line | Branch | Exec | Source |
1 |
#include "gtest/gtest.h" |
||
2 |
|||
3 |
#include <sstream> |
||
4 |
#include "zserio/JsonParser.h" |
||
5 |
|||
6 |
namespace zserio |
||
7 |
{ |
||
8 |
|||
9 |
namespace |
||
10 |
{ |
||
11 |
|||
12 |
✗✓ | 22 |
class DummyObserver : public JsonParser::IObserver |
13 |
{ |
||
14 |
public: |
||
15 |
12 |
const std::vector<std::string>& getReport() const |
|
16 |
{ |
||
17 |
12 |
return m_report; |
|
18 |
} |
||
19 |
|||
20 |
9 |
void beginObject() override |
|
21 |
{ |
||
22 |
✓✗✓✗ |
9 |
m_report.push_back("beginObject"); |
23 |
9 |
} |
|
24 |
|||
25 |
3 |
void endObject() override |
|
26 |
{ |
||
27 |
✓✗✓✗ |
3 |
m_report.push_back("endObject"); |
28 |
3 |
} |
|
29 |
|||
30 |
2 |
void beginArray() override |
|
31 |
{ |
||
32 |
✓✗✓✗ |
2 |
m_report.push_back("beginArray"); |
33 |
2 |
} |
|
34 |
|||
35 |
1 |
void endArray() override |
|
36 |
{ |
||
37 |
✓✗✓✗ |
1 |
m_report.push_back("endArray"); |
38 |
1 |
} |
|
39 |
|||
40 |
7 |
void visitKey(StringView stringValue) override |
|
41 |
{ |
||
42 |
✓✗✓✗ |
7 |
m_report.push_back("visitKey: " + toString(stringValue)); |
43 |
7 |
} |
|
44 |
|||
45 |
1 |
void visitValue(std::nullptr_t) override |
|
46 |
{ |
||
47 |
✓✗✓✗ |
1 |
m_report.push_back("visitValue: null"); |
48 |
1 |
} |
|
49 |
|||
50 |
1 |
void visitValue(bool boolValue) override |
|
51 |
{ |
||
52 |
✓✗✓✗ |
1 |
m_report.push_back("visitValue: " + toString(boolValue)); |
53 |
1 |
} |
|
54 |
|||
55 |
1 |
void visitValue(int64_t intValue) override |
|
56 |
{ |
||
57 |
✓✗✓✗ |
1 |
m_report.push_back("visitValue: " + toString(intValue)); |
58 |
1 |
} |
|
59 |
|||
60 |
4 |
void visitValue(uint64_t uintValue) override |
|
61 |
{ |
||
62 |
✓✗✓✗ |
4 |
m_report.push_back("visitValue: " + toString(uintValue)); |
63 |
4 |
} |
|
64 |
|||
65 |
1 |
void visitValue(double doubleValue) override |
|
66 |
{ |
||
67 |
✓✗✓✗ |
1 |
m_report.push_back("visitValue: " + std::to_string(doubleValue)); |
68 |
1 |
} |
|
69 |
|||
70 |
6 |
void visitValue(StringView stringValue) override |
|
71 |
{ |
||
72 |
✓✗✓✗ |
6 |
m_report.push_back("visitValue: " + toString(stringValue)); |
73 |
6 |
} |
|
74 |
|||
75 |
private: |
||
76 |
std::vector<std::string> m_report; |
||
77 |
}; |
||
78 |
|||
79 |
} // namespace |
||
80 |
|||
81 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(JsonParserTest, empty) |
82 |
{ |
||
83 |
✓✗✓✗ |
2 |
std::stringstream str(""); |
84 |
✓✗ | 2 |
DummyObserver observer; |
85 |
✓✗✓✗ |
2 |
JsonParser jsonParser(str, observer); |
86 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(jsonParser.parse()); |
87 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗ |
1 |
ASSERT_EQ(0, observer.getReport().size()); |
88 |
} |
||
89 |
|||
90 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(JsonParserTest, oneString) |
91 |
{ |
||
92 |
✓✗✓✗ |
2 |
std::stringstream str("\"text\""); |
93 |
✓✗ | 2 |
DummyObserver observer; |
94 |
✓✗✓✗ |
2 |
JsonParser jsonParser(str, observer); |
95 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(jsonParser.parse()); |
96 |
✓✗✓✗ ✓✗✓✓ ✗✓✗✗ ✗✗✗✗ ✓✗✓✗ ✗✗ |
1 |
ASSERT_EQ(std::vector<std::string>{{"visitValue: text"}}, observer.getReport()); |
97 |
} |
||
98 |
|||
99 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(JsonParserTest, twoStrings) |
100 |
{ |
||
101 |
✓✗✓✗ |
2 |
std::stringstream str("\"text\"\"second\""); |
102 |
✓✗ | 2 |
DummyObserver observer; |
103 |
✓✗✓✗ |
2 |
JsonParser jsonParser(str, observer); |
104 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_FALSE(jsonParser.parse()); |
105 |
✓✗✓✗ ✓✓✓✗ ✗✗ |
2 |
std::vector<std::string> expectedReport = {{"visitValue: text"}}; |
106 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ |
1 |
ASSERT_EQ(expectedReport, observer.getReport()); |
107 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(jsonParser.parse()); |
108 |
✓✗✓✗ |
1 |
expectedReport.push_back("visitValue: second"); |
109 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗ |
1 |
ASSERT_EQ(expectedReport, observer.getReport()); |
110 |
} |
||
111 |
|||
112 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(JsonParserTest, parse) |
113 |
{ |
||
114 |
✓✗✓✗ |
2 |
std::stringstream str("{\"array\":\n[\n{\"key1\":\n10, \"key2\":\n\"text\"}, {}]}"); |
115 |
✓✗ | 2 |
DummyObserver observer; |
116 |
✓✗✓✗ |
2 |
JsonParser jsonParser(str, observer); |
117 |
✓✗✗✓ ✗✗✗✗ ✗✗✗✗ ✓✗ |
1 |
ASSERT_TRUE(jsonParser.parse()); |
118 |
|||
119 |
std::vector<std::string> expectedReport = {{ |
||
120 |
{"beginObject"}, |
||
121 |
{"visitKey: array"}, |
||
122 |
{"beginArray"}, |
||
123 |
{"beginObject"}, |
||
124 |
{"visitKey: key1"}, |
||
125 |
{"visitValue: 10"}, |
||
126 |
{"visitKey: key2"}, |
||
127 |
{"visitValue: text"}, |
||
128 |
{"endObject"}, |
||
129 |
{"beginObject"}, |
||
130 |
{"endObject"}, |
||
131 |
{"endArray"}, |
||
132 |
{"endObject"} |
||
133 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✓✓✗ ✗✗ |
2 |
}}; |
134 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗ |
1 |
ASSERT_EQ(expectedReport, observer.getReport()); |
135 |
} |
||
136 |
|||
137 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(JsonParserTest, valueTypes) |
138 |
{ |
||
139 |
✓✗✓✗ |
2 |
std::stringstream str("null true 10 -10 1.1 \"str\""); |
140 |
✓✗ | 2 |
DummyObserver observer; |
141 |
✓✗✓✗ |
2 |
JsonParser jsonParser(str, observer); |
142 |
✓✗✓✓ |
6 |
while (!jsonParser.parse()) |
143 |
{} |
||
144 |
|||
145 |
std::vector<std::string> expectedReport = {{ |
||
146 |
{"visitValue: null"}, |
||
147 |
{"visitValue: true"}, |
||
148 |
{"visitValue: 10"}, |
||
149 |
{"visitValue: -10"}, |
||
150 |
{"visitValue: 1.100000"}, |
||
151 |
{"visitValue: str"} |
||
152 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✓ ✓✗✗✗ |
2 |
}}; |
153 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗ |
1 |
ASSERT_EQ(expectedReport, observer.getReport()); |
154 |
} |
||
155 |
|||
156 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(JsonParserTest, unexpectedObject) |
157 |
{ |
||
158 |
✓✗✓✗ |
2 |
std::stringstream str("{\n\n{\n\n"); |
159 |
✓✗ | 2 |
DummyObserver observer; |
160 |
✓✗✓✗ ✗✓ |
2 |
JsonParser jsonParser(str, observer); |
161 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW({ |
162 |
try |
||
163 |
{ |
||
164 |
jsonParser.parse(); |
||
165 |
} |
||
166 |
catch (const JsonParserException& e) |
||
167 |
{ |
||
168 |
ASSERT_STREQ("JsonParser:3:1: unexpected token: BEGIN_OBJECT, expecting END_OBJECT!", e.what()); |
||
169 |
throw; |
||
170 |
} |
||
171 |
}, JsonParserException); |
||
172 |
|||
173 |
std::vector<std::string> expectedReport = {{ |
||
174 |
"beginObject" |
||
175 |
✓✗✓✗ ✓✓✓✗ ✗✗ |
2 |
}}; |
176 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗ |
1 |
ASSERT_EQ(expectedReport, observer.getReport()); |
177 |
} |
||
178 |
|||
179 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(JsonParserTest, unexpectedObjectAfterItemSeparator) |
180 |
{ |
||
181 |
✓✗✓✗ |
2 |
std::stringstream str("{\n \"key\": 10,\n {\n"); |
182 |
✓✗ | 2 |
DummyObserver observer; |
183 |
✓✗✓✗ ✗✓ |
2 |
JsonParser jsonParser(str, observer); |
184 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW({ |
185 |
try |
||
186 |
{ |
||
187 |
jsonParser.parse(); |
||
188 |
} |
||
189 |
catch (const JsonParserException& e) |
||
190 |
{ |
||
191 |
ASSERT_STREQ("JsonParser:3:3: unexpected token: BEGIN_OBJECT, expecting VALUE!", e.what()); |
||
192 |
throw; |
||
193 |
} |
||
194 |
}, JsonParserException); |
||
195 |
|||
196 |
std::vector<std::string> expectedReport = {{ |
||
197 |
{"beginObject"}, |
||
198 |
{"visitKey: key"}, |
||
199 |
{"visitValue: 10"} |
||
200 |
✓✗✓✗ ✓✗✓✗ ✓✓✓✗ ✗✗ |
2 |
}}; |
201 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗ |
1 |
ASSERT_EQ(expectedReport, observer.getReport()); |
202 |
} |
||
203 |
|||
204 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(JsonParserTest, missingObjectItemSeparator) |
205 |
{ |
||
206 |
✓✗✓✗ |
2 |
std::stringstream str("{\n\"item1\":\"text\"\n\"item2\":\"text\"\n}"); |
207 |
✓✗ | 2 |
DummyObserver observer; |
208 |
✓✗✓✗ ✗✓ |
2 |
JsonParser jsonParser(str, observer); |
209 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW({ |
210 |
try |
||
211 |
{ |
||
212 |
jsonParser.parse(); |
||
213 |
} |
||
214 |
catch (const JsonParserException& e) |
||
215 |
{ |
||
216 |
ASSERT_STREQ("JsonParser:3:1: unexpected token: VALUE, expecting END_OBJECT!", e.what()); |
||
217 |
throw; |
||
218 |
} |
||
219 |
}, JsonParserException); |
||
220 |
|||
221 |
std::vector<std::string> expectedReport = {{ |
||
222 |
{"beginObject"}, |
||
223 |
{"visitKey: item1"}, |
||
224 |
{"visitValue: text"} |
||
225 |
✓✗✓✗ ✓✗✓✗ ✓✓✓✗ ✗✗ |
2 |
}}; |
226 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗ |
1 |
ASSERT_EQ(expectedReport, observer.getReport()); |
227 |
} |
||
228 |
|||
229 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(JsonParserTest, wrongKeyType) |
230 |
{ |
||
231 |
✓✗✓✗ |
2 |
std::stringstream str("{\n10:\"text\"\n}"); |
232 |
✓✗ | 2 |
DummyObserver observer; |
233 |
✓✗✓✗ ✗✓ |
2 |
JsonParser jsonParser(str, observer); |
234 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW({ |
235 |
try |
||
236 |
{ |
||
237 |
jsonParser.parse(); |
||
238 |
} |
||
239 |
catch (const JsonParserException& e) |
||
240 |
{ |
||
241 |
ASSERT_STREQ("JsonParser:2:1: Key must be a string value!", e.what()); |
||
242 |
throw; |
||
243 |
} |
||
244 |
}, JsonParserException); |
||
245 |
|||
246 |
std::vector<std::string> expectedReport = {{ |
||
247 |
"beginObject" |
||
248 |
✓✗✓✗ ✓✓✓✗ ✗✗ |
2 |
}}; |
249 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗ |
1 |
ASSERT_EQ(expectedReport, observer.getReport()); |
250 |
} |
||
251 |
|||
252 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(JsonParserTest, unexpectedElementToken) |
253 |
{ |
||
254 |
✓✗✓✗ |
2 |
std::stringstream str("{\n\"item\":}"); |
255 |
✓✗ | 2 |
DummyObserver observer; |
256 |
✓✗✓✗ ✗✓ |
2 |
JsonParser jsonParser(str, observer); |
257 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW({ |
258 |
try |
||
259 |
{ |
||
260 |
jsonParser.parse(); |
||
261 |
} |
||
262 |
catch (const JsonParserException& e) |
||
263 |
{ |
||
264 |
ASSERT_STREQ("JsonParser:2:8: unexpected token: END_OBJECT, " |
||
265 |
"expecting one of [BEGIN_OBJECT, BEGIN_ARRAY, VALUE]!", e.what()); |
||
266 |
throw; |
||
267 |
} |
||
268 |
}, JsonParserException); |
||
269 |
|||
270 |
std::vector<std::string> expectedReport = {{ |
||
271 |
{"beginObject"}, |
||
272 |
{"visitKey: item"} |
||
273 |
✓✗✓✗ ✓✗✓✓ ✓✗✗✗ |
2 |
}}; |
274 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗ |
1 |
ASSERT_EQ(expectedReport, observer.getReport()); |
275 |
} |
||
276 |
|||
277 |
✓✗✓✗ ✓✗✗✓ |
802 |
TEST(JsonParserTest, missingArrayElementSeparator) |
278 |
{ |
||
279 |
✓✗✓✗ |
2 |
std::stringstream str("{\n\"array\":\n[10\n20\n]}"); |
280 |
✓✗ | 2 |
DummyObserver observer; |
281 |
✓✗✓✗ ✗✓ |
2 |
JsonParser jsonParser(str, observer); |
282 |
✓✗✓✗ ✓✗✗✓ ✗✓✗✗ ✗✗✗✗ ✗✗✓✗ ✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✗✗✓✗ ✗✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗ |
2 |
ASSERT_THROW({ |
283 |
try |
||
284 |
{ |
||
285 |
jsonParser.parse(); |
||
286 |
} |
||
287 |
catch (const JsonParserException& e) |
||
288 |
{ |
||
289 |
ASSERT_STREQ("JsonParser:4:1: unexpected token: VALUE, expecting END_ARRAY!", e.what()); |
||
290 |
throw; |
||
291 |
} |
||
292 |
}, JsonParserException); |
||
293 |
|||
294 |
std::vector<std::string> expectedReport = {{ |
||
295 |
{"beginObject"}, |
||
296 |
{"visitKey: array"}, |
||
297 |
{"beginArray"}, |
||
298 |
{"visitValue: 10"} |
||
299 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✓ ✓✗✗✗ |
2 |
}}; |
300 |
✓✗✗✓ ✗✗✗✗ ✗✗✓✗ ✓✗ |
1 |
ASSERT_EQ(expectedReport, observer.getReport()); |
301 |
} |
||
302 |
|||
303 |
✓✗✓✗ |
2394 |
} // namespace zserio |
Generated by: GCOVR (Version 4.2) |