IteratorsTest.cpp File Reference

#include <map>
#include <folly/container/Array.h>
#include <folly/detail/Iterators.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Functions
	TEST (IteratorsTest, IterFacadeHasCorrectTraits)
	TEST (IteratorsTest, SimpleIteratorFacade)
	TEST (IteratorsTest, IterAdaptorHasCorrectTraits)
	TEST (IteratorsTest, IterAdaptorWithPointer)
	TEST (IteratorsTest, IterAdaptorOfOtherIter)
	TEST (IteratorsTest, MixedConstAndNonconstIters)

Function Documentation

TEST	(	IteratorsTest	,
		IterFacadeHasCorrectTraits
	)

Definition at line 43 of file IteratorsTest.cpp.

References value.

                                                {
  using TR = std::iterator_traits<IntArrayIterator>;
  static_assert(std::is_same<TR::value_type, int const>::value, "");
  static_assert(std::is_same<TR::reference, int const&>::value, "");
  static_assert(std::is_same<TR::pointer, int const*>::value, "");
  static_assert(
      std::is_same<TR::iterator_category, std::forward_iterator_tag>::value,
      "");
  static_assert(std::is_same<TR::difference_type, ssize_t>::value, "");
}

TEST	(	IteratorsTest	,
		SimpleIteratorFacade
	)

Definition at line 54 of file IteratorsTest.cpp.

References folly::test::end(), EXPECT_EQ, EXPECT_NE, folly::make_array(), and ptr.

                                          {
  static const auto kArray = folly::make_array(42, 43, 44);
  IntArrayIterator end(kArray.data() + kArray.size());
  IntArrayIterator iter(kArray.data());
  EXPECT_NE(iter, end);
  EXPECT_EQ(42, *iter);
  ++iter;
  EXPECT_NE(iter, end);
  EXPECT_EQ(43, *iter);
  ++iter;
  EXPECT_NE(iter, end);
  EXPECT_EQ(44, *iter);
  ++iter;
  EXPECT_EQ(iter, end);
}

TEST	(	IteratorsTest	,
		IterAdaptorHasCorrectTraits
	)

Definition at line 86 of file IteratorsTest.cpp.

References value.

                                                 {
  using TR = std::iterator_traits<IntPointerIter>;
  static_assert(std::is_same<TR::value_type, int const>::value, "");
  static_assert(std::is_same<TR::reference, int const&>::value, "");
  static_assert(std::is_same<TR::pointer, int const*>::value, "");
  static_assert(
      std::is_same<TR::iterator_category, std::forward_iterator_tag>::value,
      "");
  static_assert(std::is_same<TR::difference_type, ssize_t>::value, "");
}

TEST	(	IteratorsTest	,
		IterAdaptorWithPointer
	)

Definition at line 97 of file IteratorsTest.cpp.

References folly::gen::dereference, folly::test::end(), EXPECT_EQ, EXPECT_NE, and folly::make_array().

                                            {
  static const auto kArray = folly::make_array(42, 43, 44);
  IntPointerIter end(kArray.data() + kArray.size());
  IntPointerIter iter(kArray.data());
  EXPECT_NE(iter, end);
  EXPECT_EQ(42, *iter);
  ++iter;
  EXPECT_NE(iter, end);
  EXPECT_EQ(43, *iter);
  ++iter;
  EXPECT_NE(iter, end);
  EXPECT_EQ(44, *iter);
  ++iter;
  EXPECT_EQ(iter, end);
}

TEST	(	IteratorsTest	,
		IterAdaptorOfOtherIter
	)

Definition at line 150 of file IteratorsTest.cpp.

References folly::gen::dereference, EXPECT_EQ, EXPECT_NE, m, and folly::detail::rhs.

                                            {
  std::map<int, int> m{{2, 42}, {3, 43}, {4, 44}};

  IntMapKeyIter keyEnd(m.end());
  IntMapKeyIter keyIter(m.begin());
  EXPECT_NE(keyIter, keyEnd);
  EXPECT_EQ(2, *keyIter);
  ++keyIter;
  EXPECT_NE(keyIter, keyEnd);
  EXPECT_EQ(3, *keyIter);
  ++keyIter;
  EXPECT_NE(keyIter, keyEnd);
  EXPECT_EQ(4, *keyIter);
  ++keyIter;
  EXPECT_EQ(keyIter, keyEnd);

  IntMapValueIter valueEnd(m.end());
  IntMapValueIter valueIter(m.begin());
  EXPECT_NE(valueIter, valueEnd);
  EXPECT_EQ(42, *valueIter);
  ++valueIter;
  EXPECT_NE(valueIter, valueEnd);
  EXPECT_EQ(43, *valueIter);
  ++valueIter;
  EXPECT_NE(valueIter, valueEnd);
  EXPECT_EQ(44, *valueIter);
  ++valueIter;
  EXPECT_EQ(valueIter, valueEnd);
}

TEST	(	IteratorsTest	,
		MixedConstAndNonconstIters
	)

Definition at line 201 of file IteratorsTest.cpp.

References folly::padded::cend(), EXPECT_EQ, EXPECT_NE, and m.

                                                {
  std::map<int, int> m{{2, 42}, {3, 43}, {4, 44}};
  IntMapValueIterConst cend(m.cend());
  IntMapValueIter valueIter(m.begin());
  EXPECT_NE(valueIter, cend);
  ++valueIter;
  ++valueIter;
  ++valueIter;
  EXPECT_EQ(valueIter, cend);
}