cpp-useful-iterators/test/join_iterator_test.cxx

#include "iterator/join_iterator.hpp"

#include <vector>

#include "xcode_gtest_helper.h"

using iterator::end_aware_iterator;
using iterator::joining_iterator;

using testing::Ne;

TEST(JoinIteratorTest, FirstDereferencedElemIsTheFirstInTheChain) {
  std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
  EXPECT_THAT(*joining_iterator(make_end_aware_iterator(mv)), mv[0][0]);
}

TEST(JoinIteratorTest, HoldsReferenceToContainedElements) {
  std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
  EXPECT_THAT(joining_iterator(make_end_aware_iterator(mv)).operator->(),
              &mv[0][0]);
}

TEST(JoinIteratorTest, DefaultCtorIsEnd) {
  std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
  joining_iterator it(make_end_aware_iterator(mv));
  EXPECT_THAT(it, Ne(decltype(it)()));
  mv.clear();
  EXPECT_THAT(joining_iterator(make_end_aware_iterator(mv)), decltype(it)());
}

// TODO: This ought to be implemented as a compiles-test
TEST(JoinIteratorTest, CanCastCompatibleIterators) {
  std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
  joining_iterator it(make_end_aware_iterator(mv));
  iterator::joining_iterator<decltype(mv)::const_iterator>{it};
}

TEST(JoinIteratorTest, CanAccessInternalIterator) {
  std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
  auto eai = make_end_aware_iterator(mv);
  joining_iterator it(eai);
  EXPECT_THAT(it.join_iterator(), eai);
}

TEST(JoinIteratorTest, CanAccessChildIterator) {
  std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
  joining_iterator it(make_end_aware_iterator(mv));
  EXPECT_THAT(it.element_iterator(), make_end_aware_iterator(mv[0]));
}

TEST(JoinIteratorTest, EmptyConstructorEqualsEnd) {
  std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
  joining_iterator it(end_aware_iterator(mv.end()),
                      end_aware_iterator(mv.back().end()));
  EXPECT_THAT(it, decltype(it)());
}

TEST(JoinIteratorTest, PreIncrementAdvancesIterator) {
  std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
  joining_iterator it(make_end_aware_iterator(mv));
  EXPECT_THAT(*it, 1);
  EXPECT_THAT(*++it, 2);
  EXPECT_THAT(*it, 2);
}

TEST(JoinIteratorTest, PostIncrementReturnsCopyOfPrev) {
  std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
  joining_iterator it(make_end_aware_iterator(mv));
  EXPECT_THAT(*it, 1);
  EXPECT_THAT(*it++, 1);
  EXPECT_THAT(*it, 2);
}

TEST(JoinIteratorTest, MovesFromListToListWhenReachingEnd) {
  std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
  joining_iterator it(make_end_aware_iterator(mv));
  std::advance(it, 3);
  EXPECT_THAT(*++it, mv[1][0]);
}

TEST(JoinIteratorTest, SkipsOverEmptyElements) {
  std::vector<std::vector<int>> mv{{1, 2, 3}, {}, {4, 5, 6}};
  joining_iterator it(make_end_aware_iterator(mv));
  std::advance(it, 3);
  EXPECT_THAT(*++it, mv[2][0]);
}

TEST(JoinIteratorTest, IncrementEndIsUnsafe) {
  std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
  joining_iterator it(end_aware_iterator(mv.end()),
                      end_aware_iterator(mv.back().end()));
  joining_iterator const cp = it;
  ++it;
  EXPECT_NE(it, cp);
}