cpp-useful-iterators/test/recursive_iterator_accessors_test.cxx

#include "iterator/recursive_iterator.h"

#include <map>
#include <string>
#include <tuple>
#include <vector>

#include "ranges.h"
#include "xcode_gtest_helper.h"

using iterator::bounded;
using iterator::EndAwareIterator;
using iterator::RecursiveIterator;

using testing::ElementsAreArray;
using testing::Not;
using testing::StaticAssertTypeEq;

TEST(RecursiveIterator, DoesNotUnwrapString) {
  std::vector<std::string> obj{"A", "B", "C", "D"};
  auto rit = RecursiveIterator(obj);
  StaticAssertTypeEq<decltype(rit.operator->()), std::string *>();

  EXPECT_THAT(obj | views::recursive | ranges::to<std::vector>(),
              ElementsAreArray(obj));
}

TEST(RecursiveIterator, CanArrowMultiVector) {
  std::vector<std::vector<int>> obj{{{0, 1}}, {{2, 3}}};
  auto rit = RecursiveIterator(obj);
  StaticAssertTypeEq<decltype(rit.operator->()), int *>();
  EXPECT_THAT(rit.operator->(), &obj[0][0]);
}

TEST(RecursiveIterator, CanAccessOuterterator) {
  std::map<int, std::vector<int>> obj{{1, {{0, 1}}}, {2, {{2, 3}}}};
  auto rit = RecursiveIterator(obj);

  EndAwareIterator<decltype(obj)::iterator> inner = rit;
  EXPECT_THAT(&std::get<0>(*rit), &(inner->first));
}

TEST(RecursiveIterator, CanAccessInnerIterator) {
  std::map<int, std::vector<int>> obj{{1, {{0, 1}}}, {2, {{2, 3}}}};
  auto rit = RecursiveIterator(obj);

  EndAwareIterator<std::vector<int>::iterator> inner = rit;
  EXPECT_THAT(&std::get<1>(*rit), &*inner);
}

TEST(RecursiveIterator, CanStdGetToAllLayersOfInternalIteration) {
  std::map<int, std::vector<std::map<int, int>>> obj{
      {1, {{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
      {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
  };
  auto rit = RecursiveIterator(obj);

  using mvm_iterator = std::map<int, std::vector<std::map<int, int>>>::iterator;
  StaticAssertTypeEq<decltype(std::get<0>(rit)),
                     EndAwareIterator<mvm_iterator>>();

  using vm_iterator = std::vector<std::map<int, int>>::iterator;
  StaticAssertTypeEq<decltype(std::get<1>(rit)),
                     EndAwareIterator<vm_iterator>>();

  using m_iterator = std::map<int, int>::iterator;
  StaticAssertTypeEq<decltype(std::get<2>(rit)),
                     EndAwareIterator<m_iterator>>();

  using tup_i_i_i = std::tuple<int const &, int const &, int &>;
  StaticAssertTypeEq<decltype(*rit), tup_i_i_i>();
}

TEST(RecursiveIterator, CanAccessInternalIteratorsWithGet) {
  std::map<int, std::vector<std::map<int, int>>> obj{
      {1, {{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
      {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
  };
  auto rit = RecursiveIterator(obj);
  EXPECT_THAT(std::get<0>(rit), EndAwareIterator(obj));
  EXPECT_THAT(std::get<1>(rit), EndAwareIterator(obj[1]));
  EXPECT_THAT(std::get<2>(rit), EndAwareIterator(obj[1][0]));
}

// TODO: This ought to be implemented as a compiles-test
TEST(RecursiveIterator, CanCastCompatibleIterators) {
  std::map<int, std::vector<std::map<int, int>>> obj{
      {1, {{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
      {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
  };
  auto rit = RecursiveIterator(obj);
  iterator::RecursiveIterator<decltype(obj)::const_iterator> cit(rit);
}

TEST(RecursiveIterator, EmptyCtorIsEnd) {
  std::map<int, std::vector<std::map<int, int>>> obj{
      {1, {{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
      {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
  };
  auto rit = RecursiveIterator(obj);

  EXPECT_THAT(rit, Not(iterator::sentinel));
  EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 4);

  std::advance(rit, 4);
  EXPECT_THAT(rit, iterator::sentinel);
}

TEST(RecursiveIterator_Bounded, CanStdGetToNLayersOfInternalIteration) {
  std::map<int, std::vector<std::map<int, int>>> obj{
      {1, {{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
      {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
  };
  auto rit = RecursiveIterator(obj, bounded<2>{});

  using mvm_iterator = std::map<int, std::vector<std::map<int, int>>>::iterator;
  StaticAssertTypeEq<decltype(std::get<0>(rit)),
                     EndAwareIterator<mvm_iterator>>();

  using vm_iterator = std::vector<std::map<int, int>>::iterator;
  StaticAssertTypeEq<decltype(std::get<1>(rit)),
                     EndAwareIterator<vm_iterator>>();

  using tup_i_mii = std::tuple<int const &, std::map<int, int> &>;
  StaticAssertTypeEq<decltype(*rit), tup_i_mii>();
}

TEST(RecursiveIterator_Bounded, CanAccessInternalIteratorsWithGet) {
  std::map<int, std::vector<std::map<int, int>>> obj{
      {1, {{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
      {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
  };
  auto rit = RecursiveIterator(obj, bounded<2>{});
  EXPECT_THAT(std::get<0>(rit), EndAwareIterator(obj));
  EXPECT_THAT(std::get<1>(rit), EndAwareIterator(obj[1]));
}

// TODO: This ought to be implemented as a compiles-test
TEST(RecursiveIterator_Bounded, CanCastCompatibleIterators) {
  std::map<int, std::vector<std::map<int, int>>> obj{
      {1, {{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
      {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
  };
  auto rit = RecursiveIterator(obj, bounded<2>{});
  iterator::RecursiveIteratorN<decltype(obj)::const_iterator, 2> cit(rit);
}

TEST(RecursiveIterator_Bounded, EmptyCtorIsEnd) {
  std::map<int, std::vector<std::map<int, int>>> obj{
      {1, {{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
      {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
  };
  auto rit = RecursiveIterator(obj, bounded<3>{});
  EXPECT_THAT(rit, Not(iterator::sentinel));
  EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 4);

  std::advance(rit, 4);
  EXPECT_THAT(rit, iterator::sentinel);
}

TEST(RecursiveIterator_Bounded, CanFetchInnerCollections) {
  std::vector<std::vector<std::map<int, int>>> obj{
      {{{{1, 1}}, {{2, 2}}}}, // 2 1-element maps
      {{{{3, 3}, {4, 4}}}}    // 1 2-element map
  };
  auto rit = RecursiveIterator(obj, bounded<2>{});
  EXPECT_THAT(*rit, obj[0][0]);
}