test-refactor: use views in test cases

test/ranges.h

@@ -8,7 +8,11 @@
 
 #pragma once
 
+#include <ranges>
+
 namespace ranges {
+using namespace std::ranges;
+
 template <typename It, typename S, typename F>
 auto for_each(It it, S end, F consumer) {
   for (; it != end; ++it) {
@@ -22,19 +26,12 @@ template <typename It, typename S> auto distance(It it, S end) {
   for_each(it, end, [&diff](auto const &) { ++diff; });
   return diff;
 }
-
-template <template <typename...> class C, typename It, typename S>
-auto to(It it, S end) {
-  decltype(C(it, it)) rval;
-  for_each(it, end,
-           [&rval](auto const & elem) { rval.insert(rval.end(), elem); });
-  return rval;
 }
 
-template <typename C, typename It, typename S> auto to(It it, S end) {
-  C rval;
-  for_each(it, end,
-           [&rval](auto const & elem) { rval.insert(rval.end(), elem); });
-  return rval;
+namespace iterator::views {
 }
+
+namespace views {
+using namespace std::views;
+using namespace iterator::views;
 }

test/recursive_iterator_accessors_test.cxx

@@ -12,33 +12,32 @@ using iterator::bounded;
 using iterator::end_aware_iterator;
 using iterator::recursive_iterator;
 
+using testing::ElementsAreArray;
+using testing::Not;
 using testing::StaticAssertTypeEq;
 
 TEST(RecursiveIteratorTest, DoesNotUnwrapString) {
   std::vector<std::string> obj{"A", "B", "C", "D"};
   auto rit = recursive_iterator(obj);
   StaticAssertTypeEq<decltype(rit.operator->()), std::string *>();
+
+  EXPECT_THAT(obj | views::recursive | ranges::to<std::vector>(),
+              ElementsAreArray(obj));
 }
 
 TEST(RecursiveIteratorTest, CanArrowMultiVector) {
   std::vector<std::vector<int>> obj{{{0, 1}}, {{2, 3}}};
   auto rit = recursive_iterator(obj);
   StaticAssertTypeEq<decltype(rit.operator->()), int *>();
-  EXPECT_EQ(rit.operator->(), &obj[0][0]);
+  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 = recursive_iterator(obj);
-//  StaticAssertTypeEq<decltype(rit.operator->()), void>();
-//}
-
 TEST(RecursiveIteratorTest, CanAccessOuterterator) {
   std::map<int, std::vector<int>> obj{{1, {{0, 1}}}, {2, {{2, 3}}}};
   auto rit = recursive_iterator(obj);
 
   end_aware_iterator<decltype(obj)::iterator> inner = rit;
-  EXPECT_EQ(&std::get<0>(*rit), &(inner->first));
+  EXPECT_THAT(&std::get<0>(*rit), &(inner->first));
 }
 
 TEST(RecursiveIteratorTest, CanAccessInnerIterator) {
@@ -46,7 +45,7 @@ TEST(RecursiveIteratorTest, CanAccessInnerIterator) {
   auto rit = recursive_iterator(obj);
 
   end_aware_iterator<std::vector<int>::iterator> inner = rit;
-  EXPECT_EQ(&std::get<1>(*rit), &*inner);
+  EXPECT_THAT(&std::get<1>(*rit), &*inner);
 }
 
 TEST(RecursiveIteratorTest, CanStdGetToAllLayersOfInternalIteration) {
@@ -55,15 +54,19 @@ TEST(RecursiveIteratorTest, CanStdGetToAllLayersOfInternalIteration) {
       {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
   };
   auto rit = recursive_iterator(obj);
+
   using mvm_iterator = std::map<int, std::vector<std::map<int, int>>>::iterator;
   StaticAssertTypeEq<decltype(std::get<0>(rit)),
                      end_aware_iterator<mvm_iterator>>();
+
   using vm_iterator = std::vector<std::map<int, int>>::iterator;
   StaticAssertTypeEq<decltype(std::get<1>(rit)),
                      end_aware_iterator<vm_iterator>>();
+
   using m_iterator = std::map<int, int>::iterator;
   StaticAssertTypeEq<decltype(std::get<2>(rit)),
                      end_aware_iterator<m_iterator>>();
+
   using tup_i_i_i = std::tuple<int const &, int const &, int &>;
   StaticAssertTypeEq<decltype(*rit), tup_i_i_i>();
 }
@@ -74,9 +77,9 @@ TEST(RecursiveIteratorTest, CanAccessInternalIteratorsWithGet) {
       {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
   };
   auto rit = recursive_iterator(obj);
-  EXPECT_EQ(std::get<0>(rit), end_aware_iterator(obj));
-  EXPECT_EQ(std::get<1>(rit), end_aware_iterator(obj[1]));
-  EXPECT_EQ(std::get<2>(rit), end_aware_iterator(obj[1][0]));
+  EXPECT_THAT(std::get<0>(rit), end_aware_iterator(obj));
+  EXPECT_THAT(std::get<1>(rit), end_aware_iterator(obj[1]));
+  EXPECT_THAT(std::get<2>(rit), end_aware_iterator(obj[1][0]));
 }
 
 // TODO: This ought to be implemented as a compiles-test
@@ -96,11 +99,11 @@ TEST(RecursiveIteratorTest, EmptyCtorIsEnd) {
   };
   auto rit = recursive_iterator(obj);
 
-  EXPECT_NE(rit, iterator::sentinel);
-  EXPECT_EQ(ranges::distance(rit, iterator::sentinel), 4);
+  EXPECT_THAT(rit, Not(iterator::sentinel));
+  EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 4);
 
   std::advance(rit, 4);
-  EXPECT_EQ(rit, iterator::sentinel);
+  EXPECT_THAT(rit, iterator::sentinel);
 }
 
 TEST(BoundedRecursiveIteratorTest, CanStdGetToNLayersOfInternalIteration) {
@@ -109,12 +112,15 @@ TEST(BoundedRecursiveIteratorTest, CanStdGetToNLayersOfInternalIteration) {
       {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
   };
   auto rit = recursive_iterator(obj, bounded<2>{});
+
   using mvm_iterator = std::map<int, std::vector<std::map<int, int>>>::iterator;
   StaticAssertTypeEq<decltype(std::get<0>(rit)),
                      end_aware_iterator<mvm_iterator>>();
+
   using vm_iterator = std::vector<std::map<int, int>>::iterator;
   StaticAssertTypeEq<decltype(std::get<1>(rit)),
                      end_aware_iterator<vm_iterator>>();
+
   using tup_i_mii = std::tuple<int const &, std::map<int, int> &>;
   StaticAssertTypeEq<decltype(*rit), tup_i_mii>();
 }
@@ -125,8 +131,8 @@ TEST(BoundedRecursiveIteratorTest, CanAccessInternalIteratorsWithGet) {
       {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
   };
   auto rit = recursive_iterator(obj, bounded<2>{});
-  EXPECT_EQ(std::get<0>(rit), end_aware_iterator(obj));
-  EXPECT_EQ(std::get<1>(rit), end_aware_iterator(obj[1]));
+  EXPECT_THAT(std::get<0>(rit), end_aware_iterator(obj));
+  EXPECT_THAT(std::get<1>(rit), end_aware_iterator(obj[1]));
 }
 
 // TODO: This ought to be implemented as a compiles-test
@@ -145,11 +151,11 @@ TEST(BoundedRecursiveIteratorTest, EmptyCtorIsEnd) {
       {2, {{{3, 3}, {4, 4}}}}    // 1 2-element map
   };
   auto rit = recursive_iterator(obj, bounded<3>{});
-  EXPECT_NE(rit, iterator::sentinel);
-  EXPECT_EQ(ranges::distance(rit, iterator::sentinel), 4);
+  EXPECT_THAT(rit, Not(iterator::sentinel));
+  EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 4);
 
   std::advance(rit, 4);
-  EXPECT_EQ(rit, iterator::sentinel);
+  EXPECT_THAT(rit, iterator::sentinel);
 }
 
 TEST(BoundedRecursiveIteratorTest, CanFetchInnerCollections) {
@@ -158,5 +164,5 @@ TEST(BoundedRecursiveIteratorTest, CanFetchInnerCollections) {
       {{{{3, 3}, {4, 4}}}}    // 1 2-element map
   };
   auto rit = recursive_iterator(obj, bounded<2>{});
-  EXPECT_EQ(*rit, obj[0][0]);
+  EXPECT_THAT(*rit, obj[0][0]);
 }

test/recursive_iterator_map_test.cxx

@@ -13,24 +13,25 @@
 using iterator::bounded;
 using iterator::recursive_iterator;
 
+using testing::ElementsAreArray;
 using testing::IsEmpty;
 
 TEST(RecursiveIteratorMapTest, 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 = recursive_iterator(map);
-  EXPECT_EQ(std::get<3>(*rit), 1);
-  EXPECT_EQ(std::get<3>(*++rit), 2);
-  EXPECT_EQ(std::get<3>(*rit), 2);
+  EXPECT_THAT(std::get<3>(*rit), 1);
+  EXPECT_THAT(std::get<3>(*++rit), 2);
+  EXPECT_THAT(std::get<3>(*rit), 2);
 }
 
 TEST(RecursiveIteratorMapTest, 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 = recursive_iterator(map);
-  EXPECT_EQ(std::get<3>(*rit), 1);
-  EXPECT_EQ(std::get<3>(*rit++), 1);
-  EXPECT_EQ(std::get<3>(*rit), 2);
+  EXPECT_THAT(std::get<3>(*rit), 1);
+  EXPECT_THAT(std::get<3>(*rit++), 1);
+  EXPECT_THAT(std::get<3>(*rit), 2);
 }
 
 TEST(RecursiveIteratorMapTest, IterDistanceIsSumOfInnerContainerSizes) {
@@ -38,7 +39,7 @@ TEST(RecursiveIteratorMapTest, IterDistanceIsSumOfInnerContainerSizes) {
       {1, {{1, {{1, 1}}}}}, {2, {{2, {{2, 2}}}, {3, {{3, 3}, {4, 4}}}}}};
   auto rit = recursive_iterator(map);
 
-  EXPECT_EQ(ranges::distance(rit, iterator::sentinel), 4);
+  EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 4);
 }
 
 TEST(RecursiveIteratorMapTest, ElementsAreUnwrappedAsATuple) {
@@ -46,11 +47,9 @@ TEST(RecursiveIteratorMapTest, ElementsAreUnwrappedAsATuple) {
       {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}};
-  auto rit = recursive_iterator(map);
 
-  EXPECT_EQ((ranges::to<std::vector<std::tuple<int, int, int, int>>>(
-                rit, iterator::sentinel)),
-            expected);
+  EXPECT_THAT(map | views::recursive | ranges::to<std::vector>(),
+              ElementsAreArray(expected));
 }
 
 TEST(RecursiveIteratorMapTest, CanMutatePointedToData) {
@@ -58,25 +57,25 @@ TEST(RecursiveIteratorMapTest, CanMutatePointedToData) {
       {1, {{1, {{1, 1}}}}}, {2, {{2, {{2, 2}}}, {3, {{3, 3}, {4, 4}}}}}};
   auto rit = recursive_iterator(map);
   std::get<3>(*rit) = 4;
-  EXPECT_EQ(map[1][1][1], 4);
+  EXPECT_THAT(map[1][1][1], 4);
 }
 
 TEST(BoundRecursiveIteratorMapTest, 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 = recursive_iterator(map, bounded<2>{});
-  EXPECT_EQ(std::get<2>(*rit), map[1][1]);
-  EXPECT_EQ(std::get<2>(*++rit), map[2][2]);
-  EXPECT_EQ(std::get<2>(*rit), map[2][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(BoundRecursiveIteratorMapTest, 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 = recursive_iterator(map, bounded<2>{});
-  EXPECT_EQ(std::get<2>(*rit), map[1][1]);
-  EXPECT_EQ(std::get<2>(*rit++), map[1][1]);
-  EXPECT_EQ(std::get<2>(*rit), map[2][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(BoundRecursiveIteratorMapTest, IterDistanceSumOnNLayersSize) {
@@ -84,7 +83,7 @@ TEST(BoundRecursiveIteratorMapTest, IterDistanceSumOnNLayersSize) {
       {1, {{1, {{1, 1}}}}}, {2, {{2, {{2, 2}}}, {3, {{3, 3}, {4, 4}}}}}};
   auto rit = recursive_iterator(map, bounded<2>{});
 
-  EXPECT_EQ(ranges::distance(rit, iterator::sentinel), 3);
+  EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 3);
 }
 
 TEST(BoundRecursiveIteratorMapTest, ElementsAreUnwrappedAsATuple) {
@@ -93,9 +92,8 @@ TEST(BoundRecursiveIteratorMapTest, ElementsAreUnwrappedAsATuple) {
   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 | iterator::views::recursive_n<2> |
-                  std::ranges::to<std::vector>(),
-              testing::ElementsAreArray(expected));
+  EXPECT_THAT(map | views::recursive_n<2> | ranges::to<std::vector>(),
+              ElementsAreArray(expected));
 }
 
 TEST(BoundedRecursiveIteratorMapTest, CanMutatePointedToData) {

test/recursive_iterator_mixed_container_test.cxx

@@ -8,29 +8,29 @@
 
 using iterator::recursive_iterator;
 
+using testing::ElementsAreArray;
+
 TEST(RecursiveIteratorMapVectorTest, IterDistanceIsSumOfInnerContainerSizes) {
   std::map<int, std::vector<int>> const obj{{1, {1, 2}}, {2, {3, 4, 5}}};
   auto rit = recursive_iterator(obj);
 
-  EXPECT_EQ(ranges::distance(rit, iterator::sentinel), 5);
+  EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 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 = recursive_iterator(obj);
 
-  EXPECT_EQ(
-      (ranges::to<std::vector<std::tuple<int, int>>>(rit, iterator::sentinel)),
-      expected);
+  EXPECT_THAT(obj | views::recursive | ranges::to<std::vector>(),
+              ElementsAreArray(expected));
 }
 
 TEST(RecursiveIteratorMapVectorTest, CanMutatePointedToData) {
   std::map<int, std::vector<int>> obj{{1, {1, 2}}, {2, {3, 4, 5}}};
   auto rit = recursive_iterator(obj);
   std::get<1>(*rit) = 6;
-  EXPECT_EQ(obj[1][0], 6);
+  EXPECT_THAT(obj[1][0], 6);
 }
 
 TEST(RecursiveIteratorMapMapVectorTest, CanMutatePointedToData) {
@@ -38,7 +38,7 @@ TEST(RecursiveIteratorMapMapVectorTest, CanMutatePointedToData) {
                                                      {2, {{1, {3, 4, 5}}}}};
   auto rit = recursive_iterator(obj);
   std::get<2>(*rit) = 6;
-  EXPECT_EQ(obj[1][1][0], 6);
+  EXPECT_THAT(obj[1][1][0], 6);
 }
 
 TEST(RecursiveIteratorVectorMapTest, IterDistanceIsSumOfInnerContainerSizes) {
@@ -46,7 +46,7 @@ TEST(RecursiveIteratorVectorMapTest, IterDistanceIsSumOfInnerContainerSizes) {
                                             {{3, 3}, {4, 4}, {5, 5}}};
   auto rit = recursive_iterator(obj);
 
-  EXPECT_EQ(ranges::distance(rit, iterator::sentinel), 5);
+  EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 5);
 }
 
 TEST(RecursiveIteratorVectorMapTest, ElementsAreUnwrappedAsATuple) {
@@ -54,11 +54,9 @@ TEST(RecursiveIteratorVectorMapTest, ElementsAreUnwrappedAsATuple) {
                                             {{3, 3}, {4, 4}, {5, 5}}};
   std::vector<std::pair<int, int>> const expected{
       {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};
-  auto rit = recursive_iterator(obj);
 
-  EXPECT_EQ(
-      (ranges::to<std::vector<std::pair<int, int>>>(rit, iterator::sentinel)),
-      expected);
+  EXPECT_THAT(obj | views::recursive | ranges::to<std::vector>(),
+              ElementsAreArray(expected));
 }
 
 TEST(RecursiveIteratorVectorMapTest, CanMutatePointedToData) {
@@ -66,7 +64,7 @@ TEST(RecursiveIteratorVectorMapTest, CanMutatePointedToData) {
                                       {{3, 3}, {4, 4}, {5, 5}}};
   auto rit = recursive_iterator(obj);
   std::get<1>(*rit) = 6;
-  EXPECT_EQ(obj[0][1], 6);
+  EXPECT_THAT(obj[0][1], 6);
 }
 
 TEST(RecursiveIteratorMapVecMapTest, IterDistanceIsSumOfInnerContainerSizes) {
@@ -75,7 +73,7 @@ TEST(RecursiveIteratorMapVecMapTest, IterDistanceIsSumOfInnerContainerSizes) {
   std::vector<std::tuple<int, int, int>> const expected{{1, 1, 1}, {1, 2, 2}};
   auto rit = recursive_iterator(obj);
 
-  EXPECT_EQ(ranges::distance(rit, iterator::sentinel), expected.size());
+  EXPECT_THAT(ranges::distance(rit, iterator::sentinel), expected.size());
 }
 
 TEST(RecursiveIteratorMapVecMapTest, ElementsAreUnwrappedAsATuple) {
@@ -84,16 +82,15 @@ TEST(RecursiveIteratorMapVecMapTest, ElementsAreUnwrappedAsATuple) {
   std::vector<std::tuple<int, int, int>> const expected{{1, 1, 1}, {1, 2, 2}};
   auto rit = recursive_iterator(obj);
 
-  EXPECT_EQ((ranges::to<std::vector<std::tuple<int, int, int>>>(
-                rit, iterator::sentinel)),
-            expected);
+  EXPECT_THAT(obj | views::recursive | ranges::to<std::vector>(),
+              ElementsAreArray(expected));
 }
 
 TEST(RecursiveIteratorMapVecMapTest, CanMutatePointedToData) {
   std::map<int, std::vector<std::map<int, int>>> obj{{1, {{{1, 1}, {2, 2}}}}};
   auto rit = recursive_iterator(obj);
   std::get<2>(*rit) = 4;
-  EXPECT_EQ(obj[1][0][1], 4);
+  EXPECT_THAT(obj[1][0][1], 4);
 }
 
 TEST(RecursiveIteratorVecMapVecTest, IterDistanceIsSumOfInnerContainerSizes) {
@@ -101,7 +98,7 @@ TEST(RecursiveIteratorVecMapVecTest, IterDistanceIsSumOfInnerContainerSizes) {
       {{1, {1, 2}}, {2, {3, 4, 5}}}, {{1, {3, 4}}}};
   auto rit = recursive_iterator(obj);
 
-  EXPECT_EQ(ranges::distance(rit, iterator::sentinel), 7);
+  EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 7);
 }
 
 TEST(RecursiveIteratorVecMapVecTest, ElementsAreUnwrappedAsATuple) {
@@ -109,11 +106,9 @@ TEST(RecursiveIteratorVecMapVecTest, ElementsAreUnwrappedAsATuple) {
       {{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 = recursive_iterator(obj);
 
-  EXPECT_EQ(
-      (ranges::to<std::vector<std::tuple<int, int>>>(rit, iterator::sentinel)),
-      expected);
+  EXPECT_THAT(obj | views::recursive | ranges::to<std::vector>(),
+              ElementsAreArray(expected));
 }
 
 TEST(RecursiveIteratorVecMapVecTest, CanMutatePointedToData) {
@@ -121,5 +116,6 @@ TEST(RecursiveIteratorVecMapVecTest, CanMutatePointedToData) {
       {{1, {1, 2}}, {2, {3, 4, 5}}}, {{1, {3, 4}}}};
   auto rit = recursive_iterator(obj);
   std::get<1>(*rit) = 6;
-  EXPECT_EQ(obj[0][1][0], 6);
+
+  EXPECT_THAT(obj[0][1][0], 6);
 }

test/recursive_iterator_single_level_test.cxx

@@ -16,6 +16,8 @@
 
 using iterator::recursive_iterator;
 
+using testing::ElementsAreArray;
+
 TEST(RecursiveIteratorSingleVectorTest, IterDistanceIsContainerSize) {
   std::vector<int> const vec{1, 2, 3, 4, 5};
   auto rit = recursive_iterator(vec);
@@ -25,9 +27,9 @@ TEST(RecursiveIteratorSingleVectorTest, IterDistanceIsContainerSize) {
 
 TEST(RecursiveIteratorSingleVectorTest, DataMatchesContainerIterator) {
   std::vector<int> const vec{1, 2, 3, 4, 5};
-  auto rit = recursive_iterator(vec);
 
-  EXPECT_THAT(ranges::to<std::vector<int>>(rit, iterator::sentinel), vec);
+  EXPECT_THAT(vec | views::recursive | ranges::to<std::vector>(),
+              ElementsAreArray(vec));
 }
 
 TEST(RecursiveIteratorSingleVectorTest, CanMutatePointedToData) {
@@ -46,9 +48,8 @@ TEST(RecursiveIteratorSingleMapTest, IterDistanceIsContainerSize) {
 
 TEST(RecursiveIteratorSingleMapTest, DataMatchesContainerIterator) {
   std::map<int, int> const map{{1, 1}, {2, 2}, {3, 3}};
-  auto rit = recursive_iterator(map);
 
-  EXPECT_THAT((ranges::to<std::map<int, int>>(rit, iterator::sentinel)), map);
+  EXPECT_THAT((map | views::recursive | ranges::to<std::map<int, int>>()), map);
 }
 
 TEST(RecursiveIteratorSingleMapTest, CanMutatePointedToData) {

test/recursive_iterator_vector_test.cxx

@@ -10,6 +10,7 @@
 using iterator::bounded;
 using iterator::recursive_iterator;
 
+using testing::ElementsAreArray;
 using testing::IsEmpty;
 
 TEST(RecursiveIteratorVecTest, PreIncrementAdvancesIterator) {
@@ -37,10 +38,10 @@ TEST(RecursiveIteratorVecTest, IterDistanceIsSumOfInnerContainerSizes) {
 
 TEST(RecursiveIteratorVecTest, FlattensVectorDataLikeJoinIterator) {
   std::vector<std::vector<std::vector<int>>> const vec{{{1, 2}}, {{3}, {4, 5}}};
-  auto rit = recursive_iterator(vec);
 
   std::vector<int> const expected{1, 2, 3, 4, 5};
-  EXPECT_THAT(ranges::to<std::vector<int>>(rit, iterator::sentinel), expected);
+  EXPECT_THAT(vec | views::recursive | ranges::to<std::vector>(),
+              ElementsAreArray(expected));
 }
 
 TEST(RecursiveIteratorVecTest, CanMutatePointedToData) {
@@ -75,12 +76,10 @@ TEST(BoundedRecursiveIteratorVecTest, IterDistanceSumOnNLayersSize) {
 
 TEST(BoundedRecursiveIteratorVecTest, ElementsAreUnwrappedAsATuple) {
   std::vector<std::vector<std::vector<int>>> const vec{{{1, 2}}, {{3}, {4, 5}}};
-  auto rit = recursive_iterator(vec, bounded<2>{});
 
   std::vector<std::vector<int>> const expected{{1, 2}, {3}, {4, 5}};
-  EXPECT_THAT(
-      ranges::to<std::vector<std::vector<int>>>(rit, iterator::sentinel),
-      expected);
+  EXPECT_THAT(vec | views::recursive_n<2> | ranges::to<std::vector>(),
+              ElementsAreArray(expected));
 }
 
 TEST(BoundedRecursiveIteratorVecTest, CanMutatePointedToData) {