EnumerateTest.cpp File Reference

#include <array>
#include <string>
#include <vector>
#include <folly/Range.h>
#include <folly/container/Enumerate.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Classes
class	CStringRange
struct	CStringRange::Sentinel

Macros
#define	ENUMERATE_TEST_BASIC(DECL, NAME)
#define	ENUMERATE_TEST_BASIC_CONST(DECL, NAME)

Functions
	TEST (Enumerate, Basic)
	TEST (Enumerate, BasicRRef)
	TEST (Enumerate, BasicConst)
	TEST (Enumerate, BasicConstRef)
	TEST (Enumerate, BasicConstRRef)
	TEST (Enumerate, Temporary)
	TEST (Enumerate, BasicConstArg)
	TEST (Enumerate, TemporaryConstEnumerate)
	TEST (Enumerate, RangeSupport)
	TEST (Enumerate, EmptyRange)
bool	operator== (const char *c, CStringRange::Sentinel)
	TEST (Enumerate, Cpp17Support)

Macro Definition Documentation

#define ENUMERATE_TEST_BASIC	(		DECL,
			NAME
	)

Value:

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());                          \
  }

Definition at line 38 of file EnumerateTest.cpp.

#define ENUMERATE_TEST_BASIC_CONST	(		DECL,
			NAME
	)

Value:

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());                                             \
  }

Definition at line 63 of file EnumerateTest.cpp.

Function Documentation

bool operator==	(	const char *	c,
		CStringRange::Sentinel
	)

Definition at line 164 of file EnumerateTest.cpp.

Referenced by folly::operator!=(), and TEST().

                                                     {
  return *c == 0;
}

TEST	(	Enumerate	,
		Basic
	)

Definition at line 58 of file EnumerateTest.cpp.

{                                               \

TEST	(	Enumerate	,
		BasicRRef
	)

Definition at line 59 of file EnumerateTest.cpp.

{                                               \

TEST	(	Enumerate	,
		BasicConst
	)

Definition at line 79 of file EnumerateTest.cpp.

{

TEST	(	Enumerate	,
		BasicConstRef
	)

Definition at line 80 of file EnumerateTest.cpp.

{

TEST	(	Enumerate	,
		BasicConstRRef
	)

Definition at line 81 of file EnumerateTest.cpp.

{

TEST	(	Enumerate	,
		Temporary
	)

Definition at line 85 of file EnumerateTest.cpp.

References folly::enumerate(), EXPECT_EQ, and i.

                           {
  std::vector<std::string> v = {"abc", "a", "ab"};
  size_t i = 0;
  for (auto&& it : folly::enumerate(decltype(v)(v))) { // Copy v.
    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	,
		BasicConstArg
	)

Definition at line 98 of file EnumerateTest.cpp.

References folly::enumerate(), EXPECT_EQ, i, and value.

                               {
  const std::vector<std::string> v = {"abc", "a", "ab"};
  size_t i = 0;
  for (auto&& it : folly::enumerate(v)) {
    static_assert(
        IsConstReference<decltype(*it)>::value, "Enumerating a const vector");
    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	,
		TemporaryConstEnumerate
	)

Definition at line 113 of file EnumerateTest.cpp.

References folly::enumerate(), EXPECT_EQ, i, and value.

                                         {
  std::vector<std::string> v = {"abc", "a", "ab"};
  size_t i = 0;
  for (const auto&& it : folly::enumerate(decltype(v)(v))) { // Copy 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	,
		RangeSupport
	)

Definition at line 127 of file EnumerateTest.cpp.

References folly::enumerate(), EXPECT_EQ, i, and folly::range().

                              {
  std::vector<std::string> v = {"abc", "a", "ab"};
  size_t i = 0;
  for (const auto&& it : folly::enumerate(folly::range(v))) {
    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	,
		EmptyRange
	)

Definition at line 140 of file EnumerateTest.cpp.

References ADD_FAILURE, folly::enumerate(), and v.

                            {
  std::vector<std::string> v;
  for (auto&& it : folly::enumerate(v)) {
    (void)it; // Silence warnings.
    ADD_FAILURE();
  }
}

TEST	(	Enumerate	,
		Cpp17Support
	)

Definition at line 168 of file EnumerateTest.cpp.

References ASSERT_LT, folly::test::begin(), folly::test::end(), folly::enumerate(), and EXPECT_EQ.

                              {
  std::array<char, 5> test = {"test"};
  // Can't use range based for loop until C++17, so test manually
  // Equivalent to:
  // for (const auto&& it : folly::enumerate(CStringRange{test.data()})) { ... }
  {
    auto&& enumerate = folly::enumerate(CStringRange{test.data()});
    auto begin = enumerate.begin();
    auto end = enumerate.end();
    for (; begin != end; ++begin) {
      const auto&& it = *begin;

      ASSERT_LT(it.index, test.size());
      EXPECT_EQ(*it, test[it.index]);
    }
  }
}