Add a few more recursive_iterator tests.

TODO: Split up tests more sensibly by type.
TODO: Test `operator super()`
TODO: Test `operator++(int)`
TODO: Make std::string handle properly.

test/recursive_iterator_accessors_test.cxx

@@ -5,24 +5,51 @@
 
 #include <gmock/gmock.h>
 
+// TODO: std::string should not be unwrapped
+TEST(RecursiveIteratorTest, CanArrowMultiVector) {
+  std::vector<std::vector<int>> obj{{{0, 1}}, {{2, 3}}};
+  auto rit = make_recursive_iterator(obj);
+  testing::StaticAssertTypeEq<decltype(rit.operator->()), int *>();
+  EXPECT_THAT(rit.operator->(), &obj[0][0]);
+}
+
+TEST(RecursiveIteratorTest, CannotArrowMap) {
+  std::map<int, std::vector<int>> obj{{1, {{0, 1}}}, {2, {{2, 3}}}};
+  auto rit = make_recursive_iterator(obj);
+  testing::StaticAssertTypeEq<decltype(rit.operator->()), void>();
+}
+
+TEST(RecursiveIteratorTest, CanAccessOuterterator) {
+  std::map<int, std::vector<int>> obj{{1, {{0, 1}}}, {2, {{2, 3}}}};
+  auto rit = make_recursive_iterator(obj);
+  auto inner = iterator::end_aware_iterator<decltype(obj)::iterator>(rit);
+  EXPECT_THAT(&std::get<0>(*rit), &(inner->first));
+}
+
+TEST(RecursiveIteratorTest, CanAccessInnerIterator) {
+  std::map<int, std::vector<int>> obj{{1, {{0, 1}}}, {2, {{2, 3}}}};
+  auto rit = make_recursive_iterator(obj);
+  auto inner = iterator::end_aware_iterator<std::vector<int>::iterator>(rit);
+  EXPECT_THAT(&std::get<1>(*rit), &*inner);
+}
+
 TEST(RecursiveIteratorTest, 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 = make_recursive_iterator(obj);
-  EXPECT_TRUE((testing::StaticAssertTypeEq<
-               decltype(std::get<0>(rit)),
-               iterator::end_aware_iterator<decltype(obj)::iterator>>()));
-  EXPECT_TRUE(
-      (testing::StaticAssertTypeEq<decltype(std::get<1>(rit)),
-                                   iterator::end_aware_iterator<std::vector<
-                                       std::map<int, int>>::iterator>>()));
-  EXPECT_TRUE((testing::StaticAssertTypeEq<
-               decltype(std::get<2>(rit)),
-               iterator::end_aware_iterator<std::map<int, int>::iterator>>()));
-  EXPECT_TRUE((testing::StaticAssertTypeEq<
-               decltype(*rit), std::tuple<int const &, int const &, int &>>()));
+  testing::StaticAssertTypeEq<
+      decltype(std::get<0>(rit)),
+      iterator::end_aware_iterator<decltype(obj)::iterator>>();
+  testing::StaticAssertTypeEq<decltype(std::get<1>(rit)),
+                              iterator::end_aware_iterator<
+                                  std::vector<std::map<int, int>>::iterator>>();
+  testing::StaticAssertTypeEq<
+      decltype(std::get<2>(rit)),
+      iterator::end_aware_iterator<std::map<int, int>::iterator>>();
+  testing::StaticAssertTypeEq<decltype(*rit),
+                              std::tuple<int const &, int const &, int &>>();
 }
 
 TEST(RecursiveIteratorTest, CanAccessInternalIteratorsWithGet) {
@@ -64,16 +91,14 @@ TEST(BoundedRecursiveIteratorTest, CanStdGetToNLayersOfInternalIteration) {
       {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
   };
   auto rit = make_recursive_iterator<2>(obj);
-  EXPECT_TRUE((testing::StaticAssertTypeEq<
-               decltype(std::get<0>(rit)),
-               iterator::end_aware_iterator<decltype(obj)::iterator>>()));
-  EXPECT_TRUE(
-      (testing::StaticAssertTypeEq<decltype(std::get<1>(rit)),
-                                   iterator::end_aware_iterator<std::vector<
-                                       std::map<int, int>>::iterator>>()));
-  EXPECT_TRUE(
-      (testing::StaticAssertTypeEq<
-          decltype(*rit), std::tuple<int const &, std::map<int, int> &>>()));
+  testing::StaticAssertTypeEq<
+      decltype(std::get<0>(rit)),
+      iterator::end_aware_iterator<decltype(obj)::iterator>>();
+  testing::StaticAssertTypeEq<decltype(std::get<1>(rit)),
+                              iterator::end_aware_iterator<
+                                  std::vector<std::map<int, int>>::iterator>>();
+  testing::StaticAssertTypeEq<decltype(*rit),
+                              std::tuple<int const &, std::map<int, int> &>>();
 }
 
 TEST(BoundedRecursiveIteratorTest, CanAccessInternalIteratorsWithGet) {
@@ -108,6 +133,15 @@ TEST(BoundedRecursiveIteratorTest, EmptyCtorIsEnd) {
   EXPECT_THAT(rit, decltype(rit)());
 }
 
+TEST(BoundedRecursiveIteratorTest, 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 = make_recursive_iterator<2>(obj);
+  EXPECT_THAT(*rit, obj[0][0]);
+}
+
 // TEST(RecursiveIteratorTest, CanConstructInPlaceFromIterators) {
 //  std::map<int, std::vector<std::map<int, int>>> const obj{
 //      {1, {{{1, 1}}, {{2, 2}}}}, {2, {{{3, 3}, {4, 4}}}}};

test/recursive_iterator_map_test.cxx

@@ -16,10 +16,8 @@ TEST(RecursiveIteratorSingleMapTest, IterDistanceIsContainerSize) {
 TEST(RecursiveIteratorSingleMapTest, DataMatchesContainerIterator) {
   std::map<int, int> const map{{1, 1}, {2, 2}, {3, 3}};
   auto rit = make_recursive_iterator(map);
-  // TODO: Collapse into a container instead
-  for (auto it = map.begin(), end = map.end(); it != end; ++it, ++rit) {
-    EXPECT_THAT(*it, *rit);
-  }
+  decltype(map) result(rit, decltype(rit)());
+  EXPECT_THAT(result, map);
 }
 
 TEST(RecursiveIteratorSingleMapTest, CanMutatePointedToData) {
@@ -44,11 +42,8 @@ TEST(RecursiveIteratorMapMapTest, ElementsAreUnwrappedAsATuple) {
   std::vector<std::tuple<int, int, int>> const expected{
       {1, 1, 1}, {2, 2, 2}, {2, 3, 3}};
   auto rit = make_recursive_iterator(map);
-  // TODO: Collapse into a container instead
-  for (auto it = expected.begin(), end = expected.end(); it != end;
-       ++it, ++rit) {
-    EXPECT_THAT(std::tuple_cat(*it), *rit);
-  }
+  decltype(expected) result(rit, decltype(rit)());
+  EXPECT_THAT(result, expected);
 }
 
 TEST(RecursiveIteratorMapMapTest, CanMutatePointedToData) {
@@ -69,9 +64,6 @@ TEST(BoundRecursiveIteratorMapMapTest, IterDistanceSumOnNLayersSize) {
 TEST(BoundRecursiveIteratorMapMapTest, ElementsAreUnwrappedAsATuple) {
   std::map<int, std::map<int, int>> map{{1, {{1, 1}}}, {2, {{2, 2}, {3, 3}}}};
   auto rit = make_recursive_iterator<1>(map);
-
-  // TODO: Collapse into a container instead
-  for (auto it = map.begin(), end = map.end(); it != end; ++it, ++rit) {
-    EXPECT_THAT(*it, *rit);
-  }
+  decltype(map) result(rit, decltype(rit)());
+  EXPECT_THAT(result, map);
 }

test/recursive_iterator_mixed_container_test.cxx

@@ -17,12 +17,9 @@ 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}};
-  // TODO: Collapse into a container instead
   auto rit = make_recursive_iterator(obj);
-  for (auto it = expected.begin(), end = expected.end(); it != end;
-       ++it, ++rit) {
-    EXPECT_THAT(*it, *rit);
-  }
+  decltype(expected) result(rit, decltype(rit)());
+  EXPECT_THAT(result, expected);
 }
 
 TEST(RecursiveIteratorMapVectorTest, CanMutatePointedToData) {
@@ -32,6 +29,14 @@ TEST(RecursiveIteratorMapVectorTest, CanMutatePointedToData) {
   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}}};
@@ -47,11 +52,8 @@ TEST(RecursiveIteratorVectorMapTest, ElementsAreUnwrappedAsATuple) {
   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);
-  // TODO: Collapse into a container instead
-  for (auto it = expected.begin(), end = expected.end(); it != end;
-       ++it, ++rit) {
-    EXPECT_THAT(*it, *rit);
-  }
+  decltype(expected) result(rit, decltype(rit)());
+  EXPECT_THAT(result, expected);
 }
 
 TEST(RecursiveIteratorVectorMapTest, CanMutatePointedToData) {
@@ -76,11 +78,8 @@ TEST(RecursiveIteratorMapVecMapTest, ElementsAreUnwrappedAsATuple) {
       {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);
-  // TODO: Collapse into a container instead
-  for (auto it = expected.begin(), end = expected.end(); it != end;
-       ++it, ++rit) {
-    EXPECT_THAT(*it, *rit);
-  }
+  decltype(expected) result(rit, decltype(rit)());
+  EXPECT_THAT(result, expected);
 }
 
 TEST(RecursiveIteratorMapVecMapTest, CanMutatePointedToData) {
@@ -105,11 +104,8 @@ TEST(RecursiveIteratorVecMapVecTest, ElementsAreUnwrappedAsATuple) {
   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);
-  // TODO: Collapse into a container instead
-  for (auto it = expected.begin(), end = expected.end(); it != end;
-       ++it, ++rit) {
-    EXPECT_THAT(*it, *rit);
-  }
+  decltype(expected) result(rit, decltype(rit)());
+  EXPECT_THAT(result, expected);
 }
 
 TEST(RecursiveIteratorVecMapVecTest, CanMutatePointedToData) {

test/recursive_iterator_vector_test.cxx

@@ -14,11 +14,8 @@ TEST(RecursiveIteratorSingleVectorTest, IterDistanceIsContainerSize) {
 TEST(RecursiveIteratorSingleVectorTest, ElementsAreUnwrappedAsATuple) {
   std::vector<int> const vec{1, 2, 3, 4, 5};
   auto rit = make_recursive_iterator(vec);
-
-  // TODO: Collapse into a container instead
-  for (auto it = vec.begin(), end = vec.end(); it != end; ++it, ++rit) {
-    EXPECT_THAT(*it, *rit);
-  }
+  decltype(vec) result(rit, decltype(rit)());
+  EXPECT_THAT(result, vec);
 }
 
 TEST(RecursiveIteratorSingleVectorTest, CanMutatePointedToData) {
@@ -42,12 +39,8 @@ TEST(RecursiveIteratorVectorVectorTest, ElementsAreUnwrappedAsATuple) {
   std::vector<std::vector<int>> const vec{{1, 2}, {3, 4, 5}};
   std::vector<int> const expected{1, 2, 3, 4, 5};
   auto rit = make_recursive_iterator(vec);
-
-  // TODO: Collapse into a container instead
-  for (auto it = expected.begin(), end = expected.end(); it != end;
-       ++it, ++rit) {
-    EXPECT_THAT(*it, *rit);
-  }
+  decltype(expected) result(rit, decltype(rit)());
+  EXPECT_THAT(result, expected);
 }
 
 TEST(RecursiveIteratorVectorVectorTest, CanMutatePointedToData) {
@@ -68,9 +61,6 @@ TEST(BoundedRecursiveIteratorVectorVectorTest, IterDistanceSumOnNLayersSize) {
 TEST(BoundedRecursiveIteratorVectorVectorTest, ElementsAreUnwrappedAsATuple) {
   std::vector<std::vector<int>> const vec{{1, 2}, {3, 4, 5}};
   auto rit = make_recursive_iterator<1>(vec);
-
-  // TODO: Collapse into a container instead
-  for (auto it = vec.begin(), end = vec.end(); it != end; ++it, ++rit) {
-    EXPECT_THAT(*it, *rit);
-  }
+  decltype(vec) result(rit, decltype(rit)());
+  EXPECT_THAT(result, vec);
 }