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
17namespace rtc {
18
19static Json::Value in_s("foo");
20static Json::Value in_sn("99");
21static Json::Value in_si("-99");
22static Json::Value in_sb("true");
23static Json::Value in_sd("1.2");
24static Json::Value in_n(12);
25static Json::Value in_i(-12);
26static Json::Value in_u(34U);
27static Json::Value in_b(true);
28static Json::Value in_d(1.2);
29static Json::Value big_sn("12345678901234567890");
30static Json::Value big_si("-12345678901234567890");
31static Json::Value big_u(0xFFFFFFFF);
32static Json::Value bad_a(Json::arrayValue);
33static Json::Value bad_o(Json::objectValue);
34
35TEST(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
56TEST(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
78TEST(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
100TEST(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
123TEST(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
144TEST(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
156TEST(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
168namespace {
169template <typename T>
170std::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}
177template <typename T>
178Json::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
187TEST(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
203TEST(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
219TEST(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
235TEST(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
251TEST(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
267TEST(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