GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: test/zserio/JsonEncoderTest.cpp Lines: 138 140 98.6 %
Date: 2023-12-13 14:51:09 Branches: 348 1000 34.8 %

Line Branch Exec Source
1
#include "gtest/gtest.h"
2
3
#include <cmath>
4
#include <sstream>
5
6
#include "zserio/JsonEncoder.h"
7
8
namespace zserio
9
{
10
11


802
TEST(JsonEncoderTest, encodeNull)
12
{
13
2
    std::ostringstream os;
14
1
    JsonEncoder::encodeNull(os);
15




1
    ASSERT_EQ("null", os.str());
16
}
17
18


802
TEST(JsonEncoderTest, encodeBool)
19
{
20
2
    std::ostringstream os;
21
1
    JsonEncoder::encodeBool(os, true);
22



1
    ASSERT_EQ("true", os.str());
23
24

1
    os.str("");
25
1
    JsonEncoder::encodeBool(os, false);
26




1
    ASSERT_EQ("false", os.str());
27
}
28
29


802
TEST(JsonEncoderTest, encodeIntegral)
30
{
31
2
    std::ostringstream os;
32
1
    JsonEncoder::encodeIntegral(os, static_cast<uint8_t>(UINT8_MAX));
33




1
    ASSERT_EQ(std::to_string(UINT8_MAX), os.str());
34

1
    os.str("");
35
1
    JsonEncoder::encodeIntegral(os, static_cast<uint16_t>(UINT16_MAX));
36




1
    ASSERT_EQ(std::to_string(UINT16_MAX), os.str());
37

1
    os.str("");
38
1
    JsonEncoder::encodeIntegral(os, static_cast<uint32_t>(UINT32_MAX));
39




1
    ASSERT_EQ(std::to_string(UINT32_MAX), os.str());
40

1
    os.str("");
41
1
    JsonEncoder::encodeIntegral(os, static_cast<uint64_t>(UINT64_MAX));
42




1
    ASSERT_EQ(std::to_string(UINT64_MAX), os.str());
43
44

1
    os.str("");
45
1
    JsonEncoder::encodeIntegral(os, static_cast<int8_t>(INT8_MIN));
46




1
    ASSERT_EQ(std::to_string(INT8_MIN), os.str());
47

1
    os.str("");
48
1
    JsonEncoder::encodeIntegral(os, static_cast<int8_t>(INT8_MAX));
49




1
    ASSERT_EQ(std::to_string(INT8_MAX), os.str());
50

1
    os.str("");
51
1
    JsonEncoder::encodeIntegral(os, static_cast<int16_t>(INT16_MIN));
52




1
    ASSERT_EQ(std::to_string(INT16_MIN), os.str());
53

1
    os.str("");
54
1
    JsonEncoder::encodeIntegral(os, static_cast<int16_t>(INT16_MAX));
55




1
    ASSERT_EQ(std::to_string(INT16_MAX), os.str());
56

1
    os.str("");
57
1
    JsonEncoder::encodeIntegral(os, static_cast<int32_t>(INT32_MIN));
58




1
    ASSERT_EQ(std::to_string(INT32_MIN), os.str());
59

1
    os.str("");
60
1
    JsonEncoder::encodeIntegral(os, static_cast<int32_t>(INT32_MAX));
61




1
    ASSERT_EQ(std::to_string(INT32_MAX), os.str());
62

1
    os.str("");
63
1
    JsonEncoder::encodeIntegral(os, static_cast<int64_t>(INT64_MIN));
64




1
    ASSERT_EQ(std::to_string(INT64_MIN), os.str());
65

1
    os.str("");
66
1
    JsonEncoder::encodeIntegral(os, static_cast<int64_t>(INT64_MAX));
67




1
    ASSERT_EQ(std::to_string(INT64_MAX), os.str());
68
69

1
    os.str("");
70
1
    JsonEncoder::encodeIntegral(os, INT64_MIN);
71



1
    ASSERT_EQ("-9223372036854775808", os.str());
72

1
    os.str("");
73
1
    JsonEncoder::encodeIntegral(os, -1000);
74



1
    ASSERT_EQ("-1000", os.str());
75

1
    os.str("");
76
1
    JsonEncoder::encodeIntegral(os, 0);
77



1
    ASSERT_EQ("0", os.str());
78

1
    os.str("");
79
1
    JsonEncoder::encodeIntegral(os, 1000);
80



1
    ASSERT_EQ("1000", os.str());
81

1
    os.str("");
82
1
    JsonEncoder::encodeIntegral(os, UINT64_MAX);
83




1
    ASSERT_EQ("18446744073709551615", os.str());
84
}
85
86


802
TEST(JsonEncoderTest, encodeFloatingPoint)
87
{
88
2
    std::ostringstream os;
89
1
    JsonEncoder::encodeFloatingPoint(os, -1.0);
90



1
    ASSERT_EQ("-1.0", os.str());
91

1
    os.str("");
92
1
    JsonEncoder::encodeFloatingPoint(os, 0.0);
93



1
    ASSERT_EQ("0.0", os.str());
94

1
    os.str("");
95
1
    JsonEncoder::encodeFloatingPoint(os, 1.0);
96



1
    ASSERT_EQ("1.0", os.str());
97
98

1
    os.str("");
99
1
    JsonEncoder::encodeFloatingPoint(os, 3.5);
100



1
    ASSERT_EQ("3.5", os.str());
101

1
    os.str("");
102
1
    JsonEncoder::encodeFloatingPoint(os, 9.875);
103



1
    ASSERT_EQ("9.875", os.str());
104

1
    os.str("");
105
1
    JsonEncoder::encodeFloatingPoint(os, 0.6171875);
106



1
    ASSERT_EQ("0.6171875", os.str());
107
108

1
    os.str("");
109
1
    JsonEncoder::encodeFloatingPoint(os, 1e20);
110






2
    ASSERT_TRUE("1e+20" == os.str() || "1e+020" == os.str())
111
            << "Value '" << os.str() << "' does not match to neither '1e+20' nor '1e+020'";
112
113

1
    os.str("");
114
1
    JsonEncoder::encodeFloatingPoint(os, -1e+16);
115






2
    ASSERT_TRUE("-1e+16" == os.str() || "-1e+016" == os.str())
116
            << "Value '" << os.str() << "' does not match to neither '-1e+16' nor '-1e+016'";
117
118

1
    os.str("");
119
1
    JsonEncoder::encodeFloatingPoint(os, static_cast<double>(NAN));
120



1
    ASSERT_EQ("NaN", os.str());
121

1
    os.str("");
122
1
    JsonEncoder::encodeFloatingPoint(os, static_cast<double>(INFINITY));
123



1
    ASSERT_EQ("Infinity", os.str());
124

1
    os.str("");
125
1
    JsonEncoder::encodeFloatingPoint(os, -static_cast<double>(INFINITY));
126




1
    ASSERT_EQ("-Infinity", os.str());
127
}
128
129


802
TEST(JsonEncoderTest, encodeString)
130
{
131
2
    std::ostringstream os;
132
1
    JsonEncoder::encodeString(os, "");
133



1
    ASSERT_EQ("\"\"", os.str());
134

1
    os.str("");
135
1
    JsonEncoder::encodeString(os, "test");
136



1
    ASSERT_EQ("\"test\"", os.str());
137

1
    os.str("");
138
1
    JsonEncoder::encodeString(os, "München");
139



1
    ASSERT_EQ("\"München\"", os.str());
140

1
    os.str("");
141
1
    JsonEncoder::encodeString(os, "€");
142



1
    ASSERT_EQ("\"€\"", os.str());
143
144
    // escapes
145

1
    os.str("");
146
1
    JsonEncoder::encodeString(os, "\\");
147



1
    ASSERT_EQ("\"\\\\\"", os.str());
148

1
    os.str("");
149
1
    JsonEncoder::encodeString(os, "\"");
150



1
    ASSERT_EQ("\"\\\"\"", os.str());
151

1
    os.str("");
152
1
    JsonEncoder::encodeString(os, "\b");
153



1
    ASSERT_EQ("\"\\b\"", os.str());
154

1
    os.str("");
155
1
    JsonEncoder::encodeString(os, "\f");
156



1
    ASSERT_EQ("\"\\f\"", os.str());
157

1
    os.str("");
158
1
    JsonEncoder::encodeString(os, "\n");
159



1
    ASSERT_EQ("\"\\n\"", os.str());
160

1
    os.str("");
161
1
    JsonEncoder::encodeString(os, "\r");
162



1
    ASSERT_EQ("\"\\r\"", os.str());
163

1
    os.str("");
164
1
    JsonEncoder::encodeString(os, "\t");
165



1
    ASSERT_EQ("\"\\t\"", os.str());
166
167

1
    os.str("");
168
1
    JsonEncoder::encodeString(os, "\n\t%^@(*aAzZ01234569$%^!?<>[]](){}-=+~:;/|\\\"\'Hello World2");
169



1
    ASSERT_EQ("\"\\n\\t%^@(*aAzZ01234569$%^!?<>[]](){}-=+~:;/|\\\\\\\"'Hello World2\"", os.str());
170
171
    // <= 0x1F -> unicode escape
172

1
    os.str("");
173
1
    JsonEncoder::encodeString(os, "\x1F");
174




1
    ASSERT_EQ("\"\\u001f\"", os.str());
175
}
176
177

2394
} // namespace zserio
178