cpp-useful-iterators/test/recursive_iterator_mixed_container_test.cxx

#include "iterator/recursive_iterator.hpp"

#include <map>
#include <vector>

#include "xcode_gtest_helper.h"

TEST(RecursiveIteratorMapVectorTest, IterDistanceIsSumOfInnerContainerSizes) {
  std::map<int, std::vector<int>> const obj{{1, {1, 2}}, {2, {3, 4, 5}}};
  auto rit = make_recursive_iterator(obj);
  decltype(rit) end{};
  // TODO: Actually perform the summation?
  EXPECT_THAT(std::distance(rit, end), 5);
}

TEST(RecursiveIteratorMapVectorTest, 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}};
  auto rit = make_recursive_iterator(obj);
  decltype(expected) result(rit, decltype(rit)());
  EXPECT_THAT(result, expected);
}

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

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

TEST(RecursiveIteratorVectorMapTest, IterDistanceIsSumOfInnerContainerSizes) {
  std::vector<std::map<int, int>> const obj{{{1, 1}, {2, 2}},
                                            {{3, 3}, {4, 4}, {5, 5}}};
  auto rit = make_recursive_iterator(obj);
  decltype(rit) end{};
  // TODO: Actually perform the summation?
  EXPECT_THAT(std::distance(rit, end), 5);
}

TEST(RecursiveIteratorVectorMapTest, ElementsAreUnwrappedAsATuple) {
  std::vector<std::map<int, int>> const obj{{{1, 1}, {2, 2}},
                                            {{3, 3}, {4, 4}, {5, 5}}};
  std::vector<std::pair<int const, int>> const expected{
      {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};
  auto rit = make_recursive_iterator(obj);
  decltype(expected) result(rit, decltype(rit)());
  EXPECT_THAT(result, expected);
}

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

TEST(RecursiveIteratorMapVecMapTest, 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 = make_recursive_iterator(obj);
  decltype(rit) end{};
  EXPECT_THAT(std::distance(rit, end), expected.size());
}

TEST(RecursiveIteratorMapVecMapTest, 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}};
  auto rit = make_recursive_iterator(obj);
  decltype(expected) result(rit, decltype(rit)());
  EXPECT_THAT(result, expected);
}

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

TEST(RecursiveIteratorVecMapVecTest, IterDistanceIsSumOfInnerContainerSizes) {
  std::vector<std::map<int, std::vector<int>>> const obj{
      {{1, {1, 2}}, {2, {3, 4, 5}}}, {{1, {3, 4}}}};
  auto rit = make_recursive_iterator(obj);
  decltype(rit) end{};
  // TODO: Actually perform the summation?
  EXPECT_THAT(std::distance(rit, end), 7);
}

TEST(RecursiveIteratorVecMapVecTest, 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}};
  auto rit = make_recursive_iterator(obj);
  decltype(expected) result(rit, decltype(rit)());
  EXPECT_THAT(result, expected);
}

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