folly/test/DynamicConverterTest.cpp

   1 /*
   2  * Copyright 2012 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 #include <gtest/gtest.h>
  21 #include <gflags/gflags.h>
  22 #include "folly/Benchmark.h"
  23
  24 using namespace folly;
  25 using namespace folly::dynamicconverter_detail;
  26
  27 TEST(DynamicConverter, template_metaprogramming) {
  28   struct A {};
  29
  30   bool c1f = is_container<int>::value;
  31   bool c2f = is_container<std::pair<int, int>>::value;
  32   bool c3f = is_container<A>::value;
  33
  34   bool c1t = is_container<std::vector<int>>::value;
  35   bool c2t = is_container<std::set<int>>::value;
  36   bool c3t = is_container<std::map<int, int>>::value;
  37
  38   EXPECT_EQ(c1f, false);
  39   EXPECT_EQ(c2f, false);
  40   EXPECT_EQ(c3f, false);
  41   EXPECT_EQ(c1t, true);
  42   EXPECT_EQ(c2t, true);
  43   EXPECT_EQ(c3t, true);
  44
  45   bool m1f = is_map_container<int>::value;
  46   bool m2f = is_map_container<std::vector<int>>::value;
  47   bool m3f = is_map_container<std::set<int>>::value;
  48
  49   bool m1t = is_map_container<std::map<int, int>>::value;
  50   bool m2t = is_map_container<std::unordered_map<int, int>>::value;
  51
  52   EXPECT_EQ(m1f, false);
  53   EXPECT_EQ(m2f, false);
  54   EXPECT_EQ(m3f, false);
  55   EXPECT_EQ(m1t, true);
  56   EXPECT_EQ(m2t, true);
  57 }
  58
  59 TEST(DynamicConverter, arithmetic_types) {
  60   dynamic d1 = 12;
  61   auto i1 = convertTo<int>(d1);
  62   EXPECT_EQ(i1, 12);
  63
  64   dynamic d2 = 123456789012345;
  65   auto i2 = convertTo<int64_t>(d2);
  66   EXPECT_EQ(i2, 123456789012345);
  67
  68   dynamic d3 = 123456789012345;
  69   auto i3 = convertTo<uint8_t>(d3);
  70   EXPECT_EQ(i3, 121);
  71
  72   dynamic d4 = 3.141;
  73   auto i4 = convertTo<float>(d4);
  74   EXPECT_EQ((int)(i4*100), 314);
  75
  76   dynamic d5 = true;
  77   auto i5 = convertTo<bool>(d5);
  78   EXPECT_EQ(i5, true);
  79
  80   dynamic d6 = 15;
  81   const auto i6 = convertTo<const int>(d6);
  82   EXPECT_EQ(i6, 15);
  83
  84   dynamic d7 = "87";
  85   auto i7 = convertTo<int>(d7);
  86   EXPECT_EQ(i7, 87);
  87
  88   dynamic d8 = "false";
  89   auto i8 = convertTo<bool>(d8);
  90   EXPECT_EQ(i8, false);
  91 }
  92
  93 TEST(DynamicConverter, simple_builtins) {
  94   dynamic d1 = "Haskell";
  95   auto i1 = convertTo<folly::fbstring>(d1);
  96   EXPECT_EQ(i1, "Haskell");
  97
  98   dynamic d2 = 13;
  99   auto i2 = convertTo<std::string>(d2);
 100   EXPECT_EQ(i2, "13");
 101
 102   dynamic d3 = { 12, "Scala" };
 103   auto i3 = convertTo<std::pair<int, std::string>>(d3);
 104   EXPECT_EQ(i3.first, 12);
 105   EXPECT_EQ(i3.second, "Scala");
 106
 107   dynamic d4 = dynamic::object("C", "C++");
 108   auto i4 = convertTo<std::pair<std::string, folly::fbstring>>(d4);
 109   EXPECT_EQ(i4.first, "C");
 110   EXPECT_EQ(i4.second, "C++");
 111 }
 112
 113 TEST(DynamicConverter, simple_fbvector) {
 114   dynamic d1 = { 1, 2, 3 };
 115   auto i1 = convertTo<folly::fbvector<int>>(d1);
 116   decltype(i1) i1b = { 1, 2, 3 };
 117   EXPECT_EQ(i1, i1b);
 118 }
 119
 120 TEST(DynamicConverter, simple_container) {
 121   dynamic d1 = { 1, 2, 3 };
 122   auto i1 = convertTo<std::vector<int>>(d1);
 123   decltype(i1) i1b = { 1, 2, 3 };
 124   EXPECT_EQ(i1, i1b);
 125
 126   dynamic d2 = { 1, 3, 5, 2, 4 };
 127   auto i2 = convertTo<std::set<int>>(d2);
 128   decltype(i2) i2b = { 1, 2, 3, 5, 4 };
 129   EXPECT_EQ(i2, i2b);
 130 }
 131
 132 TEST(DynamicConverter, simple_map) {
 133   dynamic d1 = dynamic::object(1, "one")(2, "two");
 134   auto i1 = convertTo<std::map<int, std::string>>(d1);
 135   decltype(i1) i1b = { { 1, "one" }, { 2, "two" } };
 136   EXPECT_EQ(i1, i1b);
 137
 138   dynamic d2 = { { 3, "three" }, { 4, "four" } };
 139   auto i2 = convertTo<std::unordered_map<int, std::string>>(d2);
 140   decltype(i2) i2b = { { 3, "three" }, { 4, "four" } };
 141   EXPECT_EQ(i2, i2b);
 142 }
 143
 144 TEST(DynamicConverter, nested_containers) {
 145   dynamic d1 = { { 1 }, { }, { 2, 3 } };
 146   auto i1 = convertTo<folly::fbvector<std::vector<uint8_t>>>(d1);
 147   decltype(i1) i1b = { { 1 }, { }, { 2, 3 } };
 148   EXPECT_EQ(i1, i1b);
 149
 150   dynamic h2a = { "3", ".", "1", "4" };
 151   dynamic h2b = { "2", ".", "7", "2" };
 152   dynamic d2 = dynamic::object(3.14, h2a)(2.72, h2b);
 153   auto i2 = convertTo<std::map<double, std::vector<folly::fbstring>>>(d2);
 154   decltype(i2) i2b =
 155     { { 3.14, { "3", ".", "1", "4" } },
 156       { 2.72, { "2", ".", "7", "2" } } };
 157   EXPECT_EQ(i2, i2b);
 158 }
 159
 160 struct A {
 161   int i;
 162   bool operator==(const A & o) const { return i == o.i; }
 163 };
 164 namespace folly {
 165 template <> struct DynamicConverter<A> {
 166   static A convert(const dynamic & d) {
 167     return { convertTo<int>(d["i"]) };
 168   }
 169 };
 170 }
 171 TEST(DynamicConverter, custom_class) {
 172   dynamic d1 = dynamic::object("i", 17);
 173   auto i1 = convertTo<A>(d1);
 174   EXPECT_EQ(i1.i, 17);
 175
 176   dynamic d2 = { dynamic::object("i", 18), dynamic::object("i", 19) };
 177   auto i2 = convertTo<std::vector<A>>(d2);
 178   decltype(i2) i2b = { { 18 }, { 19 } };
 179   EXPECT_EQ(i2, i2b);
 180 }
 181
 182 TEST(DynamicConverter, crazy) {
 183   // we are going to create a vector<unordered_map<bool, T>>
 184   // we will construct some of the maps from dynamic objects,
 185   //   some from a vector of KV pairs.
 186   // T will be vector<set<string>>
 187
 188   std::set<std::string>
 189     s1 = { "a", "e", "i", "o", "u" },
 190     s2 = { "2", "3", "5", "7" },
 191     s3 = { "Hello", "World" };
 192
 193   std::vector<std::set<std::string>>
 194     v1 = {},
 195     v2 = { s1, s2 },
 196     v3 = { s3 };
 197
 198   std::unordered_map<bool, std::vector<std::set<std::string>>>
 199     m1 = { { true, v1 }, { false, v2 } },
 200     m2 = { { true, v3 } };
 201
 202   std::vector<std::unordered_map<bool, std::vector<std::set<std::string>>>>
 203     f1 = { m1, m2 };
 204
 205
 206   dynamic
 207     ds1 = { "a", "e", "i", "o", "u" },
 208     ds2 = { "2", "3", "5", "7" },
 209     ds3 = { "Hello", "World" };
 210
 211   dynamic
 212     dv1 = {},
 213     dv2 = { ds1, ds2 },
 214     dv3 = { ds3 };
 215
 216   dynamic
 217     dm1 = dynamic::object(true, dv1)(false, dv2),
 218     dm2 = { { true, dv3 } };
 219
 220   dynamic
 221     df1 = { dm1, dm2 };
 222
 223
 224   auto i = convertTo<std::vector<std::unordered_map<bool, std::vector<
 225           std::set<std::string>>>>>(df1); // yes, that is 5 close-chevrons
 226
 227   EXPECT_EQ(f1, i);
 228 }
 229
 230 struct Token {
 231   int kind_;
 232   fbstring lexeme_;
 233
 234   explicit Token(int kind, const fbstring& lexeme)
 235     : kind_(kind), lexeme_(lexeme) {}
 236 };
 237 namespace folly {
 238 template <> struct DynamicConverter<Token> {
 239   static Token convert(const dynamic& d) {
 240     int k = convertTo<int>(d["KIND"]);
 241     fbstring lex = convertTo<fbstring>(d["LEXEME"]);
 242     return Token(k, lex);
 243   }
 244 };
 245 }
 246 TEST(DynamicConverter, example) {
 247   dynamic d1 = dynamic::object("KIND", 2)("LEXEME", "a token");
 248   auto i1 = convertTo<Token>(d1);
 249   EXPECT_EQ(i1.kind_, 2);
 250   EXPECT_EQ(i1.lexeme_, "a token");
 251 }
 252
 253 int main(int argc, char ** argv) {
 254   testing::InitGoogleTest(&argc, argv);
 255   google::ParseCommandLineFlags(&argc, &argv, true);
 256   if (FLAGS_benchmark) {
 257     folly::runBenchmarks();
 258   }
 259   return RUN_ALL_TESTS();
 260 }
 261