Commit fbba2051 authored by Yedidya Feldblum's avatar Yedidya Feldblum Committed by Facebook GitHub Bot

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
parent 04d6ac76
...@@ -566,9 +566,7 @@ if (BUILD_TESTS) ...@@ -566,9 +566,7 @@ if (BUILD_TESTS)
TEST access_test SOURCES AccessTest.cpp TEST access_test SOURCES AccessTest.cpp
TEST array_test SOURCES ArrayTest.cpp TEST array_test SOURCES ArrayTest.cpp
TEST bit_iterator_test SOURCES BitIteratorTest.cpp TEST bit_iterator_test SOURCES BitIteratorTest.cpp
# TODO: CMake's gtest_add_tests() function currently chokes on TEST enumerate_test SOURCES EnumerateTest.cpp
# EnumerateTest.cpp since it uses macros to define tests.
#TEST enumerate_test SOURCES EnumerateTest.cpp
TEST evicting_cache_map_test SOURCES EvictingCacheMapTest.cpp TEST evicting_cache_map_test SOURCES EvictingCacheMapTest.cpp
TEST f14_fwd_test SOURCES F14FwdTest.cpp TEST f14_fwd_test SOURCES F14FwdTest.cpp
TEST f14_map_test SOURCES F14MapTest.cpp TEST f14_map_test SOURCES F14MapTest.cpp
......
...@@ -35,70 +35,109 @@ struct IsConstReference<const T&> { ...@@ -35,70 +35,109 @@ struct IsConstReference<const T&> {
} // namespace } // namespace
#define ENUMERATE_TEST_BASIC(DECL, NAME) \ TEST(Enumerate, Basic) {
TEST(Enumerate, NAME) { \ std::vector<std::string> v = {"abc", "a", "ab"};
std::vector<std::string> v = {"abc", "a", "ab"}; \ size_t i = 0;
size_t i = 0; \ for (auto it : folly::enumerate(v)) {
for (DECL it : folly::enumerate(v)) { \ EXPECT_EQ(it.index, i);
EXPECT_EQ(it.index, i); \ EXPECT_EQ(*it, v[i]);
EXPECT_EQ(*it, v[i]); \ EXPECT_EQ(it->size(), v[i].size());
EXPECT_EQ(it->size(), v[i].size()); \
\ /* Test mutability. */
/* Test mutability. */ \ std::string newValue = "x";
std::string newValue = "x"; \ *it = newValue;
*it = newValue; \ EXPECT_EQ(newValue, v[i]);
EXPECT_EQ(newValue, v[i]); \
\ ++i;
++i; \ }
} \
\ EXPECT_EQ(i, v.size());
EXPECT_EQ(i, v.size()); \ }
}
TEST(Enumerate, BasicRRef) {
ENUMERATE_TEST_BASIC(auto, Basic) std::vector<std::string> v = {"abc", "a", "ab"};
ENUMERATE_TEST_BASIC(auto&&, BasicRRef) size_t i = 0;
for (auto&& it : folly::enumerate(v)) {
#undef ENUMERATE_TEST_BASIC EXPECT_EQ(it.index, i);
EXPECT_EQ(*it, v[i]);
#define ENUMERATE_TEST_BASIC_CONST(DECL, NAME) \ EXPECT_EQ(it->size(), v[i].size());
TEST(Enumerate, NAME) { \
std::vector<std::string> v = {"abc", "a", "ab"}; \ /* Test mutability. */
size_t i = 0; \ std::string newValue = "x";
for (DECL it : folly::enumerate(v)) { \ *it = newValue;
static_assert( \ EXPECT_EQ(newValue, v[i]);
IsConstReference<decltype(*it)>::value, "Const enumeration"); \
EXPECT_EQ(it.index, i); \ ++i;
EXPECT_EQ(*it, v[i]); \ }
EXPECT_EQ(it->size(), v[i].size()); \
++i; \ EXPECT_EQ(i, v.size());
} \ }
\
EXPECT_EQ(i, v.size()); \ TEST(Enumerate, BasicConst) {
} std::vector<std::string> v = {"abc", "a", "ab"};
size_t i = 0;
ENUMERATE_TEST_BASIC_CONST(const auto, BasicConst) for (const auto it : folly::enumerate(v)) {
ENUMERATE_TEST_BASIC_CONST(const auto&, BasicConstRef) static_assert(IsConstReference<decltype(*it)>::value, "Const enumeration");
ENUMERATE_TEST_BASIC_CONST(const auto&&, BasicConstRRef) EXPECT_EQ(it.index, i);
EXPECT_EQ(*it, v[i]);
#undef ENUMERATE_TEST_BASIC_CONST EXPECT_EQ(it->size(), v[i].size());
++i;
#define ENUMERATE_TEST_BASIC_VECTOR_BOOL(DECL, NAME) \ }
TEST(Enumerate, NAME) { \
std::vector<bool> v = {true, false, false, true}; \ EXPECT_EQ(i, v.size());
size_t i = 0; \ }
for (DECL it : folly::enumerate(v)) { \
EXPECT_EQ(it.index, i); \ TEST(Enumerate, BasicConstRef) {
EXPECT_EQ(*it, v[i]); \ std::vector<std::string> v = {"abc", "a", "ab"};
++i; \ size_t i = 0;
} \ for (const auto& it : folly::enumerate(v)) {
\ static_assert(IsConstReference<decltype(*it)>::value, "Const enumeration");
EXPECT_EQ(i, v.size()); \ EXPECT_EQ(it.index, i);
} EXPECT_EQ(*it, v[i]);
EXPECT_EQ(it->size(), v[i].size());
ENUMERATE_TEST_BASIC_VECTOR_BOOL(auto, BasicVecBool) ++i;
ENUMERATE_TEST_BASIC_VECTOR_BOOL(auto&&, BasicVecBoolRRef) }
#undef ENUMERATE_TEST_BASIC_VECTOR_BOOL 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) { TEST(Enumerate, Temporary) {
std::vector<std::string> v = {"abc", "a", "ab"}; std::vector<std::string> v = {"abc", "a", "ab"};
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment