no fancy macros in the enumerate tests

Summary: Avoid the use of fancy macros in the `folly::enumerate` test suite in order to facilitate cmake's gtest integration.

Reviewed By: Orvid

Differential Revision: D26477530

fbshipit-source-id: 1838709e76016c389b052a9523a0681c58b8af96

CMakeLists.txt

@@ -566,9 +566,7 @@ if (BUILD_TESTS)
       TEST access_test SOURCES AccessTest.cpp
       TEST array_test SOURCES ArrayTest.cpp
       TEST bit_iterator_test SOURCES BitIteratorTest.cpp
-      # TODO: CMake's gtest_add_tests() function currently chokes on
-      # EnumerateTest.cpp since it uses macros to define tests.
-      #TEST enumerate_test SOURCES EnumerateTest.cpp
+      TEST enumerate_test SOURCES EnumerateTest.cpp
       TEST evicting_cache_map_test SOURCES EvictingCacheMapTest.cpp
       TEST f14_fwd_test SOURCES F14FwdTest.cpp
       TEST f14_map_test SOURCES F14MapTest.cpp

folly/container/test/EnumerateTest.cpp

@@ -35,70 +35,109 @@ struct IsConstReference<const T&> {
 
 } // namespace
 
-#define ENUMERATE_TEST_BASIC(DECL, NAME)             \
-  TEST(Enumerate, NAME) {                            \
-    std::vector<std::string> v = {"abc", "a", "ab"}; \
-    size_t i = 0;                                    \
-    for (DECL it : folly::enumerate(v)) {            \
-      EXPECT_EQ(it.index, i);                        \
-      EXPECT_EQ(*it, v[i]);                          \
-      EXPECT_EQ(it->size(), v[i].size());            \
-                                                     \
-      /* Test mutability. */                         \
-      std::string newValue = "x";                    \
-      *it = newValue;                                \
-      EXPECT_EQ(newValue, v[i]);                     \
-                                                     \
-      ++i;                                           \
-    }                                                \
-                                                     \
-    EXPECT_EQ(i, v.size());                          \
-  }
-
-ENUMERATE_TEST_BASIC(auto, Basic)
-ENUMERATE_TEST_BASIC(auto&&, BasicRRef)
-
-#undef ENUMERATE_TEST_BASIC
-
-#define ENUMERATE_TEST_BASIC_CONST(DECL, NAME)                          \
-  TEST(Enumerate, NAME) {                                               \
-    std::vector<std::string> v = {"abc", "a", "ab"};                    \
-    size_t i = 0;                                                       \
-    for (DECL it : folly::enumerate(v)) {                               \
-      static_assert(                                                    \
-          IsConstReference<decltype(*it)>::value, "Const enumeration"); \
-      EXPECT_EQ(it.index, i);                                           \
-      EXPECT_EQ(*it, v[i]);                                             \
-      EXPECT_EQ(it->size(), v[i].size());                               \
-      ++i;                                                              \
-    }                                                                   \
-                                                                        \
-    EXPECT_EQ(i, v.size());                                             \
-  }
-
-ENUMERATE_TEST_BASIC_CONST(const auto, BasicConst)
-ENUMERATE_TEST_BASIC_CONST(const auto&, BasicConstRef)
-ENUMERATE_TEST_BASIC_CONST(const auto&&, BasicConstRRef)
-
-#undef ENUMERATE_TEST_BASIC_CONST
-
-#define ENUMERATE_TEST_BASIC_VECTOR_BOOL(DECL, NAME)  \
-  TEST(Enumerate, NAME) {                             \
-    std::vector<bool> v = {true, false, false, true}; \
-    size_t i = 0;                                     \
-    for (DECL it : folly::enumerate(v)) {             \
-      EXPECT_EQ(it.index, i);                         \
-      EXPECT_EQ(*it, v[i]);                           \
-      ++i;                                            \
-    }                                                 \
-                                                      \
-    EXPECT_EQ(i, v.size());                           \
-  }
-
-ENUMERATE_TEST_BASIC_VECTOR_BOOL(auto, BasicVecBool)
-ENUMERATE_TEST_BASIC_VECTOR_BOOL(auto&&, BasicVecBoolRRef)
-
-#undef ENUMERATE_TEST_BASIC_VECTOR_BOOL
+TEST(Enumerate, Basic) {
+  std::vector<std::string> v = {"abc", "a", "ab"};
+  size_t i = 0;
+  for (auto it : folly::enumerate(v)) {
+    EXPECT_EQ(it.index, i);
+    EXPECT_EQ(*it, v[i]);
+    EXPECT_EQ(it->size(), v[i].size());
+
+    /* Test mutability. */
+    std::string newValue = "x";
+    *it = newValue;
+    EXPECT_EQ(newValue, v[i]);
+
+    ++i;
+  }
+
+  EXPECT_EQ(i, v.size());
+}
+
+TEST(Enumerate, BasicRRef) {
+  std::vector<std::string> v = {"abc", "a", "ab"};
+  size_t i = 0;
+  for (auto&& it : folly::enumerate(v)) {
+    EXPECT_EQ(it.index, i);
+    EXPECT_EQ(*it, v[i]);
+    EXPECT_EQ(it->size(), v[i].size());
+
+    /* Test mutability. */
+    std::string newValue = "x";
+    *it = newValue;
+    EXPECT_EQ(newValue, v[i]);
+
+    ++i;
+  }
+
+  EXPECT_EQ(i, v.size());
+}
+
+TEST(Enumerate, BasicConst) {
+  std::vector<std::string> v = {"abc", "a", "ab"};
+  size_t i = 0;
+  for (const auto it : folly::enumerate(v)) {
+    static_assert(IsConstReference<decltype(*it)>::value, "Const enumeration");
+    EXPECT_EQ(it.index, i);
+    EXPECT_EQ(*it, v[i]);
+    EXPECT_EQ(it->size(), v[i].size());
+    ++i;
+  }
+
+  EXPECT_EQ(i, v.size());
+}
+
+TEST(Enumerate, BasicConstRef) {
+  std::vector<std::string> v = {"abc", "a", "ab"};
+  size_t i = 0;
+  for (const auto& it : folly::enumerate(v)) {
+    static_assert(IsConstReference<decltype(*it)>::value, "Const enumeration");
+    EXPECT_EQ(it.index, i);
+    EXPECT_EQ(*it, v[i]);
+    EXPECT_EQ(it->size(), v[i].size());
+    ++i;
+  }
+
+  EXPECT_EQ(i, v.size());
+}
+
+TEST(Enumerate, BasicConstRRef) {
+  std::vector<std::string> v = {"abc", "a", "ab"};
+  size_t i = 0;
+  for (const auto&& it : folly::enumerate(v)) {
+    static_assert(IsConstReference<decltype(*it)>::value, "Const enumeration");
+    EXPECT_EQ(it.index, i);
+    EXPECT_EQ(*it, v[i]);
+    EXPECT_EQ(it->size(), v[i].size());
+    ++i;
+  }
+
+  EXPECT_EQ(i, v.size());
+}
+
+TEST(Enumerate, BasicVecBool) {
+  std::vector<bool> v = {true, false, false, true};
+  size_t i = 0;
+  for (auto it : folly::enumerate(v)) {
+    EXPECT_EQ(it.index, i);
+    EXPECT_EQ(*it, v[i]);
+    ++i;
+  }
+
+  EXPECT_EQ(i, v.size());
+}
+
+TEST(Enumerate, BasicVecBoolRRef) {
+  std::vector<bool> v = {true, false, false, true};
+  size_t i = 0;
+  for (auto it : folly::enumerate(v)) {
+    EXPECT_EQ(it.index, i);
+    EXPECT_EQ(*it, v[i]);
+    ++i;
+  }
+
+  EXPECT_EQ(i, v.size());
+}
 
 TEST(Enumerate, Temporary) {
   std::vector<std::string> v = {"abc", "a", "ab"};