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::__anonc01fe0870111::Dummy24   constexpr bool operator==(const Dummy& other) const {
25     return other.value == value;
26   }
27 };
28 
ParseAndValidateDummy(const Json::Value & value,Dummy * out)29 bool ParseAndValidateDummy(const Json::Value& value, Dummy* out) {
30   int value_out;
31   if (!ParseAndValidateInt(value, &value_out)) {
32     return false;
33   }
34   *out = Dummy{value_out};
35   return true;
36 }
37 
38 }  // namespace
39 
TEST(ParsingHelpersTest,ParseAndValidateDouble)40 TEST(ParsingHelpersTest, ParseAndValidateDouble) {
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(ParseAndValidateDouble(kValid, &out));
49   EXPECT_DOUBLE_EQ(13.37, out);
50   EXPECT_TRUE(ParseAndValidateDouble(kZeroDouble, &out));
51   EXPECT_DOUBLE_EQ(0.0, out);
52   EXPECT_FALSE(ParseAndValidateDouble(kNotDouble, &out));
53   EXPECT_FALSE(ParseAndValidateDouble(kNegativeDouble, &out));
54   EXPECT_FALSE(ParseAndValidateDouble(kNone, &out));
55   EXPECT_FALSE(ParseAndValidateDouble(kNanDouble, &out));
56 }
57 
TEST(ParsingHelpersTest,ParseAndValidateInt)58 TEST(ParsingHelpersTest, ParseAndValidateInt) {
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(ParseAndValidateInt(kValid, &out));
66   EXPECT_EQ(1337, out);
67   EXPECT_TRUE(ParseAndValidateInt(kZeroInt, &out));
68   EXPECT_EQ(0, out);
69   EXPECT_FALSE(ParseAndValidateInt(kNone, &out));
70   EXPECT_FALSE(ParseAndValidateInt(kNotInt, &out));
71   EXPECT_FALSE(ParseAndValidateInt(kNegativeInt, &out));
72 }
73 
TEST(ParsingHelpersTest,ParseAndValidateUint)74 TEST(ParsingHelpersTest, ParseAndValidateUint) {
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(ParseAndValidateUint(kValid, &out));
81   EXPECT_EQ(1337u, out);
82   EXPECT_TRUE(ParseAndValidateUint(kZeroUint, &out));
83   EXPECT_EQ(0u, out);
84   EXPECT_FALSE(ParseAndValidateUint(kNone, &out));
85   EXPECT_FALSE(ParseAndValidateUint(kNotUint, &out));
86 }
87 
TEST(ParsingHelpersTest,ParseAndValidateString)88 TEST(ParsingHelpersTest, ParseAndValidateString) {
89   const Json::Value kValid = "macchiato";
90   const Json::Value kNotString = 42;
91 
92   std::string out;
93   EXPECT_TRUE(ParseAndValidateString(kValid, &out));
94   EXPECT_EQ("macchiato", out);
95   EXPECT_TRUE(ParseAndValidateString(kEmptyString, &out));
96   EXPECT_EQ("", out);
97   EXPECT_FALSE(ParseAndValidateString(kNone, &out));
98   EXPECT_FALSE(ParseAndValidateString(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,ParseAndValidateSimpleFraction)103 TEST(ParsingHelpersTest, ParseAndValidateSimpleFraction) {
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(ParseAndValidateSimpleFraction(kValid, &out));
115   EXPECT_EQ((SimpleFraction{42, 30}), out);
116   EXPECT_TRUE(ParseAndValidateSimpleFraction(kValidNumber, &out));
117   EXPECT_EQ((SimpleFraction{42, 1}), out);
118   EXPECT_TRUE(ParseAndValidateSimpleFraction(kInteger, &out));
119   EXPECT_EQ((SimpleFraction{123, 1}), out);
120   EXPECT_FALSE(ParseAndValidateSimpleFraction(kUndefined, &out));
121   EXPECT_FALSE(ParseAndValidateSimpleFraction(kNegative, &out));
122   EXPECT_FALSE(ParseAndValidateSimpleFraction(kInvalidNumber, &out));
123   EXPECT_FALSE(ParseAndValidateSimpleFraction(kNotSimpleFraction, &out));
124   EXPECT_FALSE(ParseAndValidateSimpleFraction(kNone, &out));
125   EXPECT_FALSE(ParseAndValidateSimpleFraction(kEmptyString, &out));
126   EXPECT_FALSE(ParseAndValidateSimpleFraction(kNegativeInteger, &out));
127 }
128 
TEST(ParsingHelpersTest,ParseAndValidateMilliseconds)129 TEST(ParsingHelpersTest, ParseAndValidateMilliseconds) {
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(ParseAndValidateMilliseconds(kValid, &out));
138   EXPECT_EQ(milliseconds(1000), out);
139   EXPECT_TRUE(ParseAndValidateMilliseconds(kValidFloat, &out));
140   EXPECT_EQ(milliseconds(500), out);
141   EXPECT_TRUE(ParseAndValidateMilliseconds(kZeroNumber, &out));
142   EXPECT_EQ(milliseconds(0), out);
143   EXPECT_FALSE(ParseAndValidateMilliseconds(kNone, &out));
144   EXPECT_FALSE(ParseAndValidateMilliseconds(kNegativeNumber, &out));
145   EXPECT_FALSE(ParseAndValidateMilliseconds(kNotNumber, &out));
146 }
147 
TEST(ParsingHelpersTest,ParseAndValidateArray)148 TEST(ParsingHelpersTest, ParseAndValidateArray) {
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(ParseAndValidateArray<Dummy>(valid_dummy_array,
159                                            ParseAndValidateDummy, &out));
160   EXPECT_THAT(out, ElementsAre(Dummy{123}, Dummy{456}));
161   EXPECT_FALSE(ParseAndValidateArray<Dummy>(invalid_dummy_array,
162                                             ParseAndValidateDummy, &out));
163   EXPECT_FALSE(
164       ParseAndValidateArray<Dummy>(kEmptyArray, ParseAndValidateDummy, &out));
165 }
166 
TEST(ParsingHelpersTest,ParseAndValidateIntArray)167 TEST(ParsingHelpersTest, ParseAndValidateIntArray) {
168   Json::Value valid_int_array;
169   valid_int_array[0] = 123;
170   valid_int_array[1] = 456;
171 
172   Json::Value invalid_int_array;
173   invalid_int_array[0] = "iced coffee";
174   invalid_int_array[1] = 456;
175 
176   std::vector<int> out;
177   EXPECT_TRUE(ParseAndValidateIntArray(valid_int_array, &out));
178   EXPECT_THAT(out, ElementsAre(123, 456));
179   EXPECT_FALSE(ParseAndValidateIntArray(invalid_int_array, &out));
180   EXPECT_FALSE(ParseAndValidateIntArray(kEmptyArray, &out));
181 }
182 
TEST(ParsingHelpersTest,ParseAndValidateUintArray)183 TEST(ParsingHelpersTest, ParseAndValidateUintArray) {
184   Json::Value valid_uint_array;
185   valid_uint_array[0] = 123u;
186   valid_uint_array[1] = 456u;
187 
188   Json::Value invalid_uint_array;
189   invalid_uint_array[0] = "breve";
190   invalid_uint_array[1] = 456u;
191 
192   std::vector<uint32_t> out;
193   EXPECT_TRUE(ParseAndValidateUintArray(valid_uint_array, &out));
194   EXPECT_THAT(out, ElementsAre(123u, 456u));
195   EXPECT_FALSE(ParseAndValidateUintArray(invalid_uint_array, &out));
196   EXPECT_FALSE(ParseAndValidateUintArray(kEmptyArray, &out));
197 }
198 
TEST(ParsingHelpersTest,ParseAndValidateStringArray)199 TEST(ParsingHelpersTest, ParseAndValidateStringArray) {
200   Json::Value valid_string_array;
201   valid_string_array[0] = "nitro cold brew";
202   valid_string_array[1] = "doppio espresso";
203 
204   Json::Value invalid_string_array;
205   invalid_string_array[0] = "mocha latte";
206   invalid_string_array[1] = 456;
207 
208   std::vector<std::string> out;
209   EXPECT_TRUE(ParseAndValidateStringArray(valid_string_array, &out));
210   EXPECT_THAT(out, ElementsAre("nitro cold brew", "doppio espresso"));
211   EXPECT_FALSE(ParseAndValidateStringArray(invalid_string_array, &out));
212   EXPECT_FALSE(ParseAndValidateStringArray(kEmptyArray, &out));
213 }
214 
215 }  // namespace json
216 }  // namespace openscreen
217