1 /*
2 * Copyright 2009 The WebRTC Project Authors. All rights reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "rtc_base/strings/json.h"
12
13 #include <vector>
14
15 #include "test/gtest.h"
16
17 namespace rtc {
18
19 static Json::Value in_s("foo");
20 static Json::Value in_sn("99");
21 static Json::Value in_si("-99");
22 static Json::Value in_sb("true");
23 static Json::Value in_sd("1.2");
24 static Json::Value in_n(12);
25 static Json::Value in_i(-12);
26 static Json::Value in_u(34U);
27 static Json::Value in_b(true);
28 static Json::Value in_d(1.2);
29 static Json::Value big_sn("12345678901234567890");
30 static Json::Value big_si("-12345678901234567890");
31 static Json::Value big_u(0xFFFFFFFF);
32 static Json::Value bad_a(Json::arrayValue);
33 static Json::Value bad_o(Json::objectValue);
34
TEST(JsonTest,GetString)35 TEST(JsonTest, GetString) {
36 std::string out;
37 EXPECT_TRUE(GetStringFromJson(in_s, &out));
38 EXPECT_EQ("foo", out);
39 EXPECT_TRUE(GetStringFromJson(in_sn, &out));
40 EXPECT_EQ("99", out);
41 EXPECT_TRUE(GetStringFromJson(in_si, &out));
42 EXPECT_EQ("-99", out);
43 EXPECT_TRUE(GetStringFromJson(in_i, &out));
44 EXPECT_EQ("-12", out);
45 EXPECT_TRUE(GetStringFromJson(in_n, &out));
46 EXPECT_EQ("12", out);
47 EXPECT_TRUE(GetStringFromJson(in_u, &out));
48 EXPECT_EQ("34", out);
49 EXPECT_TRUE(GetStringFromJson(in_b, &out));
50 EXPECT_EQ("true", out);
51 // Not supported here yet.
52 EXPECT_FALSE(GetStringFromJson(bad_a, &out));
53 EXPECT_FALSE(GetStringFromJson(bad_o, &out));
54 }
55
TEST(JsonTest,GetInt)56 TEST(JsonTest, GetInt) {
57 int out;
58 EXPECT_TRUE(GetIntFromJson(in_sn, &out));
59 EXPECT_EQ(99, out);
60 EXPECT_TRUE(GetIntFromJson(in_si, &out));
61 EXPECT_EQ(-99, out);
62 EXPECT_TRUE(GetIntFromJson(in_n, &out));
63 EXPECT_EQ(12, out);
64 EXPECT_TRUE(GetIntFromJson(in_i, &out));
65 EXPECT_EQ(-12, out);
66 EXPECT_TRUE(GetIntFromJson(in_u, &out));
67 EXPECT_EQ(34, out);
68 EXPECT_TRUE(GetIntFromJson(in_b, &out));
69 EXPECT_EQ(1, out);
70 EXPECT_FALSE(GetIntFromJson(in_s, &out));
71 EXPECT_FALSE(GetIntFromJson(big_sn, &out));
72 EXPECT_FALSE(GetIntFromJson(big_si, &out));
73 EXPECT_FALSE(GetIntFromJson(big_u, &out));
74 EXPECT_FALSE(GetIntFromJson(bad_a, &out));
75 EXPECT_FALSE(GetIntFromJson(bad_o, &out));
76 }
77
TEST(JsonTest,GetUInt)78 TEST(JsonTest, GetUInt) {
79 unsigned int out;
80 EXPECT_TRUE(GetUIntFromJson(in_sn, &out));
81 EXPECT_EQ(99U, out);
82 EXPECT_TRUE(GetUIntFromJson(in_n, &out));
83 EXPECT_EQ(12U, out);
84 EXPECT_TRUE(GetUIntFromJson(in_u, &out));
85 EXPECT_EQ(34U, out);
86 EXPECT_TRUE(GetUIntFromJson(in_b, &out));
87 EXPECT_EQ(1U, out);
88 EXPECT_TRUE(GetUIntFromJson(big_u, &out));
89 EXPECT_EQ(0xFFFFFFFFU, out);
90 EXPECT_FALSE(GetUIntFromJson(in_s, &out));
91 // TODO(bugs.webrtc.org/9804): Fail reading negative strings.
92 // EXPECT_FALSE(GetUIntFromJson(in_si, &out));
93 EXPECT_FALSE(GetUIntFromJson(in_i, &out));
94 EXPECT_FALSE(GetUIntFromJson(big_sn, &out));
95 EXPECT_FALSE(GetUIntFromJson(big_si, &out));
96 EXPECT_FALSE(GetUIntFromJson(bad_a, &out));
97 EXPECT_FALSE(GetUIntFromJson(bad_o, &out));
98 }
99
TEST(JsonTest,GetBool)100 TEST(JsonTest, GetBool) {
101 bool out;
102 EXPECT_TRUE(GetBoolFromJson(in_sb, &out));
103 EXPECT_EQ(true, out);
104 EXPECT_TRUE(GetBoolFromJson(in_n, &out));
105 EXPECT_EQ(true, out);
106 EXPECT_TRUE(GetBoolFromJson(in_i, &out));
107 EXPECT_EQ(true, out);
108 EXPECT_TRUE(GetBoolFromJson(in_u, &out));
109 EXPECT_EQ(true, out);
110 EXPECT_TRUE(GetBoolFromJson(in_b, &out));
111 EXPECT_EQ(true, out);
112 EXPECT_TRUE(GetBoolFromJson(big_u, &out));
113 EXPECT_EQ(true, out);
114 EXPECT_FALSE(GetBoolFromJson(in_s, &out));
115 EXPECT_FALSE(GetBoolFromJson(in_sn, &out));
116 EXPECT_FALSE(GetBoolFromJson(in_si, &out));
117 EXPECT_FALSE(GetBoolFromJson(big_sn, &out));
118 EXPECT_FALSE(GetBoolFromJson(big_si, &out));
119 EXPECT_FALSE(GetBoolFromJson(bad_a, &out));
120 EXPECT_FALSE(GetBoolFromJson(bad_o, &out));
121 }
122
TEST(JsonTest,GetDouble)123 TEST(JsonTest, GetDouble) {
124 double out;
125 EXPECT_TRUE(GetDoubleFromJson(in_sn, &out));
126 EXPECT_EQ(99, out);
127 EXPECT_TRUE(GetDoubleFromJson(in_si, &out));
128 EXPECT_EQ(-99, out);
129 EXPECT_TRUE(GetDoubleFromJson(in_sd, &out));
130 EXPECT_EQ(1.2, out);
131 EXPECT_TRUE(GetDoubleFromJson(in_n, &out));
132 EXPECT_EQ(12, out);
133 EXPECT_TRUE(GetDoubleFromJson(in_i, &out));
134 EXPECT_EQ(-12, out);
135 EXPECT_TRUE(GetDoubleFromJson(in_u, &out));
136 EXPECT_EQ(34, out);
137 EXPECT_TRUE(GetDoubleFromJson(in_b, &out));
138 EXPECT_EQ(1, out);
139 EXPECT_TRUE(GetDoubleFromJson(in_d, &out));
140 EXPECT_EQ(1.2, out);
141 EXPECT_FALSE(GetDoubleFromJson(in_s, &out));
142 }
143
TEST(JsonTest,GetFromArray)144 TEST(JsonTest, GetFromArray) {
145 Json::Value a, out;
146 a.append(in_s);
147 a.append(in_i);
148 a.append(in_u);
149 a.append(in_b);
150 EXPECT_TRUE(GetValueFromJsonArray(a, 0, &out));
151 EXPECT_TRUE(GetValueFromJsonArray(a, 3, &out));
152 EXPECT_FALSE(GetValueFromJsonArray(a, 99, &out));
153 EXPECT_FALSE(GetValueFromJsonArray(a, 0xFFFFFFFF, &out));
154 }
155
TEST(JsonTest,GetFromObject)156 TEST(JsonTest, GetFromObject) {
157 Json::Value o, out;
158 o["string"] = in_s;
159 o["int"] = in_i;
160 o["uint"] = in_u;
161 o["bool"] = in_b;
162 EXPECT_TRUE(GetValueFromJsonObject(o, "int", &out));
163 EXPECT_TRUE(GetValueFromJsonObject(o, "bool", &out));
164 EXPECT_FALSE(GetValueFromJsonObject(o, "foo", &out));
165 EXPECT_FALSE(GetValueFromJsonObject(o, "", &out));
166 }
167
168 namespace {
169 template <typename T>
VecOf3(const T & a,const T & b,const T & c)170 std::vector<T> VecOf3(const T& a, const T& b, const T& c) {
171 std::vector<T> in;
172 in.push_back(a);
173 in.push_back(b);
174 in.push_back(c);
175 return in;
176 }
177 template <typename T>
JsonVecOf3(const T & a,const T & b,const T & c)178 Json::Value JsonVecOf3(const T& a, const T& b, const T& c) {
179 Json::Value in(Json::arrayValue);
180 in.append(a);
181 in.append(b);
182 in.append(c);
183 return in;
184 }
185 } // unnamed namespace
186
TEST(JsonTest,ValueVectorToFromArray)187 TEST(JsonTest, ValueVectorToFromArray) {
188 std::vector<Json::Value> in = VecOf3<Json::Value>("a", "b", "c");
189 Json::Value out = ValueVectorToJsonArray(in);
190 EXPECT_EQ(in.size(), out.size());
191 for (Json::Value::ArrayIndex i = 0; i < in.size(); ++i) {
192 EXPECT_EQ(in[i].asString(), out[i].asString());
193 }
194 Json::Value inj = JsonVecOf3<Json::Value>("a", "b", "c");
195 EXPECT_EQ(inj, out);
196 std::vector<Json::Value> outj;
197 EXPECT_TRUE(JsonArrayToValueVector(inj, &outj));
198 for (Json::Value::ArrayIndex i = 0; i < in.size(); i++) {
199 EXPECT_EQ(in[i], outj[i]);
200 }
201 }
202
TEST(JsonTest,IntVectorToFromArray)203 TEST(JsonTest, IntVectorToFromArray) {
204 std::vector<int> in = VecOf3<int>(1, 2, 3);
205 Json::Value out = IntVectorToJsonArray(in);
206 EXPECT_EQ(in.size(), out.size());
207 for (Json::Value::ArrayIndex i = 0; i < in.size(); ++i) {
208 EXPECT_EQ(in[i], out[i].asInt());
209 }
210 Json::Value inj = JsonVecOf3<int>(1, 2, 3);
211 EXPECT_EQ(inj, out);
212 std::vector<int> outj;
213 EXPECT_TRUE(JsonArrayToIntVector(inj, &outj));
214 for (Json::Value::ArrayIndex i = 0; i < in.size(); i++) {
215 EXPECT_EQ(in[i], outj[i]);
216 }
217 }
218
TEST(JsonTest,UIntVectorToFromArray)219 TEST(JsonTest, UIntVectorToFromArray) {
220 std::vector<unsigned int> in = VecOf3<unsigned int>(1, 2, 3);
221 Json::Value out = UIntVectorToJsonArray(in);
222 EXPECT_EQ(in.size(), out.size());
223 for (Json::Value::ArrayIndex i = 0; i < in.size(); ++i) {
224 EXPECT_EQ(in[i], out[i].asUInt());
225 }
226 Json::Value inj = JsonVecOf3<unsigned int>(1, 2, 3);
227 EXPECT_EQ(inj, out);
228 std::vector<unsigned int> outj;
229 EXPECT_TRUE(JsonArrayToUIntVector(inj, &outj));
230 for (Json::Value::ArrayIndex i = 0; i < in.size(); i++) {
231 EXPECT_EQ(in[i], outj[i]);
232 }
233 }
234
TEST(JsonTest,StringVectorToFromArray)235 TEST(JsonTest, StringVectorToFromArray) {
236 std::vector<std::string> in = VecOf3<std::string>("a", "b", "c");
237 Json::Value out = StringVectorToJsonArray(in);
238 EXPECT_EQ(in.size(), out.size());
239 for (Json::Value::ArrayIndex i = 0; i < in.size(); ++i) {
240 EXPECT_EQ(in[i], out[i].asString());
241 }
242 Json::Value inj = JsonVecOf3<std::string>("a", "b", "c");
243 EXPECT_EQ(inj, out);
244 std::vector<std::string> outj;
245 EXPECT_TRUE(JsonArrayToStringVector(inj, &outj));
246 for (Json::Value::ArrayIndex i = 0; i < in.size(); i++) {
247 EXPECT_EQ(in[i], outj[i]);
248 }
249 }
250
TEST(JsonTest,BoolVectorToFromArray)251 TEST(JsonTest, BoolVectorToFromArray) {
252 std::vector<bool> in = VecOf3<bool>(false, true, false);
253 Json::Value out = BoolVectorToJsonArray(in);
254 EXPECT_EQ(in.size(), out.size());
255 for (Json::Value::ArrayIndex i = 0; i < in.size(); ++i) {
256 EXPECT_EQ(in[i], out[i].asBool());
257 }
258 Json::Value inj = JsonVecOf3<bool>(false, true, false);
259 EXPECT_EQ(inj, out);
260 std::vector<bool> outj;
261 EXPECT_TRUE(JsonArrayToBoolVector(inj, &outj));
262 for (Json::Value::ArrayIndex i = 0; i < in.size(); i++) {
263 EXPECT_EQ(in[i], outj[i]);
264 }
265 }
266
TEST(JsonTest,DoubleVectorToFromArray)267 TEST(JsonTest, DoubleVectorToFromArray) {
268 std::vector<double> in = VecOf3<double>(1.0, 2.0, 3.0);
269 Json::Value out = DoubleVectorToJsonArray(in);
270 EXPECT_EQ(in.size(), out.size());
271 for (Json::Value::ArrayIndex i = 0; i < in.size(); ++i) {
272 EXPECT_EQ(in[i], out[i].asDouble());
273 }
274 Json::Value inj = JsonVecOf3<double>(1.0, 2.0, 3.0);
275 EXPECT_EQ(inj, out);
276 std::vector<double> outj;
277 EXPECT_TRUE(JsonArrayToDoubleVector(inj, &outj));
278 for (Json::Value::ArrayIndex i = 0; i < in.size(); i++) {
279 EXPECT_EQ(in[i], outj[i]);
280 }
281 }
282
283 } // namespace rtc
284