folly/test/DynamicConverterTest.cpp

   1 /*
   2  * Copyright 2013 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 // @author Nicholas Ormrod <njormrod@fb.com>
  18
  19 #include "folly/DynamicConverter.h"
  20
  21 #include <algorithm>
  22 #include <gflags/gflags.h>
  23 #include <gtest/gtest.h>
  24 #include <map>
  25 #include <vector>
  26
  27 #include "folly/Benchmark.h"
  28
  29 using namespace folly;
  30 using namespace folly::dynamicconverter_detail;
  31
  32 TEST(DynamicConverter, template_metaprogramming) {
  33   struct A {};
  34
  35   bool c1f = is_container<int>::value;
  36   bool c2f = is_container<std::pair<int, int>>::value;
  37   bool c3f = is_container<A>::value;
  38
  39   bool c1t = is_container<std::vector<int>>::value;
  40   bool c2t = is_container<std::set<int>>::value;
  41   bool c3t = is_container<std::map<int, int>>::value;
  42
  43   EXPECT_EQ(c1f, false);
  44   EXPECT_EQ(c2f, false);
  45   EXPECT_EQ(c3f, false);
  46   EXPECT_EQ(c1t, true);
  47   EXPECT_EQ(c2t, true);
  48   EXPECT_EQ(c3t, true);
  49
  50
  51   bool m1f = is_map<int>::value;
  52   bool m2f = is_map<std::set<int>>::value;
  53
  54   bool m1t = is_map<std::map<int, int>>::value;
  55
  56   EXPECT_EQ(m1f, false);
  57   EXPECT_EQ(m2f, false);
  58   EXPECT_EQ(m1t, true);
  59
  60
  61   bool r1f = is_range<int>::value;
  62
  63   bool r1t = is_range<std::set<int>>::value;
  64   bool r2t = is_range<std::vector<int>>::value;
  65
  66   EXPECT_EQ(r1f, false);
  67   EXPECT_EQ(r1t, true);
  68   EXPECT_EQ(r2t, true);
  69 }
  70
  71 TEST(DynamicConverter, arithmetic_types) {
  72   dynamic d1 = 12;
  73   auto i1 = convertTo<int>(d1);
  74   EXPECT_EQ(i1, 12);
  75
  76   dynamic d2 = 123456789012345;
  77   auto i2 = convertTo<int64_t>(d2);
  78   EXPECT_EQ(i2, 123456789012345);
  79
  80   dynamic d4 = 3.141;
  81   auto i4 = convertTo<float>(d4);
  82   EXPECT_EQ((int)(i4*100), 314);
  83
  84   dynamic d5 = true;
  85   auto i5 = convertTo<bool>(d5);
  86   EXPECT_EQ(i5, true);
  87
  88   dynamic d6 = 15;
  89   const auto i6 = convertTo<const int>(d6);
  90   EXPECT_EQ(i6, 15);
  91
  92   dynamic d7 = "87";
  93   auto i7 = convertTo<int>(d7);
  94   EXPECT_EQ(i7, 87);
  95
  96   dynamic d8 = "false";
  97   auto i8 = convertTo<bool>(d8);
  98   EXPECT_EQ(i8, false);
  99 }
 100
 101 TEST(DynamicConverter, simple_builtins) {
 102   dynamic d1 = "Haskell";
 103   auto i1 = convertTo<folly::fbstring>(d1);
 104   EXPECT_EQ(i1, "Haskell");
 105
 106   dynamic d2 = 13;
 107   auto i2 = convertTo<std::string>(d2);
 108   EXPECT_EQ(i2, "13");
 109
 110   dynamic d3 = { 12, "Scala" };
 111   auto i3 = convertTo<std::pair<int, std::string>>(d3);
 112   EXPECT_EQ(i3.first, 12);
 113   EXPECT_EQ(i3.second, "Scala");
 114
 115   dynamic d4 = dynamic::object("C", "C++");
 116   auto i4 = convertTo<std::pair<std::string, folly::fbstring>>(d4);
 117   EXPECT_EQ(i4.first, "C");
 118   EXPECT_EQ(i4.second, "C++");
 119 }
 120
 121 TEST(DynamicConverter, simple_fbvector) {
 122   dynamic d1 = { 1, 2, 3 };
 123   auto i1 = convertTo<folly::fbvector<int>>(d1);
 124   decltype(i1) i1b = { 1, 2, 3 };
 125   EXPECT_EQ(i1, i1b);
 126 }
 127
 128 TEST(DynamicConverter, simple_container) {
 129   dynamic d1 = { 1, 2, 3 };
 130   auto i1 = convertTo<std::vector<int>>(d1);
 131   decltype(i1) i1b = { 1, 2, 3 };
 132   EXPECT_EQ(i1, i1b);
 133
 134   dynamic d2 = { 1, 3, 5, 2, 4 };
 135   auto i2 = convertTo<std::set<int>>(d2);
 136   decltype(i2) i2b = { 1, 2, 3, 5, 4 };
 137   EXPECT_EQ(i2, i2b);
 138 }
 139
 140 TEST(DynamicConverter, simple_map) {
 141   dynamic d1 = dynamic::object(1, "one")(2, "two");
 142   auto i1 = convertTo<std::map<int, std::string>>(d1);
 143   decltype(i1) i1b = { { 1, "one" }, { 2, "two" } };
 144   EXPECT_EQ(i1, i1b);
 145
 146   dynamic d2 = { { 3, "three" }, { 4, "four" } };
 147   auto i2 = convertTo<std::unordered_map<int, std::string>>(d2);
 148   decltype(i2) i2b = { { 3, "three" }, { 4, "four" } };
 149   EXPECT_EQ(i2, i2b);
 150 }
 151
 152 TEST(DynamicConverter, map_keyed_by_string) {
 153   dynamic d1 = dynamic::object("1", "one")("2", "two");
 154   auto i1 = convertTo<std::map<std::string, std::string>>(d1);
 155   decltype(i1) i1b = { { "1", "one" }, { "2", "two" } };
 156   EXPECT_EQ(i1, i1b);
 157
 158   dynamic d2 = { { "3", "three" }, { "4", "four" } };
 159   auto i2 = convertTo<std::unordered_map<std::string, std::string>>(d2);
 160   decltype(i2) i2b = { { "3", "three" }, { "4", "four" } };
 161   EXPECT_EQ(i2, i2b);
 162 }
 163
 164 TEST(DynamicConverter, map_to_vector_of_pairs) {
 165   dynamic d1 = dynamic::object("1", "one")("2", "two");
 166   auto i1 = convertTo<std::vector<std::pair<std::string, std::string>>>(d1);
 167   std::sort(i1.begin(), i1.end());
 168   decltype(i1) i1b = { { "1", "one" }, { "2", "two" } };
 169   EXPECT_EQ(i1, i1b);
 170 }
 171
 172 TEST(DynamicConverter, nested_containers) {
 173   dynamic d1 = { { 1 }, { }, { 2, 3 } };
 174   auto i1 = convertTo<folly::fbvector<std::vector<uint8_t>>>(d1);
 175   decltype(i1) i1b = { { 1 }, { }, { 2, 3 } };
 176   EXPECT_EQ(i1, i1b);
 177
 178   dynamic h2a = { "3", ".", "1", "4" };
 179   dynamic h2b = { "2", ".", "7", "2" };
 180   dynamic d2 = dynamic::object(3.14, h2a)(2.72, h2b);
 181   auto i2 = convertTo<std::map<double, std::vector<folly::fbstring>>>(d2);
 182   decltype(i2) i2b =
 183     { { 3.14, { "3", ".", "1", "4" } },
 184       { 2.72, { "2", ".", "7", "2" } } };
 185   EXPECT_EQ(i2, i2b);
 186 }
 187
 188 struct A {
 189   int i;
 190   bool operator==(const A & o) const { return i == o.i; }
 191 };
 192 namespace folly {
 193 template <> struct DynamicConverter<A> {
 194   static A convert(const dynamic & d) {
 195     return { convertTo<int>(d["i"]) };
 196   }
 197 };
 198 }
 199 TEST(DynamicConverter, custom_class) {
 200   dynamic d1 = dynamic::object("i", 17);
 201   auto i1 = convertTo<A>(d1);
 202   EXPECT_EQ(i1.i, 17);
 203
 204   dynamic d2 = { dynamic::object("i", 18), dynamic::object("i", 19) };
 205   auto i2 = convertTo<std::vector<A>>(d2);
 206   decltype(i2) i2b = { { 18 }, { 19 } };
 207   EXPECT_EQ(i2, i2b);
 208 }
 209
 210 TEST(DynamicConverter, crazy) {
 211   // we are going to create a vector<unordered_map<bool, T>>
 212   // we will construct some of the maps from dynamic objects,
 213   //   some from a vector of KV pairs.
 214   // T will be vector<set<string>>
 215
 216   std::set<std::string>
 217     s1 = { "a", "e", "i", "o", "u" },
 218     s2 = { "2", "3", "5", "7" },
 219     s3 = { "Hello", "World" };
 220
 221   std::vector<std::set<std::string>>
 222     v1 = {},
 223     v2 = { s1, s2 },
 224     v3 = { s3 };
 225
 226   std::unordered_map<bool, std::vector<std::set<std::string>>>
 227     m1 = { { true, v1 }, { false, v2 } },
 228     m2 = { { true, v3 } };
 229
 230   std::vector<std::unordered_map<bool, std::vector<std::set<std::string>>>>
 231     f1 = { m1, m2 };
 232
 233
 234   dynamic
 235     ds1 = { "a", "e", "i", "o", "u" },
 236     ds2 = { "2", "3", "5", "7" },
 237     ds3 = { "Hello", "World" };
 238
 239   dynamic
 240     dv1 = {},
 241     dv2 = { ds1, ds2 },
 242     dv3 = { ds3 };
 243
 244   dynamic
 245     dm1 = dynamic::object(true, dv1)(false, dv2),
 246     dm2 = { { true, dv3 } };
 247
 248   dynamic
 249     df1 = { dm1, dm2 };
 250
 251
 252   auto i = convertTo<std::vector<std::unordered_map<bool, std::vector<
 253           std::set<std::string>>>>>(df1); // yes, that is 5 close-chevrons
 254
 255   EXPECT_EQ(f1, i);
 256 }
 257
 258 TEST(DynamicConverter, consts) {
 259   dynamic d1 = 7.5;
 260   auto i1 = convertTo<const double>(d1);
 261   EXPECT_EQ(7.5, i1);
 262
 263   dynamic d2 = "Hello";
 264   auto i2 = convertTo<const std::string>(d2);
 265   decltype(i2) i2b = "Hello";
 266   EXPECT_EQ(i2b, i2);
 267
 268   dynamic d3 = true;
 269   auto i3 = convertTo<const bool>(d3);
 270   EXPECT_EQ(true, i3);
 271
 272   dynamic d4 = "true";
 273   auto i4 = convertTo<const bool>(d4);
 274   EXPECT_EQ(true, i4);
 275
 276   dynamic d5 = { 1, 2 };
 277   auto i5 = convertTo<const std::pair<const int, const int>>(d5);
 278   decltype(i5) i5b = { 1, 2 };
 279   EXPECT_EQ(i5b, i5);
 280 }
 281
 282 struct Token {
 283   int kind_;
 284   fbstring lexeme_;
 285
 286   explicit Token(int kind, const fbstring& lexeme)
 287     : kind_(kind), lexeme_(lexeme) {}
 288 };
 289
 290 namespace folly {
 291 template <> struct DynamicConverter<Token> {
 292   static Token convert(const dynamic& d) {
 293     int k = convertTo<int>(d["KIND"]);
 294     fbstring lex = convertTo<fbstring>(d["LEXEME"]);
 295     return Token(k, lex);
 296   }
 297 };
 298 }
 299
 300 TEST(DynamicConverter, example) {
 301   dynamic d1 = dynamic::object("KIND", 2)("LEXEME", "a token");
 302   auto i1 = convertTo<Token>(d1);
 303   EXPECT_EQ(i1.kind_, 2);
 304   EXPECT_EQ(i1.lexeme_, "a token");
 305 }
 306
 307 TEST(DynamicConverter, construct) {
 308   using std::vector;
 309   using std::map;
 310   using std::pair;
 311   using std::string;
 312   {
 313     vector<int> c { 1, 2, 3 };
 314     dynamic d = { 1, 2, 3 };
 315     EXPECT_EQ(d, toDynamic(c));
 316   }
 317
 318   {
 319     map<int, int> c { { 2, 4 }, { 3, 9 } };
 320     dynamic d = dynamic::object(2, 4)(3, 9);
 321     EXPECT_EQ(d, toDynamic(c));
 322   }
 323
 324   {
 325     map<string, string> c { { "a", "b" } };
 326     dynamic d = dynamic::object("a", "b");
 327     EXPECT_EQ(d, toDynamic(c));
 328   }
 329
 330   {
 331     map<string, pair<string, int>> c { { "a", { "b", 3 } } };
 332     dynamic d = dynamic::object("a", dynamic { "b", 3 });
 333     EXPECT_EQ(d, toDynamic(c));
 334   }
 335
 336   {
 337     map<string, pair<string, int>> c { { "a", { "b", 3 } } };
 338     dynamic d = dynamic::object("a", dynamic { "b", 3 });
 339     EXPECT_EQ(d, toDynamic(c));
 340   }
 341
 342   {
 343     vector<int> vi { 2, 3, 4, 5 };
 344     auto c = std::make_pair(makeRange(vi.begin(), vi.begin() + 3),
 345                             makeRange(vi.begin() + 1, vi.begin() + 4));
 346     dynamic d = { { 2, 3, 4 }, { 3, 4, 5 } };
 347     EXPECT_EQ(d, toDynamic(c));
 348   }
 349 }
 350
 351 TEST(DynamicConverter, errors) {
 352   const auto int32Over =
 353     static_cast<int64_t>(std::numeric_limits<int32_t>().max()) + 1;
 354   const auto floatOver =
 355     static_cast<double>(std::numeric_limits<float>().max()) * 2;
 356
 357   dynamic d1 = int32Over;
 358   EXPECT_THROW(convertTo<int32_t>(d1), std::range_error);
 359
 360   dynamic d2 = floatOver;
 361   EXPECT_THROW(convertTo<float>(d2), std::range_error);
 362 }
 363
 364 int main(int argc, char ** argv) {
 365   testing::InitGoogleTest(&argc, argv);
 366   google::ParseCommandLineFlags(&argc, &argv, true);
 367   if (FLAGS_benchmark) {
 368     folly::runBenchmarks();
 369   }
 370   return RUN_ALL_TESTS();
 371 }
 372