cpp-useful-iterators/test/recursive_iterator_mixed_container_test.cxx

#include "iterator/recursive_iterator.h"

#include <map>
#include <vector>

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

using iterator::RecursiveIterator;

using testing::ElementsAreArray;

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

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

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

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

TEST(RecursiveIterator_MapVector, CanMutatePointedToData) {
  std::map<int, std::vector<int>> obj{{1, {1, 2}}, {2, {3, 4, 5}}};
  auto rit = RecursiveIterator(obj);
  std::get<1>(*rit) = 6;
  EXPECT_THAT(obj[1][0], 6);
}

TEST(RecursiveIterator_MapMapVector, CanMutatePointedToData) {
  std::map<int, std::map<int, std::vector<int>>> obj{{1, {{1, {1, 2}}}},
                                                     {2, {{1, {3, 4, 5}}}}};
  auto rit = RecursiveIterator(obj);
  std::get<2>(*rit) = 6;
  EXPECT_THAT(obj[1][1][0], 6);
}

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

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

TEST(RecursiveIterator_VectorMap, ElementsAreUnwrappedAsATuple) {
  std::vector<std::map<int, int>> const obj{{{1, 1}, {2, 2}},
                                            {{3, 3}, {4, 4}, {5, 5}}};
  std::vector<std::pair<int, int>> const expected{
      {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};

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

TEST(RecursiveIterator_VectorMap, CanMutatePointedToData) {
  std::vector<std::map<int, int>> obj{{{1, 1}, {2, 2}},
                                      {{3, 3}, {4, 4}, {5, 5}}};
  auto rit = RecursiveIterator(obj);
  std::get<1>(*rit) = 6;
  EXPECT_THAT(obj[0][1], 6);
}

TEST(RecursiveIterator_MapVectorMap, IterDistanceIsSumOfInnerContainerSizes) {
  std::map<int, std::vector<std::map<int, int>>> const obj{
      {1, {{{1, 1}, {2, 2}}}}};
  std::vector<std::tuple<int, int, int>> const expected{{1, 1, 1}, {1, 2, 2}};
  auto rit = RecursiveIterator(obj);

  EXPECT_THAT(ranges::distance(rit, iterator::sentinel), expected.size());
}

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

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

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

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

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

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

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

TEST(RecursiveIterator_VecMapVec, CanMutatePointedToData) {
  std::vector<std::map<int, std::vector<int>>> obj{
      {{1, {1, 2}}, {2, {3, 4, 5}}}, {{1, {3, 4}}}};
  auto rit = RecursiveIterator(obj);
  std::get<1>(*rit) = 6;

  EXPECT_THAT(obj[0][1][0], 6);
}