1 // Copyright 2020 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "util/json/json_helpers.h"
6
7 #include "gmock/gmock.h"
8 #include "gtest/gtest.h"
9 #include "util/chrono_helpers.h"
10
11 namespace openscreen {
12 namespace json {
13 namespace {
14
15 using ::testing::ElementsAre;
16
17 const Json::Value kNone;
18 const Json::Value kEmptyString = "";
19 const Json::Value kEmptyArray(Json::arrayValue);
20
21 struct Dummy {
22 int value;
23
operator ==openscreen::json::__anon0993d03d0111::Dummy24 constexpr bool operator==(const Dummy& other) const {
25 return other.value == value;
26 }
27 };
28
TryParseDummy(const Json::Value & value,Dummy * out)29 bool TryParseDummy(const Json::Value& value, Dummy* out) {
30 int value_out;
31 if (!TryParseInt(value, &value_out)) {
32 return false;
33 }
34 *out = Dummy{value_out};
35 return true;
36 }
37
38 } // namespace
39
TEST(ParsingHelpersTest,TryParseDouble)40 TEST(ParsingHelpersTest, TryParseDouble) {
41 const Json::Value kValid = 13.37;
42 const Json::Value kNotDouble = "coffee beans";
43 const Json::Value kNegativeDouble = -4.2;
44 const Json::Value kZeroDouble = 0.0;
45 const Json::Value kNanDouble = std::nan("");
46
47 double out;
48 EXPECT_TRUE(TryParseDouble(kValid, &out));
49 EXPECT_DOUBLE_EQ(13.37, out);
50 EXPECT_TRUE(TryParseDouble(kZeroDouble, &out));
51 EXPECT_DOUBLE_EQ(0.0, out);
52 EXPECT_FALSE(TryParseDouble(kNotDouble, &out));
53 EXPECT_FALSE(TryParseDouble(kNegativeDouble, &out));
54 EXPECT_FALSE(TryParseDouble(kNone, &out));
55 EXPECT_FALSE(TryParseDouble(kNanDouble, &out));
56 }
57
TEST(ParsingHelpersTest,TryParseInt)58 TEST(ParsingHelpersTest, TryParseInt) {
59 const Json::Value kValid = 1337;
60 const Json::Value kNotInt = "cold brew";
61 const Json::Value kNegativeInt = -42;
62 const Json::Value kZeroInt = 0;
63
64 int out;
65 EXPECT_TRUE(TryParseInt(kValid, &out));
66 EXPECT_EQ(1337, out);
67 EXPECT_TRUE(TryParseInt(kZeroInt, &out));
68 EXPECT_EQ(0, out);
69 EXPECT_FALSE(TryParseInt(kNone, &out));
70 EXPECT_FALSE(TryParseInt(kNotInt, &out));
71 EXPECT_FALSE(TryParseInt(kNegativeInt, &out));
72 }
73
TEST(ParsingHelpersTest,TryParseUint)74 TEST(ParsingHelpersTest, TryParseUint) {
75 const Json::Value kValid = 1337u;
76 const Json::Value kNotUint = "espresso";
77 const Json::Value kZeroUint = 0u;
78
79 uint32_t out;
80 EXPECT_TRUE(TryParseUint(kValid, &out));
81 EXPECT_EQ(1337u, out);
82 EXPECT_TRUE(TryParseUint(kZeroUint, &out));
83 EXPECT_EQ(0u, out);
84 EXPECT_FALSE(TryParseUint(kNone, &out));
85 EXPECT_FALSE(TryParseUint(kNotUint, &out));
86 }
87
TEST(ParsingHelpersTest,TryParseString)88 TEST(ParsingHelpersTest, TryParseString) {
89 const Json::Value kValid = "macchiato";
90 const Json::Value kNotString = 42;
91
92 std::string out;
93 EXPECT_TRUE(TryParseString(kValid, &out));
94 EXPECT_EQ("macchiato", out);
95 EXPECT_TRUE(TryParseString(kEmptyString, &out));
96 EXPECT_EQ("", out);
97 EXPECT_FALSE(TryParseString(kNone, &out));
98 EXPECT_FALSE(TryParseString(kNotString, &out));
99 }
100
101 // Simple fraction validity is tested extensively in its unit tests, so we
102 // just check the major cases here.
TEST(ParsingHelpersTest,TryParseSimpleFraction)103 TEST(ParsingHelpersTest, TryParseSimpleFraction) {
104 const Json::Value kValid = "42/30";
105 const Json::Value kValidNumber = "42";
106 const Json::Value kUndefined = "5/0";
107 const Json::Value kNegative = "10/-2";
108 const Json::Value kInvalidNumber = "-1";
109 const Json::Value kNotSimpleFraction = "latte";
110 const Json::Value kInteger = 123;
111 const Json::Value kNegativeInteger = -5000;
112
113 SimpleFraction out;
114 EXPECT_TRUE(TryParseSimpleFraction(kValid, &out));
115 EXPECT_EQ((SimpleFraction{42, 30}), out);
116 EXPECT_TRUE(TryParseSimpleFraction(kValidNumber, &out));
117 EXPECT_EQ((SimpleFraction{42, 1}), out);
118 EXPECT_TRUE(TryParseSimpleFraction(kInteger, &out));
119 EXPECT_EQ((SimpleFraction{123, 1}), out);
120 EXPECT_FALSE(TryParseSimpleFraction(kUndefined, &out));
121 EXPECT_FALSE(TryParseSimpleFraction(kNegative, &out));
122 EXPECT_FALSE(TryParseSimpleFraction(kInvalidNumber, &out));
123 EXPECT_FALSE(TryParseSimpleFraction(kNotSimpleFraction, &out));
124 EXPECT_FALSE(TryParseSimpleFraction(kNone, &out));
125 EXPECT_FALSE(TryParseSimpleFraction(kEmptyString, &out));
126 EXPECT_FALSE(TryParseSimpleFraction(kNegativeInteger, &out));
127 }
128
TEST(ParsingHelpersTest,TryParseMilliseconds)129 TEST(ParsingHelpersTest, TryParseMilliseconds) {
130 const Json::Value kValid = 1000;
131 const Json::Value kValidFloat = 500.0;
132 const Json::Value kNegativeNumber = -120;
133 const Json::Value kZeroNumber = 0;
134 const Json::Value kNotNumber = "affogato";
135
136 milliseconds out;
137 EXPECT_TRUE(TryParseMilliseconds(kValid, &out));
138 EXPECT_EQ(milliseconds(1000), out);
139 EXPECT_TRUE(TryParseMilliseconds(kValidFloat, &out));
140 EXPECT_EQ(milliseconds(500), out);
141 EXPECT_TRUE(TryParseMilliseconds(kZeroNumber, &out));
142 EXPECT_EQ(milliseconds(0), out);
143 EXPECT_FALSE(TryParseMilliseconds(kNone, &out));
144 EXPECT_FALSE(TryParseMilliseconds(kNegativeNumber, &out));
145 EXPECT_FALSE(TryParseMilliseconds(kNotNumber, &out));
146 }
147
TEST(ParsingHelpersTest,TryParseArray)148 TEST(ParsingHelpersTest, TryParseArray) {
149 Json::Value valid_dummy_array;
150 valid_dummy_array[0] = 123;
151 valid_dummy_array[1] = 456;
152
153 Json::Value invalid_dummy_array;
154 invalid_dummy_array[0] = "iced coffee";
155 invalid_dummy_array[1] = 456;
156
157 std::vector<Dummy> out;
158 EXPECT_TRUE(TryParseArray<Dummy>(valid_dummy_array, TryParseDummy, &out));
159 EXPECT_THAT(out, ElementsAre(Dummy{123}, Dummy{456}));
160 EXPECT_FALSE(TryParseArray<Dummy>(invalid_dummy_array, TryParseDummy, &out));
161 EXPECT_FALSE(TryParseArray<Dummy>(kEmptyArray, TryParseDummy, &out));
162 }
163
TEST(ParsingHelpersTest,TryParseIntArray)164 TEST(ParsingHelpersTest, TryParseIntArray) {
165 Json::Value valid_int_array;
166 valid_int_array[0] = 123;
167 valid_int_array[1] = 456;
168
169 Json::Value invalid_int_array;
170 invalid_int_array[0] = "iced coffee";
171 invalid_int_array[1] = 456;
172
173 std::vector<int> out;
174 EXPECT_TRUE(TryParseIntArray(valid_int_array, &out));
175 EXPECT_THAT(out, ElementsAre(123, 456));
176 EXPECT_FALSE(TryParseIntArray(invalid_int_array, &out));
177 EXPECT_FALSE(TryParseIntArray(kEmptyArray, &out));
178 }
179
TEST(ParsingHelpersTest,TryParseUintArray)180 TEST(ParsingHelpersTest, TryParseUintArray) {
181 Json::Value valid_uint_array;
182 valid_uint_array[0] = 123u;
183 valid_uint_array[1] = 456u;
184
185 Json::Value invalid_uint_array;
186 invalid_uint_array[0] = "breve";
187 invalid_uint_array[1] = 456u;
188
189 std::vector<uint32_t> out;
190 EXPECT_TRUE(TryParseUintArray(valid_uint_array, &out));
191 EXPECT_THAT(out, ElementsAre(123u, 456u));
192 EXPECT_FALSE(TryParseUintArray(invalid_uint_array, &out));
193 EXPECT_FALSE(TryParseUintArray(kEmptyArray, &out));
194 }
195
TEST(ParsingHelpersTest,TryParseStringArray)196 TEST(ParsingHelpersTest, TryParseStringArray) {
197 Json::Value valid_string_array;
198 valid_string_array[0] = "nitro cold brew";
199 valid_string_array[1] = "doppio espresso";
200
201 Json::Value invalid_string_array;
202 invalid_string_array[0] = "mocha latte";
203 invalid_string_array[1] = 456;
204
205 std::vector<std::string> out;
206 EXPECT_TRUE(TryParseStringArray(valid_string_array, &out));
207 EXPECT_THAT(out, ElementsAre("nitro cold brew", "doppio espresso"));
208 EXPECT_FALSE(TryParseStringArray(invalid_string_array, &out));
209 EXPECT_FALSE(TryParseStringArray(kEmptyArray, &out));
210 }
211
212 } // namespace json
213 } // namespace openscreen
214