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