2 * Copyright 2016 Facebook, Inc.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 // @author Nicholas Ormrod <njormrod@fb.com>
19 #include <folly/DynamicConverter.h>
22 #include <gtest/gtest.h>
26 using namespace folly;
27 using namespace folly::dynamicconverter_detail;
29 TEST(DynamicConverter, template_metaprogramming) {
32 bool c1f = is_container<int>::value;
33 bool c2f = is_container<std::pair<int, int>>::value;
34 bool c3f = is_container<A>::value;
35 bool c4f = class_is_container<A>::value;
37 bool c1t = is_container<std::vector<int>>::value;
38 bool c2t = is_container<std::set<int>>::value;
39 bool c3t = is_container<std::map<int, int>>::value;
40 bool c4t = class_is_container<std::vector<A>>::value;
42 EXPECT_EQ(c1f, false);
43 EXPECT_EQ(c2f, false);
44 EXPECT_EQ(c3f, false);
45 EXPECT_EQ(c4f, false);
52 bool m1f = is_map<int>::value;
53 bool m2f = is_map<std::set<int>>::value;
55 bool m1t = is_map<std::map<int, int>>::value;
57 EXPECT_EQ(m1f, false);
58 EXPECT_EQ(m2f, false);
62 bool r1f = is_range<int>::value;
64 bool r1t = is_range<std::set<int>>::value;
65 bool r2t = is_range<std::vector<int>>::value;
67 EXPECT_EQ(r1f, false);
72 TEST(DynamicConverter, arithmetic_types) {
74 auto i1 = convertTo<int>(d1);
77 dynamic d2 = 123456789012345;
78 auto i2 = convertTo<int64_t>(d2);
79 EXPECT_EQ(i2, 123456789012345);
82 auto i4 = convertTo<float>(d4);
83 EXPECT_EQ((int)(i4*100), 314);
86 auto i5 = convertTo<bool>(d5);
90 const auto i6 = convertTo<const int>(d6);
94 auto i7 = convertTo<int>(d7);
98 auto i8 = convertTo<bool>(d8);
102 TEST(DynamicConverter, enums) {
103 enum enum1 { foo = 1, bar = 2 };
106 auto i1 = convertTo<enum1>(d1);
110 auto i2 = convertTo<enum1>(d2);
113 enum class enum2 { FOO = 1, BAR = 2 };
116 auto i3 = convertTo<enum2>(d3);
117 EXPECT_EQ(i3, enum2::FOO);
120 auto i4 = convertTo<enum2>(d4);
121 EXPECT_EQ(i4, enum2::BAR);
124 TEST(DynamicConverter, simple_builtins) {
125 dynamic d1 = "Haskell";
126 auto i1 = convertTo<folly::fbstring>(d1);
127 EXPECT_EQ(i1, "Haskell");
130 auto i2 = convertTo<std::string>(d2);
133 dynamic d3 = dynamic::array(12, "Scala");
134 auto i3 = convertTo<std::pair<int, std::string>>(d3);
135 EXPECT_EQ(i3.first, 12);
136 EXPECT_EQ(i3.second, "Scala");
138 dynamic d4 = dynamic::object("C", "C++");
139 auto i4 = convertTo<std::pair<std::string, folly::fbstring>>(d4);
140 EXPECT_EQ(i4.first, "C");
141 EXPECT_EQ(i4.second, "C++");
144 TEST(DynamicConverter, simple_fbvector) {
145 dynamic d1 = dynamic::array(1, 2, 3);
146 auto i1 = convertTo<folly::fbvector<int>>(d1);
147 decltype(i1) i1b = { 1, 2, 3 };
151 TEST(DynamicConverter, simple_container) {
152 dynamic d1 = dynamic::array(1, 2, 3);
153 auto i1 = convertTo<std::vector<int>>(d1);
154 decltype(i1) i1b = { 1, 2, 3 };
157 dynamic d2 = dynamic::array(1, 3, 5, 2, 4);
158 auto i2 = convertTo<std::set<int>>(d2);
159 decltype(i2) i2b = { 1, 2, 3, 5, 4 };
163 TEST(DynamicConverter, simple_map) {
164 dynamic d1 = dynamic::object(1, "one")(2, "two");
165 auto i1 = convertTo<std::map<int, std::string>>(d1);
166 decltype(i1) i1b = { { 1, "one" }, { 2, "two" } };
169 dynamic d2 = dynamic::array(dynamic::array(3, "three"),
170 dynamic::array(4, "four"));
171 auto i2 = convertTo<std::unordered_map<int, std::string>>(d2);
172 decltype(i2) i2b = { { 3, "three" }, { 4, "four" } };
176 TEST(DynamicConverter, map_keyed_by_string) {
177 dynamic d1 = dynamic::object("1", "one")("2", "two");
178 auto i1 = convertTo<std::map<std::string, std::string>>(d1);
179 decltype(i1) i1b = { { "1", "one" }, { "2", "two" } };
182 dynamic d2 = dynamic::array(dynamic::array("3", "three"),
183 dynamic::array("4", "four"));
184 auto i2 = convertTo<std::unordered_map<std::string, std::string>>(d2);
185 decltype(i2) i2b = { { "3", "three" }, { "4", "four" } };
189 TEST(DynamicConverter, map_to_vector_of_pairs) {
190 dynamic d1 = dynamic::object("1", "one")("2", "two");
191 auto i1 = convertTo<std::vector<std::pair<std::string, std::string>>>(d1);
192 std::sort(i1.begin(), i1.end());
193 decltype(i1) i1b = { { "1", "one" }, { "2", "two" } };
197 TEST(DynamicConverter, nested_containers) {
198 dynamic d1 = dynamic::array(dynamic::array(1),
200 dynamic::array(2, 3));
201 auto i1 = convertTo<folly::fbvector<std::vector<uint8_t>>>(d1);
202 decltype(i1) i1b = { { 1 }, { }, { 2, 3 } };
205 dynamic h2a = dynamic::array("3", ".", "1", "4");
206 dynamic h2b = dynamic::array("2", ".", "7", "2");
207 dynamic d2 = dynamic::object(3.14, h2a)(2.72, h2b);
208 auto i2 = convertTo<std::map<double, std::vector<folly::fbstring>>>(d2);
210 { { 3.14, { "3", ".", "1", "4" } },
211 { 2.72, { "2", ".", "7", "2" } } };
217 bool operator==(const A & o) const { return i == o.i; }
220 template <> struct DynamicConverter<A> {
221 static A convert(const dynamic & d) {
222 return { convertTo<int>(d["i"]) };
226 TEST(DynamicConverter, custom_class) {
227 dynamic d1 = dynamic::object("i", 17);
228 auto i1 = convertTo<A>(d1);
231 dynamic d2 = dynamic::array(dynamic::object("i", 18),
232 dynamic::object("i", 19));
233 auto i2 = convertTo<std::vector<A>>(d2);
234 decltype(i2) i2b = { { 18 }, { 19 } };
238 TEST(DynamicConverter, crazy) {
239 // we are going to create a vector<unordered_map<bool, T>>
240 // we will construct some of the maps from dynamic objects,
241 // some from a vector of KV pairs.
242 // T will be vector<set<string>>
244 std::set<std::string>
245 s1 = { "a", "e", "i", "o", "u" },
246 s2 = { "2", "3", "5", "7" },
247 s3 = { "Hello", "World" };
249 std::vector<std::set<std::string>>
254 std::unordered_map<bool, std::vector<std::set<std::string>>>
255 m1 = { { true, v1 }, { false, v2 } },
256 m2 = { { true, v3 } };
258 std::vector<std::unordered_map<bool, std::vector<std::set<std::string>>>>
263 ds1 = dynamic::array("a", "e", "i", "o", "u"),
264 ds2 = dynamic::array("2", "3", "5", "7"),
265 ds3 = dynamic::array("Hello", "World");
268 dv1 = dynamic::array,
269 dv2 = dynamic::array(ds1, ds2),
270 dv3(dynamic::array(ds3));
273 dm1 = dynamic::object(true, dv1)(false, dv2),
274 dm2 = dynamic::array(dynamic::array(true, dv3));
277 df1 = dynamic::array(dm1, dm2);
280 auto i = convertTo<std::vector<std::unordered_map<bool, std::vector<
281 std::set<std::string>>>>>(df1); // yes, that is 5 close-chevrons
286 TEST(DynamicConverter, consts) {
288 auto i1 = convertTo<const double>(d1);
291 dynamic d2 = "Hello";
292 auto i2 = convertTo<const std::string>(d2);
293 decltype(i2) i2b = "Hello";
297 auto i3 = convertTo<const bool>(d3);
301 auto i4 = convertTo<const bool>(d4);
304 dynamic d5 = dynamic::array(1, 2);
305 auto i5 = convertTo<const std::pair<const int, const int>>(d5);
306 decltype(i5) i5b = { 1, 2 };
314 explicit Token(int kind, const fbstring& lexeme)
315 : kind_(kind), lexeme_(lexeme) {}
319 template <> struct DynamicConverter<Token> {
320 static Token convert(const dynamic& d) {
321 int k = convertTo<int>(d["KIND"]);
322 fbstring lex = convertTo<fbstring>(d["LEXEME"]);
323 return Token(k, lex);
328 TEST(DynamicConverter, example) {
329 dynamic d1 = dynamic::object("KIND", 2)("LEXEME", "a token");
330 auto i1 = convertTo<Token>(d1);
331 EXPECT_EQ(i1.kind_, 2);
332 EXPECT_EQ(i1.lexeme_, "a token");
335 TEST(DynamicConverter, construct) {
341 vector<int> c { 1, 2, 3 };
342 dynamic d = dynamic::array(1, 2, 3);
343 EXPECT_EQ(d, toDynamic(c));
347 vector<float> c{1.0f, 2.0f, 4.0f};
348 dynamic d = dynamic::array(1.0, 2.0, 4.0);
349 EXPECT_EQ(d, toDynamic(c));
353 map<int, int> c { { 2, 4 }, { 3, 9 } };
354 dynamic d = dynamic::object(2, 4)(3, 9);
355 EXPECT_EQ(d, toDynamic(c));
359 map<string, string> c { { "a", "b" } };
360 dynamic d = dynamic::object("a", "b");
361 EXPECT_EQ(d, toDynamic(c));
365 map<string, pair<string, int>> c { { "a", { "b", 3 } } };
366 dynamic d = dynamic::object("a", dynamic::array("b", 3));
367 EXPECT_EQ(d, toDynamic(c));
371 map<string, pair<string, int>> c { { "a", { "b", 3 } } };
372 dynamic d = dynamic::object("a", dynamic::array("b", 3));
373 EXPECT_EQ(d, toDynamic(c));
377 vector<int> vi { 2, 3, 4, 5 };
378 auto c = std::make_pair(range(vi.begin(), vi.begin() + 3),
379 range(vi.begin() + 1, vi.begin() + 4));
380 dynamic d = dynamic::array(dynamic::array(2, 3, 4),
381 dynamic::array(3, 4, 5));
382 EXPECT_EQ(d, toDynamic(c));
386 TEST(DynamicConverter, errors) {
387 const auto int32Over =
388 static_cast<int64_t>(std::numeric_limits<int32_t>().max()) + 1;
389 const auto floatOver =
390 static_cast<double>(std::numeric_limits<float>().max()) * 2;
392 dynamic d1 = int32Over;
393 EXPECT_THROW(convertTo<int32_t>(d1), std::range_error);
395 dynamic d2 = floatOver;
396 EXPECT_THROW(convertTo<float>(d2), std::range_error);