cpp-useful-iterators/test/recursive_iterator_map_test.cxx

#include "iterator/recursive_iterator.h"

#include <map>
#include <ranges>
#include <tuple>
#include <vector>

#include <iterator/forwards.h>

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

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

using testing::ElementsAreArray;
using testing::IsEmpty;

TEST(RecursiveIterator_MapMap, PreIncrementAdvancesIterator) {
  std::map<int, std::map<int, std::map<int, int>>> const map{
      {1, {{1, {{1, 1}}}}}, {2, {{2, {{2, 2}}}, {3, {{3, 3}, {4, 4}}}}}};
  auto rit = RecursiveIterator(map);
  EXPECT_THAT(std::get<3>(*rit), 1);
  EXPECT_THAT(std::get<3>(*++rit), 2);
  EXPECT_THAT(std::get<3>(*rit), 2);
}

TEST(RecursiveIterator_MapMap, PostIncrementReturnsCopyOfPrev) {
  std::map<int, std::map<int, std::map<int, int>>> const map{
      {1, {{1, {{1, 1}}}}}, {2, {{2, {{2, 2}}}, {3, {{3, 3}, {4, 4}}}}}};
  auto rit = RecursiveIterator(map);
  EXPECT_THAT(std::get<3>(*rit), 1);
  EXPECT_THAT(std::get<3>(*rit++), 1);
  EXPECT_THAT(std::get<3>(*rit), 2);
}

TEST(RecursiveIterator_MapMap, IterDistanceIsSumOfInnerContainerSizes) {
  std::map<int, std::map<int, std::map<int, int>>> const map{
      {1, {{1, {{1, 1}}}}}, {2, {{2, {{2, 2}}}, {3, {{3, 3}, {4, 4}}}}}};
  auto rit = RecursiveIterator(map);

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

TEST(RecursiveIterator_MapMap, ElementsAreUnwrappedAsATuple) {
  std::map<int, std::map<int, std::map<int, int>>> const map{
      {1, {{1, {{1, 1}}}}}, {2, {{2, {{2, 2}}}, {3, {{3, 3}, {4, 4}}}}}};
  std::vector<std::tuple<int, int, int, int>> const expected{
      {1, 1, 1, 1}, {2, 2, 2, 2}, {2, 3, 3, 3}, {2, 3, 4, 4}};

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

TEST(RecursiveIterator_MapMap, CanMutatePointedToData) {
  std::map<int, std::map<int, std::map<int, int>>> map{
      {1, {{1, {{1, 1}}}}}, {2, {{2, {{2, 2}}}, {3, {{3, 3}, {4, 4}}}}}};
  auto rit = RecursiveIterator(map);
  std::get<3>(*rit) = 4;
  EXPECT_THAT(map[1][1][1], 4);
}

TEST(RecursiveIterator_Map_Bounded, PreIncrementAdvancesIterator) {
  std::map<int, std::map<int, std::map<int, int>>> map{
      {1, {{1, {{1, 1}}}}}, {2, {{2, {{2, 2}}}, {3, {{3, 3}, {4, 4}}}}}};
  auto rit = RecursiveIterator(map, bounded<2>{});
  EXPECT_THAT(std::get<2>(*rit), map[1][1]);
  EXPECT_THAT(std::get<2>(*++rit), map[2][2]);
  EXPECT_THAT(std::get<2>(*rit), map[2][2]);
}

TEST(RecursiveIterator_Map_Bounded, PostIncrementReturnsCopyOfPrev) {
  std::map<int, std::map<int, std::map<int, int>>> map{
      {1, {{1, {{1, 1}}}}}, {2, {{2, {{2, 2}}}, {3, {{3, 3}, {4, 4}}}}}};
  auto rit = RecursiveIterator(map, bounded<2>{});
  EXPECT_THAT(std::get<2>(*rit), map[1][1]);
  EXPECT_THAT(std::get<2>(*rit++), map[1][1]);
  EXPECT_THAT(std::get<2>(*rit), map[2][2]);
}

TEST(RecursiveIterator_Map_Bounded, IterDistanceSumOnNLayersSize) {
  std::map<int, std::map<int, std::map<int, int>>> const map{
      {1, {{1, {{1, 1}}}}}, {2, {{2, {{2, 2}}}, {3, {{3, 3}, {4, 4}}}}}};
  auto rit = RecursiveIterator(map, bounded<2>{});

  EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 3);
}

TEST(RecursiveIterator_Map_Bounded, ElementsAreUnwrappedAsATuple) {
  std::map<int, std::map<int, std::map<int, int>>> const map{
      {1, {{1, {{1, 1}}}}}, {2, {{2, {{2, 2}}}, {3, {{3, 3}, {4, 4}}}}}};
  std::vector<std::tuple<int, int, std::map<int, int>>> const expected{
      {1, 1, {{1, 1}}}, {2, 2, {{2, 2}}}, {2, 3, {{3, 3}, {4, 4}}}};

  EXPECT_THAT(map | views::recursive_n<2> | ranges::to<std::vector>(),
              ElementsAreArray(expected));
}

TEST(RecursiveIterator_Map_Bounded, CanMutatePointedToData) {
  std::map<int, std::map<int, std::map<int, int>>> map{
      {1, {{1, {{1, 1}}}}}, {2, {{2, {{2, 2}}}, {3, {{3, 3}, {4, 4}}}}}};
  auto rit = RecursiveIterator(map, bounded<2>{});
  std::get<2>(*rit).clear();
  EXPECT_THAT(map[1][1], IsEmpty());
}