GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: test/zserio/JsonParserTest.cpp Lines: 115 115 100.0 %
Date: 2023-12-13 14:51:09 Branches: 337 982 34.3 %

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