X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=folly%2Ftest%2FDynamicConverterTest.cpp;h=1d45e67d787ad2ec9a5525c21599e47bb28a62c8;hb=e88735c87c71aaffd33d559af6aa1a1247dd253d;hp=62417bb38a7dd2d1ce71d729170ca7902fcf6d77;hpb=f6a8fe63f09913d1784f974845dcfdfef3d5b93e;p=folly.git

diff --git a/folly/test/DynamicConverterTest.cpp b/folly/test/DynamicConverterTest.cpp
index 62417bb3..1d45e67d 100644
--- a/folly/test/DynamicConverterTest.cpp
+++ b/folly/test/DynamicConverterTest.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright 2014 Facebook, Inc.
+ * Copyright 2016 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,13 +19,10 @@
 #include <folly/DynamicConverter.h>
 
 #include <algorithm>
-#include <gflags/gflags.h>
 #include <gtest/gtest.h>
 #include <map>
 #include <vector>
 
-#include <folly/Benchmark.h>
-
 using namespace folly;
 using namespace folly::dynamicconverter_detail;
 
@@ -35,17 +32,21 @@ TEST(DynamicConverter, template_metaprogramming) {
   bool c1f = is_container<int>::value;
   bool c2f = is_container<std::pair<int, int>>::value;
   bool c3f = is_container<A>::value;
+  bool c4f = class_is_container<A>::value;
 
   bool c1t = is_container<std::vector<int>>::value;
   bool c2t = is_container<std::set<int>>::value;
   bool c3t = is_container<std::map<int, int>>::value;
+  bool c4t = class_is_container<std::vector<A>>::value;
 
   EXPECT_EQ(c1f, false);
   EXPECT_EQ(c2f, false);
   EXPECT_EQ(c3f, false);
+  EXPECT_EQ(c4f, false);
   EXPECT_EQ(c1t, true);
   EXPECT_EQ(c2t, true);
   EXPECT_EQ(c3t, true);
+  EXPECT_EQ(c4t, true);
 
 
   bool m1f = is_map<int>::value;
@@ -98,6 +99,28 @@ TEST(DynamicConverter, arithmetic_types) {
   EXPECT_EQ(i8, false);
 }
 
+TEST(DynamicConverter, enums) {
+  enum enum1 { foo = 1, bar = 2 };
+
+  dynamic d1 = 1;
+  auto i1 = convertTo<enum1>(d1);
+  EXPECT_EQ(i1, foo);
+
+  dynamic d2 = 2;
+  auto i2 = convertTo<enum1>(d2);
+  EXPECT_EQ(i2, bar);
+
+  enum class enum2 { FOO = 1, BAR = 2 };
+
+  dynamic d3 = 1;
+  auto i3 = convertTo<enum2>(d3);
+  EXPECT_EQ(i3, enum2::FOO);
+
+  dynamic d4 = 2;
+  auto i4 = convertTo<enum2>(d4);
+  EXPECT_EQ(i4, enum2::BAR);
+}
+
 TEST(DynamicConverter, simple_builtins) {
   dynamic d1 = "Haskell";
   auto i1 = convertTo<folly::fbstring>(d1);
@@ -107,7 +130,7 @@ TEST(DynamicConverter, simple_builtins) {
   auto i2 = convertTo<std::string>(d2);
   EXPECT_EQ(i2, "13");
 
-  dynamic d3 = { 12, "Scala" };
+  dynamic d3 = dynamic::array(12, "Scala");
   auto i3 = convertTo<std::pair<int, std::string>>(d3);
   EXPECT_EQ(i3.first, 12);
   EXPECT_EQ(i3.second, "Scala");
@@ -119,19 +142,19 @@ TEST(DynamicConverter, simple_builtins) {
 }
 
 TEST(DynamicConverter, simple_fbvector) {
-  dynamic d1 = { 1, 2, 3 };
+  dynamic d1 = dynamic::array(1, 2, 3);
   auto i1 = convertTo<folly::fbvector<int>>(d1);
   decltype(i1) i1b = { 1, 2, 3 };
   EXPECT_EQ(i1, i1b);
 }
 
 TEST(DynamicConverter, simple_container) {
-  dynamic d1 = { 1, 2, 3 };
+  dynamic d1 = dynamic::array(1, 2, 3);
   auto i1 = convertTo<std::vector<int>>(d1);
   decltype(i1) i1b = { 1, 2, 3 };
   EXPECT_EQ(i1, i1b);
 
-  dynamic d2 = { 1, 3, 5, 2, 4 };
+  dynamic d2 = dynamic::array(1, 3, 5, 2, 4);
   auto i2 = convertTo<std::set<int>>(d2);
   decltype(i2) i2b = { 1, 2, 3, 5, 4 };
   EXPECT_EQ(i2, i2b);
@@ -143,7 +166,8 @@ TEST(DynamicConverter, simple_map) {
   decltype(i1) i1b = { { 1, "one" }, { 2, "two" } };
   EXPECT_EQ(i1, i1b);
 
-  dynamic d2 = { { 3, "three" }, { 4, "four" } };
+  dynamic d2 = dynamic::array(dynamic::array(3, "three"),
+                              dynamic::array(4, "four"));
   auto i2 = convertTo<std::unordered_map<int, std::string>>(d2);
   decltype(i2) i2b = { { 3, "three" }, { 4, "four" } };
   EXPECT_EQ(i2, i2b);
@@ -155,7 +179,8 @@ TEST(DynamicConverter, map_keyed_by_string) {
   decltype(i1) i1b = { { "1", "one" }, { "2", "two" } };
   EXPECT_EQ(i1, i1b);
 
-  dynamic d2 = { { "3", "three" }, { "4", "four" } };
+  dynamic d2 = dynamic::array(dynamic::array("3", "three"),
+                              dynamic::array("4", "four"));
   auto i2 = convertTo<std::unordered_map<std::string, std::string>>(d2);
   decltype(i2) i2b = { { "3", "three" }, { "4", "four" } };
   EXPECT_EQ(i2, i2b);
@@ -170,13 +195,15 @@ TEST(DynamicConverter, map_to_vector_of_pairs) {
 }
 
 TEST(DynamicConverter, nested_containers) {
-  dynamic d1 = { { 1 }, { }, { 2, 3 } };
+  dynamic d1 = dynamic::array(dynamic::array(1),
+                              dynamic::array(),
+                              dynamic::array(2, 3));
   auto i1 = convertTo<folly::fbvector<std::vector<uint8_t>>>(d1);
   decltype(i1) i1b = { { 1 }, { }, { 2, 3 } };
   EXPECT_EQ(i1, i1b);
 
-  dynamic h2a = { "3", ".", "1", "4" };
-  dynamic h2b = { "2", ".", "7", "2" };
+  dynamic h2a = dynamic::array("3", ".", "1", "4");
+  dynamic h2b = dynamic::array("2", ".", "7", "2");
   dynamic d2 = dynamic::object(3.14, h2a)(2.72, h2b);
   auto i2 = convertTo<std::map<double, std::vector<folly::fbstring>>>(d2);
   decltype(i2) i2b =
@@ -201,7 +228,8 @@ TEST(DynamicConverter, custom_class) {
   auto i1 = convertTo<A>(d1);
   EXPECT_EQ(i1.i, 17);
 
-  dynamic d2 = { dynamic::object("i", 18), dynamic::object("i", 19) };
+  dynamic d2 = dynamic::array(dynamic::object("i", 18),
+                              dynamic::object("i", 19));
   auto i2 = convertTo<std::vector<A>>(d2);
   decltype(i2) i2b = { { 18 }, { 19 } };
   EXPECT_EQ(i2, i2b);
@@ -232,21 +260,21 @@ TEST(DynamicConverter, crazy) {
 
 
   dynamic
-    ds1 = { "a", "e", "i", "o", "u" },
-    ds2 = { "2", "3", "5", "7" },
-    ds3 = { "Hello", "World" };
+    ds1 = dynamic::array("a", "e", "i", "o", "u"),
+    ds2 = dynamic::array("2", "3", "5", "7"),
+    ds3 = dynamic::array("Hello", "World");
 
   dynamic
-    dv1 = {},
-    dv2 = { ds1, ds2 },
-    dv3 = { ds3 };
+    dv1 = dynamic::array,
+    dv2 = dynamic::array(ds1, ds2),
+    dv3(dynamic::array(ds3));
 
   dynamic
     dm1 = dynamic::object(true, dv1)(false, dv2),
-    dm2 = { { true, dv3 } };
+    dm2 = dynamic::array(dynamic::array(true, dv3));
 
   dynamic
-    df1 = { dm1, dm2 };
+    df1 = dynamic::array(dm1, dm2);
 
 
   auto i = convertTo<std::vector<std::unordered_map<bool, std::vector<
@@ -273,7 +301,7 @@ TEST(DynamicConverter, consts) {
   auto i4 = convertTo<const bool>(d4);
   EXPECT_EQ(true, i4);
 
-  dynamic d5 = { 1, 2 };
+  dynamic d5 = dynamic::array(1, 2);
   auto i5 = convertTo<const std::pair<const int, const int>>(d5);
   decltype(i5) i5b = { 1, 2 };
   EXPECT_EQ(i5b, i5);
@@ -311,7 +339,13 @@ TEST(DynamicConverter, construct) {
   using std::string;
   {
     vector<int> c { 1, 2, 3 };
-    dynamic d = { 1, 2, 3 };
+    dynamic d = dynamic::array(1, 2, 3);
+    EXPECT_EQ(d, toDynamic(c));
+  }
+
+  {
+    vector<float> c{1.0f, 2.0f, 4.0f};
+    dynamic d = dynamic::array(1.0, 2.0, 4.0);
     EXPECT_EQ(d, toDynamic(c));
   }
 
@@ -329,13 +363,13 @@ TEST(DynamicConverter, construct) {
 
   {
     map<string, pair<string, int>> c { { "a", { "b", 3 } } };
-    dynamic d = dynamic::object("a", dynamic { "b", 3 });
+    dynamic d = dynamic::object("a", dynamic::array("b", 3));
     EXPECT_EQ(d, toDynamic(c));
   }
 
   {
     map<string, pair<string, int>> c { { "a", { "b", 3 } } };
-    dynamic d = dynamic::object("a", dynamic { "b", 3 });
+    dynamic d = dynamic::object("a", dynamic::array("b", 3));
     EXPECT_EQ(d, toDynamic(c));
   }
 
@@ -343,7 +377,8 @@ TEST(DynamicConverter, construct) {
     vector<int> vi { 2, 3, 4, 5 };
     auto c = std::make_pair(range(vi.begin(), vi.begin() + 3),
                             range(vi.begin() + 1, vi.begin() + 4));
-    dynamic d = { { 2, 3, 4 }, { 3, 4, 5 } };
+    dynamic d = dynamic::array(dynamic::array(2, 3, 4),
+                               dynamic::array(3, 4, 5));
     EXPECT_EQ(d, toDynamic(c));
   }
 }
@@ -360,13 +395,3 @@ TEST(DynamicConverter, errors) {
   dynamic d2 = floatOver;
   EXPECT_THROW(convertTo<float>(d2), std::range_error);
 }
-
-int main(int argc, char ** argv) {
-  testing::InitGoogleTest(&argc, argv);
-  gflags::ParseCommandLineFlags(&argc, &argv, true);
-  if (FLAGS_benchmark) {
-    folly::runBenchmarks();
-  }
-  return RUN_ALL_TESTS();
-}
-