src/third_party/libjingle/source/talk/base/json_unittest.cc

   1 /*
   2  * libjingle
   3  * Copyright 2009, Google Inc.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are met:
   7  *
   8  *  1. Redistributions of source code must retain the above copyright notice,
   9  *     this list of conditions and the following disclaimer.
  10  *  2. Redistributions in binary form must reproduce the above copyright notice,
  11  *     this list of conditions and the following disclaimer in the documentation
  12  *     and/or other materials provided with the distribution.
  13  *  3. The name of the author may not be used to endorse or promote products
  14  *     derived from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  18  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  19  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  20  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include <vector>
  29 #include "talk/base/gunit.h"
  30 #include "talk/base/json.h"
  31
  32 static Json::Value in_s("foo");
  33 static Json::Value in_sn("99");
  34 static Json::Value in_si("-99");
  35 static Json::Value in_sb("true");
  36 static Json::Value in_sd("1.2");
  37 static Json::Value in_n(12);
  38 static Json::Value in_i(-12);
  39 static Json::Value in_u(34U);
  40 static Json::Value in_b(true);
  41 static Json::Value in_d(1.2);
  42 static Json::Value big_sn("12345678901234567890");
  43 static Json::Value big_si("-12345678901234567890");
  44 static Json::Value big_u(0xFFFFFFFF);
  45 static Json::Value bad_a(Json::arrayValue);
  46 static Json::Value bad_o(Json::objectValue);
  47
  48 TEST(JsonTest, GetString) {
  49   std::string out;
  50   EXPECT_TRUE(GetStringFromJson(in_s, &out));
  51   EXPECT_EQ("foo", out);
  52   EXPECT_TRUE(GetStringFromJson(in_sn, &out));
  53   EXPECT_EQ("99", out);
  54   EXPECT_TRUE(GetStringFromJson(in_si, &out));
  55   EXPECT_EQ("-99", out);
  56   EXPECT_TRUE(GetStringFromJson(in_i, &out));
  57   EXPECT_EQ("-12", out);
  58   EXPECT_TRUE(GetStringFromJson(in_n, &out));
  59   EXPECT_EQ("12", out);
  60   EXPECT_TRUE(GetStringFromJson(in_u, &out));
  61   EXPECT_EQ("34", out);
  62   EXPECT_TRUE(GetStringFromJson(in_b, &out));
  63   EXPECT_EQ("true", out);
  64   // Not supported here yet.
  65   EXPECT_FALSE(GetStringFromJson(bad_a, &out));
  66   EXPECT_FALSE(GetStringFromJson(bad_o, &out));
  67 }
  68
  69 TEST(JsonTest, GetInt) {
  70   int out;
  71   EXPECT_TRUE(GetIntFromJson(in_sn, &out));
  72   EXPECT_EQ(99, out);
  73   EXPECT_TRUE(GetIntFromJson(in_si, &out));
  74   EXPECT_EQ(-99, out);
  75   EXPECT_TRUE(GetIntFromJson(in_n, &out));
  76   EXPECT_EQ(12, out);
  77   EXPECT_TRUE(GetIntFromJson(in_i, &out));
  78   EXPECT_EQ(-12, out);
  79   EXPECT_TRUE(GetIntFromJson(in_u, &out));
  80   EXPECT_EQ(34, out);
  81   EXPECT_TRUE(GetIntFromJson(in_b, &out));
  82   EXPECT_EQ(1, out);
  83   EXPECT_FALSE(GetIntFromJson(in_s, &out));
  84   EXPECT_FALSE(GetIntFromJson(big_sn, &out));
  85   EXPECT_FALSE(GetIntFromJson(big_si, &out));
  86   EXPECT_FALSE(GetIntFromJson(big_u, &out));
  87   EXPECT_FALSE(GetIntFromJson(bad_a, &out));
  88   EXPECT_FALSE(GetIntFromJson(bad_o, &out));
  89 }
  90
  91 TEST(JsonTest, GetUInt) {
  92   unsigned int out;
  93   EXPECT_TRUE(GetUIntFromJson(in_sn, &out));
  94   EXPECT_EQ(99U, out);
  95   EXPECT_TRUE(GetUIntFromJson(in_n, &out));
  96   EXPECT_EQ(12U, out);
  97   EXPECT_TRUE(GetUIntFromJson(in_u, &out));
  98   EXPECT_EQ(34U, out);
  99   EXPECT_TRUE(GetUIntFromJson(in_b, &out));
 100   EXPECT_EQ(1U, out);
 101   EXPECT_TRUE(GetUIntFromJson(big_u, &out));
 102   EXPECT_EQ(0xFFFFFFFFU, out);
 103   EXPECT_FALSE(GetUIntFromJson(in_s, &out));
 104   // TODO: Fail reading negative strings.
 105   // EXPECT_FALSE(GetUIntFromJson(in_si, &out));
 106   EXPECT_FALSE(GetUIntFromJson(in_i, &out));
 107   EXPECT_FALSE(GetUIntFromJson(big_sn, &out));
 108   EXPECT_FALSE(GetUIntFromJson(big_si, &out));
 109   EXPECT_FALSE(GetUIntFromJson(bad_a, &out));
 110   EXPECT_FALSE(GetUIntFromJson(bad_o, &out));
 111 }
 112
 113 TEST(JsonTest, GetBool) {
 114   bool out;
 115   EXPECT_TRUE(GetBoolFromJson(in_sb, &out));
 116   EXPECT_EQ(true, out);
 117   EXPECT_TRUE(GetBoolFromJson(in_n, &out));
 118   EXPECT_EQ(true, out);
 119   EXPECT_TRUE(GetBoolFromJson(in_i, &out));
 120   EXPECT_EQ(true, out);
 121   EXPECT_TRUE(GetBoolFromJson(in_u, &out));
 122   EXPECT_EQ(true, out);
 123   EXPECT_TRUE(GetBoolFromJson(in_b, &out));
 124   EXPECT_EQ(true, out);
 125   EXPECT_TRUE(GetBoolFromJson(big_u, &out));
 126   EXPECT_EQ(true, out);
 127   EXPECT_FALSE(GetBoolFromJson(in_s, &out));
 128   EXPECT_FALSE(GetBoolFromJson(in_sn, &out));
 129   EXPECT_FALSE(GetBoolFromJson(in_si, &out));
 130   EXPECT_FALSE(GetBoolFromJson(big_sn, &out));
 131   EXPECT_FALSE(GetBoolFromJson(big_si, &out));
 132   EXPECT_FALSE(GetBoolFromJson(bad_a, &out));
 133   EXPECT_FALSE(GetBoolFromJson(bad_o, &out));
 134 }
 135
 136 TEST(JsonTest, GetDouble) {
 137   double out;
 138   EXPECT_TRUE(GetDoubleFromJson(in_sn, &out));
 139   EXPECT_EQ(99, out);
 140   EXPECT_TRUE(GetDoubleFromJson(in_si, &out));
 141   EXPECT_EQ(-99, out);
 142   EXPECT_TRUE(GetDoubleFromJson(in_sd, &out));
 143   EXPECT_EQ(1.2, out);
 144   EXPECT_TRUE(GetDoubleFromJson(in_n, &out));
 145   EXPECT_EQ(12, out);
 146   EXPECT_TRUE(GetDoubleFromJson(in_i, &out));
 147   EXPECT_EQ(-12, out);
 148   EXPECT_TRUE(GetDoubleFromJson(in_u, &out));
 149   EXPECT_EQ(34, out);
 150   EXPECT_TRUE(GetDoubleFromJson(in_b, &out));
 151   EXPECT_EQ(1, out);
 152   EXPECT_TRUE(GetDoubleFromJson(in_d, &out));
 153   EXPECT_EQ(1.2, out);
 154   EXPECT_FALSE(GetDoubleFromJson(in_s, &out));
 155 }
 156
 157 TEST(JsonTest, GetFromArray) {
 158   Json::Value a, out;
 159   a.append(in_s);
 160   a.append(in_i);
 161   a.append(in_u);
 162   a.append(in_b);
 163   EXPECT_TRUE(GetValueFromJsonArray(a, 0, &out));
 164   EXPECT_TRUE(GetValueFromJsonArray(a, 3, &out));
 165   EXPECT_FALSE(GetValueFromJsonArray(a, 99, &out));
 166   EXPECT_FALSE(GetValueFromJsonArray(a, 0xFFFFFFFF, &out));
 167 }
 168
 169 TEST(JsonTest, GetFromObject) {
 170   Json::Value o, out;
 171   o["string"] = in_s;
 172   o["int"] = in_i;
 173   o["uint"] = in_u;
 174   o["bool"] = in_b;
 175   EXPECT_TRUE(GetValueFromJsonObject(o, "int", &out));
 176   EXPECT_TRUE(GetValueFromJsonObject(o, "bool", &out));
 177   EXPECT_FALSE(GetValueFromJsonObject(o, "foo", &out));
 178   EXPECT_FALSE(GetValueFromJsonObject(o, "", &out));
 179 }
 180
 181 namespace {
 182 template <typename T>
 183 std::vector<T> VecOf3(const T& a, const T& b, const T& c) {
 184   std::vector<T> in;
 185   in.push_back(a);
 186   in.push_back(b);
 187   in.push_back(c);
 188   return in;
 189 }
 190 template <typename T>
 191 Json::Value JsonVecOf3(const T& a, const T& b, const T& c) {
 192   Json::Value in(Json::arrayValue);
 193   in.append(a);
 194   in.append(b);
 195   in.append(c);
 196   return in;
 197 }
 198 }  // unnamed namespace
 199
 200 TEST(JsonTest, ValueVectorToFromArray) {
 201   std::vector<Json::Value> in = VecOf3<Json::Value>("a", "b", "c");
 202   Json::Value out = ValueVectorToJsonArray(in);
 203   EXPECT_EQ(in.size(), out.size());
 204   for (Json::Value::ArrayIndex i = 0; i < in.size(); ++i) {
 205     EXPECT_EQ(in[i].asString(), out[i].asString());
 206   }
 207   Json::Value inj = JsonVecOf3<Json::Value>("a", "b", "c");
 208   EXPECT_EQ(inj, out);
 209   std::vector<Json::Value> outj;
 210   EXPECT_TRUE(JsonArrayToValueVector(inj, &outj));
 211   for (Json::Value::ArrayIndex i = 0; i < in.size(); i++) {
 212     EXPECT_EQ(in[i], outj[i]);
 213   }
 214 }
 215
 216 TEST(JsonTest, IntVectorToFromArray) {
 217   std::vector<int> in = VecOf3<int>(1, 2, 3);
 218   Json::Value out = IntVectorToJsonArray(in);
 219   EXPECT_EQ(in.size(), out.size());
 220   for (Json::Value::ArrayIndex i = 0; i < in.size(); ++i) {
 221     EXPECT_EQ(in[i], out[i].asInt());
 222   }
 223   Json::Value inj = JsonVecOf3<int>(1, 2, 3);
 224   EXPECT_EQ(inj, out);
 225   std::vector<int> outj;
 226   EXPECT_TRUE(JsonArrayToIntVector(inj, &outj));
 227   for (Json::Value::ArrayIndex i = 0; i < in.size(); i++) {
 228     EXPECT_EQ(in[i], outj[i]);
 229   }
 230 }
 231
 232 TEST(JsonTest, UIntVectorToFromArray) {
 233   std::vector<unsigned int> in = VecOf3<unsigned int>(1, 2, 3);
 234   Json::Value out = UIntVectorToJsonArray(in);
 235   EXPECT_EQ(in.size(), out.size());
 236   for (Json::Value::ArrayIndex i = 0; i < in.size(); ++i) {
 237     EXPECT_EQ(in[i], out[i].asUInt());
 238   }
 239   Json::Value inj = JsonVecOf3<unsigned int>(1, 2, 3);
 240   EXPECT_EQ(inj, out);
 241   std::vector<unsigned int> outj;
 242   EXPECT_TRUE(JsonArrayToUIntVector(inj, &outj));
 243   for (Json::Value::ArrayIndex i = 0; i < in.size(); i++) {
 244     EXPECT_EQ(in[i], outj[i]);
 245   }
 246 }
 247
 248 TEST(JsonTest, StringVectorToFromArray) {
 249   std::vector<std::string> in = VecOf3<std::string>("a", "b", "c");
 250   Json::Value out = StringVectorToJsonArray(in);
 251   EXPECT_EQ(in.size(), out.size());
 252   for (Json::Value::ArrayIndex i = 0; i < in.size(); ++i) {
 253     EXPECT_EQ(in[i], out[i].asString());
 254   }
 255   Json::Value inj = JsonVecOf3<std::string>("a", "b", "c");
 256   EXPECT_EQ(inj, out);
 257   std::vector<std::string> outj;
 258   EXPECT_TRUE(JsonArrayToStringVector(inj, &outj));
 259   for (Json::Value::ArrayIndex i = 0; i < in.size(); i++) {
 260     EXPECT_EQ(in[i], outj[i]);
 261   }
 262 }
 263
 264 TEST(JsonTest, BoolVectorToFromArray) {
 265   std::vector<bool> in = VecOf3<bool>(false, true, false);
 266   Json::Value out = BoolVectorToJsonArray(in);
 267   EXPECT_EQ(in.size(), out.size());
 268   for (Json::Value::ArrayIndex i = 0; i < in.size(); ++i) {
 269     EXPECT_EQ(in[i], out[i].asBool());
 270   }
 271   Json::Value inj = JsonVecOf3<bool>(false, true, false);
 272   EXPECT_EQ(inj, out);
 273   std::vector<bool> outj;
 274   EXPECT_TRUE(JsonArrayToBoolVector(inj, &outj));
 275   for (Json::Value::ArrayIndex i = 0; i < in.size(); i++) {
 276     EXPECT_EQ(in[i], outj[i]);
 277   }
 278 }
 279
 280 TEST(JsonTest, DoubleVectorToFromArray) {
 281   std::vector<double> in = VecOf3<double>(1.0, 2.0, 3.0);
 282   Json::Value out = DoubleVectorToJsonArray(in);
 283   EXPECT_EQ(in.size(), out.size());
 284   for (Json::Value::ArrayIndex i = 0; i < in.size(); ++i) {
 285     EXPECT_EQ(in[i], out[i].asDouble());
 286   }
 287   Json::Value inj = JsonVecOf3<double>(1.0, 2.0, 3.0);
 288   EXPECT_EQ(inj, out);
 289   std::vector<double> outj;
 290   EXPECT_TRUE(JsonArrayToDoubleVector(inj, &outj));
 291   for (Json::Value::ArrayIndex i = 0; i < in.size(); i++) {
 292     EXPECT_EQ(in[i], outj[i]);
 293   }
 294 }