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 "webrtc/base/json.h"
12 
13 #include <vector>
14 
15 #include "webrtc/base/gunit.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: 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