refactor: rename test fixtures, fix some typos

include/iterator/enumerate_iterator.h

@@ -71,7 +71,7 @@ public:
   }
 
 private:
-  template <typename O> friend class indexed_iterator;
+  template <typename O> friend class EnumerateIterator;
   It base_;
   size_t index_{0};
 };

include/iterator/join_iterator.h

@@ -42,7 +42,7 @@ public:
     safely_init_inner_iterator(other.outer_, other.inner_);
   }
 
-  JoinIterator(Range auto & container) : outer_(FWD(container)) {
+  JoinIterator(Range auto & rng) : outer_(std::forward<decltype(rng)>(rng)) {
     update_iterator();
   }
 

test/capture_iterator_test.cxx

@@ -11,7 +11,7 @@
 #include "ranges.h"
 #include "xcode_gtest_helper.h"
 
-using iterator::capture_iterator;
+using iterator::CaptureIterator;
 
 using testing::Address;
 using testing::ElementsAre;
@@ -36,7 +36,7 @@ TEST(CaptureIterator, UnderlyingReturnsUnique) {
 }
 
 TEST(CaptureIterator, CachesValue) {
-  auto it = capture_iterator(fake_iterator());
+  auto it = CaptureIterator(fake_iterator());
 
   auto const & result = *it;
   EXPECT_THAT(*it, Address(&result));

test/end_aware_iterator_test.cxx

@@ -26,14 +26,14 @@ TEST(EndAwareIterator, CanCastCompatibleIterators) {
 TEST(EndAwareIterator, BeginWrapperIsEqualToBegin) {
   std::vector<int> v{1, 2, 3, 4, 5};
 
-  EXPECT_EQ(*v.begin(), *EndAwareIterator(v.begin(), v.end()));
+  EXPECT_THAT(*v.begin(), *EndAwareIterator(v.begin(), v.end()));
 }
 
 TEST(EndAwareIterator, MutableActionsArePassthrough) {
   std::vector<int> v{1, 2, 3, 4, 5};
   *EndAwareIterator(v.begin(), v.end()) = -1;
 
-  EXPECT_EQ(v[0], -1);
+  EXPECT_THAT(v[0], -1);
 }
 
 TEST(EndAwareIterator, CanTellYouThatItsReachedEnd) {
@@ -41,7 +41,7 @@ TEST(EndAwareIterator, CanTellYouThatItsReachedEnd) {
   EndAwareIterator it{v.end() - 1, v.end()};
   EXPECT_FALSE(it.at_end());
   ++it;
-  EXPECT_EQ(it, EndAwareIterator(v.end(), v.end()));
+  EXPECT_THAT(it, EndAwareIterator(v.end(), v.end()));
   EXPECT_TRUE(it.at_end());
 }
 
@@ -53,18 +53,18 @@ TEST(EndAwareIterator, PreIncrementAdvancesIterator) {
   std::vector<int> v{1, 2, 3, 4, 5};
   EndAwareIterator eai(v.begin(), v.end());
 
-  EXPECT_EQ(*eai, 1);
-  EXPECT_EQ(*++eai, 2);
-  EXPECT_EQ(*eai, 2);
+  EXPECT_THAT(*eai, 1);
+  EXPECT_THAT(*++eai, 2);
+  EXPECT_THAT(*eai, 2);
 }
 
 TEST(EndAwareIterator, PostIncrementReturnsCopyOfPrev) {
   std::vector<int> v{1, 2, 3, 4, 5};
   EndAwareIterator eai(v.begin(), v.end());
 
-  EXPECT_EQ(*eai, 1);
-  EXPECT_EQ(*eai++, 1);
-  EXPECT_EQ(*eai, 2);
+  EXPECT_THAT(*eai, 1);
+  EXPECT_THAT(*eai++, 1);
+  EXPECT_THAT(*eai, 2);
 }
 
 TEST(EndAwareIterator, CanIterateWithSentinel) {
@@ -74,5 +74,5 @@ TEST(EndAwareIterator, CanIterateWithSentinel) {
     ++count;
   }
 
-  EXPECT_EQ(count, 5);
+  EXPECT_THAT(count, 5);
 }

test/enumerate_iterator_test.cxx

@@ -18,19 +18,19 @@ using testing::Lt;
 using testing::Ne;
 
 // TODO: This ought to be implemented as a compiles-test
-TEST(IndexedIteratorTest, CanCastCompatibleIterators) {
+TEST(EnumerateIteartor, CanCastCompatibleIterators) {
   std::vector<int> v{1, 2, 3, 4, 5};
   EnumerateIterator eai(v.begin());
   EnumerateIterator<std::vector<int>::const_iterator>{eai};
 }
 
-TEST(IndexedIteratorTest, CanLieAboutIndex) {
+TEST(EnumerateIteartor, CanLieAboutIndex) {
   std::vector<int> vec{5, 3, 2, 8, 9, 11, 2, 4};
   EnumerateIterator it(vec.begin(), 3);
   EXPECT_THAT(it->first, 3);
 }
 
-TEST(IndexedIteratorTest, FakeIndexDoesntEffectEqualityCheck) {
+TEST(EnumerateIteartor, FakeIndexDoesntEffectEqualityCheck) {
   std::vector<int> vec{5, 3, 2, 8, 9, 11, 2, 4};
   EXPECT_THAT(EnumerateIterator(vec.begin()),
               EnumerateIterator(vec.begin(), 3));
@@ -38,20 +38,20 @@ TEST(IndexedIteratorTest, FakeIndexDoesntEffectEqualityCheck) {
               Ne(EnumerateIterator(vec.begin(), 3)));
 }
 
-TEST(IndexedIteratorTest, DoesNotTrackByIndex) {
+TEST(EnumerateIteartor, DoesNotTrackByIndex) {
   std::vector<int> vec{5, 3, 2, 8, 9, 11, 2, 4};
   EnumerateIterator end(vec.end());
   EXPECT_THAT(decltype(end){}, Ne(end));
 }
 
-TEST(IndexedIteratorTest, IteratorPropagatesAtEnd) {
+TEST(EnumerateIteartor, IteratorPropagatesAtEnd) {
   std::vector<int> vec{5, 3, 2, 8, 9, 11, 2, 4};
   EnumerateIterator end(EndAwareIterator(vec.end(), vec.end()));
 
-  EXPECT_EQ(end, iterator::sentinel);
+  EXPECT_THAT(end, iterator::sentinel);
 }
 
-TEST(IndexedIteratorTest, CanCompareIteratorOrder) {
+TEST(EnumerateIteartor, CanCompareIteratorOrder) {
   std::vector<int> vec{5, 3, 2, 8, 9, 11, 2, 4};
   EnumerateIterator const begin(vec.begin());
   EnumerateIterator const it = begin + 3;
@@ -64,7 +64,7 @@ TEST(IndexedIteratorTest, CanCompareIteratorOrder) {
   EXPECT_THAT(it, Ge(it));
 }
 
-TEST(IndexedIteratorTest, PreIncrementAdvancesIterator) {
+TEST(EnumerateIteartor, PreIncrementAdvancesIterator) {
   std::vector<int> vec{5, 3, 2, 8, 9, 11, 2, 4};
   EnumerateIterator it(vec.begin() + 1);
   EXPECT_THAT(it->second, 3);
@@ -72,7 +72,7 @@ TEST(IndexedIteratorTest, PreIncrementAdvancesIterator) {
   EXPECT_THAT(it->second, 2);
 }
 
-TEST(IndexedIteratorTest, PostIncrementReturnsCopyOfPrev) {
+TEST(EnumerateIteartor, PostIncrementReturnsCopyOfPrev) {
   std::vector<int> vec{5, 3, 2, 8, 9, 11, 2, 4};
   EnumerateIterator it(vec.begin() + 1);
   EXPECT_THAT(it->second, 3);
@@ -80,7 +80,7 @@ TEST(IndexedIteratorTest, PostIncrementReturnsCopyOfPrev) {
   EXPECT_THAT(it->second, 2);
 }
 
-TEST(IndexedIteratorTest, PreDecrementAdvancesIterator) {
+TEST(EnumerateIteartor, PreDecrementAdvancesIterator) {
   std::vector<int> vec{5, 3, 2, 8, 9, 11, 2, 4};
   EnumerateIterator it(vec.begin() + 1);
   EXPECT_THAT(it->second, 3);
@@ -88,7 +88,7 @@ TEST(IndexedIteratorTest, PreDecrementAdvancesIterator) {
   EXPECT_THAT(it->second, 5);
 }
 
-TEST(IndexedIteratorTest, PostDecrementReturnsCopyOfPrev) {
+TEST(EnumerateIteartor, PostDecrementReturnsCopyOfPrev) {
   std::vector<int> vec{5, 3, 2, 8, 9, 11, 2, 4};
   EnumerateIterator it(vec.begin() + 1);
   EXPECT_THAT(it->second, 3);
@@ -96,7 +96,7 @@ TEST(IndexedIteratorTest, PostDecrementReturnsCopyOfPrev) {
   EXPECT_THAT(it->second, 5);
 }
 
-TEST(IndexedIteratorTest, CanWalkNStepsForward) {
+TEST(EnumerateIteartor, CanWalkNStepsForward) {
   std::vector<int> vec{5, 3, 2, 8, 9, 11, 2, 4};
   EnumerateIterator const begin(vec.begin());
   EnumerateIterator it = begin;
@@ -104,7 +104,7 @@ TEST(IndexedIteratorTest, CanWalkNStepsForward) {
   EXPECT_THAT(ranges::distance(begin, it), 4);
 }
 
-TEST(IndexedIteratorTest, CanWalkNStepsBackwards) {
+TEST(EnumerateIteartor, CanWalkNStepsBackwards) {
   std::vector<int> vec{5, 3, 2, 8, 9, 11, 2, 4};
   EnumerateIterator const end(vec.end());
   EnumerateIterator it = end;
@@ -112,7 +112,7 @@ TEST(IndexedIteratorTest, CanWalkNStepsBackwards) {
   EXPECT_THAT(ranges::distance(it, end), 4);
 }
 
-TEST(IndexedIteratorTest, RandomAccessIsPassthrough) {
+TEST(EnumerateIteartor, RandomAccessIsPassthrough) {
   std::vector<int> vec{5, 3, 2, 8, 9, 11, 2, 4};
   EXPECT_THAT(EnumerateIterator(vec.begin()) + 4,
               EnumerateIterator(vec.begin() + 4));
@@ -120,7 +120,7 @@ TEST(IndexedIteratorTest, RandomAccessIsPassthrough) {
               EnumerateIterator(vec.end() - 4));
 }
 
-TEST(IndexedIteratorTest, TreatsVectorIteratorAsPairIdxValue) {
+TEST(EnumerateIteartor, TreatsVectorIteratorAsPairIdxValue) {
   std::vector<int> vec{5, 3, 2, 8, 9, 11, 2, 4};
   std::vector<std::pair<int, int>> const expected{
       {0, 5}, {1, 3}, {2, 2}, {3, 8}, {4, 9}, {5, 11}, {6, 2}, {7, 4}};
@@ -130,7 +130,7 @@ TEST(IndexedIteratorTest, TreatsVectorIteratorAsPairIdxValue) {
   EXPECT_THAT(result, expected);
 }
 
-TEST(IndexedIteratorTest, TreatsVectorIteratorAsMapIdxToValue) {
+TEST(EnumerateIteartor, TreatsVectorIteratorAsMapIdxToValue) {
   std::vector<int> vec{5, 3, 2, 8, 9, 11, 2, 4};
   std::map<int, int> const expected{{0, 5}, {1, 3},  {2, 2}, {3, 8},
                                     {4, 9}, {5, 11}, {6, 2}, {7, 4}};
@@ -140,7 +140,7 @@ TEST(IndexedIteratorTest, TreatsVectorIteratorAsMapIdxToValue) {
   EXPECT_THAT(result, expected);
 }
 
-TEST(IndexedIteratorTest, CanMutatePointedToData) {
+TEST(EnumerateIteartor, CanMutatePointedToData) {
   std::vector<int> vec{5, 3, 2, 8, 9, 11, 2, 4};
   EnumerateIterator(vec.begin() + 4, 4)->second = -1;
   EXPECT_THAT(vec[4], -1);

test/filter_iterator_test.cxx

@@ -13,9 +13,9 @@ TEST(FilterIterator, CanPerformSkipsOnData) {
   std::vector<int> const data = {1, 2, 3, 4, 5};
   FilterIterator it(data, is_even);
 
-  EXPECT_EQ(ranges::distance(it, iterator::sentinel), 2);
-  EXPECT_EQ(*it++, 2);
-  EXPECT_EQ(*it++, 4);
+  EXPECT_THAT(ranges::distance(it, iterator::sentinel), 2);
+  EXPECT_THAT(*it++, 2);
+  EXPECT_THAT(*it++, 4);
 }
 
 // TODO: Maybe this should actually move
@@ -23,25 +23,25 @@ TEST(FilterIterator, MutatingContainerDoesNotMoveIterator) {
   std::vector<int> data = {1, 2, 3, 4, 5};
   FilterIterator it(data, is_even);
 
-  EXPECT_EQ(ranges::distance(it, iterator::sentinel), 2);
+  EXPECT_THAT(ranges::distance(it, iterator::sentinel), 2);
 
   *it = 1;
-  EXPECT_EQ(ranges::distance(it, iterator::sentinel), 2);
-  EXPECT_EQ(*it, 1);
+  EXPECT_THAT(ranges::distance(it, iterator::sentinel), 2);
+  EXPECT_THAT(*it, 1);
 }
 
 TEST(FilterIterator, CanConstructFilterFromSubRange) {
   std::vector<int> data = {1, 2, 3, 4, 5};
   FilterIterator it(data.begin(), data.begin() + 3, is_even);
 
-  EXPECT_EQ(ranges::distance(it, iterator::sentinel), 1);
+  EXPECT_THAT(ranges::distance(it, iterator::sentinel), 1);
 }
 
 TEST(FilterIterator, IfNonMatchThenStartIsEnd) {
   std::vector<int> const data = {1, 3, 5};
   FilterIterator it(data, is_even);
 
-  EXPECT_EQ(it, iterator::sentinel);
+  EXPECT_THAT(it, iterator::sentinel);
 }
 
 TEST(FilterIterator, CapsIterationAtEnd) {
@@ -49,10 +49,10 @@ TEST(FilterIterator, CapsIterationAtEnd) {
   FilterIterator it(data, is_even);
 
   ++ ++it;
-  EXPECT_EQ(it, iterator::sentinel);
+  EXPECT_THAT(it, iterator::sentinel);
 
   ++it;
-  EXPECT_EQ(it, iterator::sentinel);
+  EXPECT_THAT(it, iterator::sentinel);
 }
 
 TEST(FilterIterator, CanIterateWithSentinel) {
@@ -62,5 +62,5 @@ TEST(FilterIterator, CanIterateWithSentinel) {
     ++count;
   }
 
-  EXPECT_EQ(count, 2);
+  EXPECT_THAT(count, 2);
 }

test/join_iterator_test.cxx

@@ -7,71 +7,73 @@
 using iterator::EndAwareIterator;
 using iterator::JoinIterator;
 
-TEST(JoinIteratorTest, FirstDereferencedElemIsTheFirstInTheChain) {
+using testing::Not;
+
+TEST(JoinIterator, FirstDereferencedElemIsTheFirstInTheChain) {
   std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
-  EXPECT_EQ(*JoinIterator(mv), mv[0][0]);
+  EXPECT_THAT(*JoinIterator(mv), mv[0][0]);
 }
 
-TEST(JoinIteratorTest, HoldsReferenceToContainedElements) {
+TEST(JoinIterator, HoldsReferenceToContainedElements) {
   std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
-  EXPECT_EQ(JoinIterator(mv).operator->(), &mv[0][0]);
+  EXPECT_THAT(JoinIterator(mv).operator->(), &mv[0][0]);
 }
 
-TEST(JoinIteratorTest, EmptyContainerBeginIsEnd) {
+TEST(JoinIterator, EmptyContainerBeginIsEnd) {
   std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
   JoinIterator it(mv);
-  EXPECT_NE(it, iterator::sentinel);
+  EXPECT_THAT(it, Not(iterator::sentinel));
 
   mv.clear();
-  EXPECT_EQ(JoinIterator(mv), iterator::sentinel);
+  EXPECT_THAT(JoinIterator(mv), iterator::sentinel);
 }
 
 // TODO: This ought to be implemented as a compiles-test
-TEST(JoinIteratorTest, CanCastCompatibleIterators) {
+TEST(JoinIterator, CanCastCompatibleIterators) {
   std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
   JoinIterator it(mv);
   iterator::JoinIterator<decltype(mv)::const_iterator>{it};
 }
 
-TEST(JoinIteratorTest, CanAccessInternalIterator) {
+TEST(JoinIterator, CanAccessInternalIterator) {
   std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
   auto eai = EndAwareIterator(mv);
   JoinIterator it(eai);
-  EXPECT_EQ(it.outer_iterator(), eai);
+  EXPECT_THAT(it.outer_iterator(), eai);
 }
 
-TEST(JoinIteratorTest, CanAccessChildIterator) {
+TEST(JoinIterator, CanAccessChildIterator) {
   std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
   JoinIterator it(mv);
-  EXPECT_EQ(it.inner_iterator(), EndAwareIterator(mv[0]));
+  EXPECT_THAT(it.inner_iterator(), EndAwareIterator(mv[0]));
 }
 
-TEST(JoinIteratorTest, PreIncrementAdvancesIterator) {
+TEST(JoinIterator, PreIncrementAdvancesIterator) {
   std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
   JoinIterator it(mv);
-  EXPECT_EQ(*it, 1);
-  EXPECT_EQ(*++it, 2);
-  EXPECT_EQ(*it, 2);
+  EXPECT_THAT(*it, 1);
+  EXPECT_THAT(*++it, 2);
+  EXPECT_THAT(*it, 2);
 }
 
-TEST(JoinIteratorTest, PostIncrementReturnsCopyOfPrev) {
+TEST(JoinIterator, PostIncrementReturnsCopyOfPrev) {
   std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
   JoinIterator it(mv);
-  EXPECT_EQ(*it, 1);
-  EXPECT_EQ(*it++, 1);
-  EXPECT_EQ(*it, 2);
+  EXPECT_THAT(*it, 1);
+  EXPECT_THAT(*it++, 1);
+  EXPECT_THAT(*it, 2);
 }
 
-TEST(JoinIteratorTest, MovesFromListToListWhenReachingEnd) {
+TEST(JoinIterator, MovesFromListToListWhenReachingEnd) {
   std::vector<std::vector<int>> mv{{1, 2, 3}, {4, 5, 6}};
   JoinIterator it(mv);
   std::advance(it, 2);
-  EXPECT_EQ(*++it, mv[1][0]);
+  EXPECT_THAT(*++it, mv[1][0]);
 }
 
-TEST(JoinIteratorTest, SkipsOverEmptyElements) {
+TEST(JoinIterator, SkipsOverEmptyElements) {
   std::vector<std::vector<int>> mv{{1, 2, 3}, {}, {4, 5, 6}};
   JoinIterator it(mv);
   std::advance(it, 2);
-  EXPECT_EQ(*++it, mv[2][0]);
+  EXPECT_THAT(*++it, mv[2][0]);
 }

test/projecting_recursive_iterator_test.cxx

@@ -31,27 +31,27 @@ struct Foo {
   std::vector<Bar> bars_copy() { return bars_; }
 };
 
-TEST(CascadeIteratorTest, OneProjectorIsTwoLevels) {
+TEST(ProjectingRecursiveIterator, OneProjectorIsTwoLevels) {
   std::vector<Foo> foos;
   auto iter = ProjectingRecursiveIterator(foos, &Foo::bars);
   testing::StaticAssertTypeEq<decltype(*iter), Bar const &>();
 }
 
-TEST(CascadeIteratorTest, TwoProjectorIsThreeLevels) {
+TEST(ProjectingRecursiveIterator, TwoProjectorIsThreeLevels) {
   std::vector<Foo> foos;
   auto iter = ProjectingRecursiveIterator(foos, &Foo::bars, &Bar::bazes);
   testing::StaticAssertTypeEq<decltype(*iter),
                               std::tuple<int const &, Baz const &>>();
 }
 
-TEST(CascadeIteratorTest, IsRvalueSafe) {
+TEST(ProjectingRecursiveIterator, IsRvalueSafe) {
   std::vector<Foo> foos;
   auto iter = ProjectingRecursiveIterator(foos, &Foo::bars_copy, &Bar::bazes);
   testing::StaticAssertTypeEq<decltype(*iter),
                               std::tuple<int const &, Baz const &>>();
 }
 
-TEST(CascadeIteratorTest, CanProjectUnboundedTail) {
+TEST(ProjectingRecursiveIterator, CanProjectUnboundedTail) {
   std::vector<Foo> foos;
   auto iter =
       ProjectingRecursiveIterator(foos, iterator::unbounded{}, &Foo::example);
@@ -62,7 +62,7 @@ TEST(CascadeIteratorTest, CanProjectUnboundedTail) {
       decltype(*iter), std::tuple<int const &, std::string const &, int &>>();
 }
 
-TEST(CascadeIteratorTest, CanProjectBoundedTail) {
+TEST(ProjectingRecursiveIterator, CanProjectBoundedTail) {
   std::vector<Foo> foos;
   auto iter =
       ProjectingRecursiveIterator(foos, iterator::bounded<3>{}, &Foo::example);

test/recursive_iterator_accessors_test.cxx

@@ -16,7 +16,7 @@ using testing::ElementsAreArray;
 using testing::Not;
 using testing::StaticAssertTypeEq;
 
-TEST(RecursiveIteratorTest, DoesNotUnwrapString) {
+TEST(RecursiveIterator, DoesNotUnwrapString) {
   std::vector<std::string> obj{"A", "B", "C", "D"};
   auto rit = RecursiveIterator(obj);
   StaticAssertTypeEq<decltype(rit.operator->()), std::string *>();
@@ -25,14 +25,14 @@ TEST(RecursiveIteratorTest, DoesNotUnwrapString) {
               ElementsAreArray(obj));
 }
 
-TEST(RecursiveIteratorTest, CanArrowMultiVector) {
+TEST(RecursiveIterator, CanArrowMultiVector) {
   std::vector<std::vector<int>> obj{{{0, 1}}, {{2, 3}}};
   auto rit = RecursiveIterator(obj);
   StaticAssertTypeEq<decltype(rit.operator->()), int *>();
   EXPECT_THAT(rit.operator->(), &obj[0][0]);
 }
 
-TEST(RecursiveIteratorTest, CanAccessOuterterator) {
+TEST(RecursiveIterator, CanAccessOuterterator) {
   std::map<int, std::vector<int>> obj{{1, {{0, 1}}}, {2, {{2, 3}}}};
   auto rit = RecursiveIterator(obj);
 
@@ -40,7 +40,7 @@ TEST(RecursiveIteratorTest, CanAccessOuterterator) {
   EXPECT_THAT(&std::get<0>(*rit), &(inner->first));
 }
 
-TEST(RecursiveIteratorTest, CanAccessInnerIterator) {
+TEST(RecursiveIterator, CanAccessInnerIterator) {
   std::map<int, std::vector<int>> obj{{1, {{0, 1}}}, {2, {{2, 3}}}};
   auto rit = RecursiveIterator(obj);
 
@@ -48,7 +48,7 @@ TEST(RecursiveIteratorTest, CanAccessInnerIterator) {
   EXPECT_THAT(&std::get<1>(*rit), &*inner);
 }
 
-TEST(RecursiveIteratorTest, CanStdGetToAllLayersOfInternalIteration) {
+TEST(RecursiveIterator, 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
@@ -71,7 +71,7 @@ TEST(RecursiveIteratorTest, CanStdGetToAllLayersOfInternalIteration) {
   StaticAssertTypeEq<decltype(*rit), tup_i_i_i>();
 }
 
-TEST(RecursiveIteratorTest, CanAccessInternalIteratorsWithGet) {
+TEST(RecursiveIterator, CanAccessInternalIteratorsWithGet) {
   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
@@ -83,7 +83,7 @@ TEST(RecursiveIteratorTest, CanAccessInternalIteratorsWithGet) {
 }
 
 // TODO: This ought to be implemented as a compiles-test
-TEST(RecursiveIteratorTest, CanCastCompatibleIterators) {
+TEST(RecursiveIterator, CanCastCompatibleIterators) {
   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
@@ -92,7 +92,7 @@ TEST(RecursiveIteratorTest, CanCastCompatibleIterators) {
   iterator::RecursiveIterator<decltype(obj)::const_iterator> cit(rit);
 }
 
-TEST(RecursiveIteratorTest, EmptyCtorIsEnd) {
+TEST(RecursiveIterator, EmptyCtorIsEnd) {
   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
@@ -106,7 +106,7 @@ TEST(RecursiveIteratorTest, EmptyCtorIsEnd) {
   EXPECT_THAT(rit, iterator::sentinel);
 }
 
-TEST(BoundedRecursiveIteratorTest, CanStdGetToNLayersOfInternalIteration) {
+TEST(RecursiveIterator_Bounded, CanStdGetToNLayersOfInternalIteration) {
   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
@@ -125,7 +125,7 @@ TEST(BoundedRecursiveIteratorTest, CanStdGetToNLayersOfInternalIteration) {
   StaticAssertTypeEq<decltype(*rit), tup_i_mii>();
 }
 
-TEST(BoundedRecursiveIteratorTest, CanAccessInternalIteratorsWithGet) {
+TEST(RecursiveIterator_Bounded, CanAccessInternalIteratorsWithGet) {
   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
@@ -136,7 +136,7 @@ TEST(BoundedRecursiveIteratorTest, CanAccessInternalIteratorsWithGet) {
 }
 
 // TODO: This ought to be implemented as a compiles-test
-TEST(BoundedRecursiveIteratorTest, CanCastCompatibleIterators) {
+TEST(RecursiveIterator_Bounded, CanCastCompatibleIterators) {
   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
@@ -145,7 +145,7 @@ TEST(BoundedRecursiveIteratorTest, CanCastCompatibleIterators) {
   iterator::RecursiveIteratorN<decltype(obj)::const_iterator, 2> cit(rit);
 }
 
-TEST(BoundedRecursiveIteratorTest, EmptyCtorIsEnd) {
+TEST(RecursiveIterator_Bounded, EmptyCtorIsEnd) {
   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
@@ -158,7 +158,7 @@ TEST(BoundedRecursiveIteratorTest, EmptyCtorIsEnd) {
   EXPECT_THAT(rit, iterator::sentinel);
 }
 
-TEST(BoundedRecursiveIteratorTest, CanFetchInnerCollections) {
+TEST(RecursiveIterator_Bounded, 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

test/recursive_iterator_map_test.cxx

@@ -16,7 +16,7 @@ using iterator::RecursiveIterator;
 using testing::ElementsAreArray;
 using testing::IsEmpty;
 
-TEST(RecursiveIteratorMapTest, PreIncrementAdvancesIterator) {
+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);
@@ -25,7 +25,7 @@ TEST(RecursiveIteratorMapTest, PreIncrementAdvancesIterator) {
   EXPECT_THAT(std::get<3>(*rit), 2);
 }
 
-TEST(RecursiveIteratorMapTest, PostIncrementReturnsCopyOfPrev) {
+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);
@@ -34,7 +34,7 @@ TEST(RecursiveIteratorMapTest, PostIncrementReturnsCopyOfPrev) {
   EXPECT_THAT(std::get<3>(*rit), 2);
 }
 
-TEST(RecursiveIteratorMapTest, IterDistanceIsSumOfInnerContainerSizes) {
+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);
@@ -42,7 +42,7 @@ TEST(RecursiveIteratorMapTest, IterDistanceIsSumOfInnerContainerSizes) {
   EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 4);
 }
 
-TEST(RecursiveIteratorMapTest, ElementsAreUnwrappedAsATuple) {
+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{
@@ -52,7 +52,7 @@ TEST(RecursiveIteratorMapTest, ElementsAreUnwrappedAsATuple) {
               ElementsAreArray(expected));
 }
 
-TEST(RecursiveIteratorMapTest, CanMutatePointedToData) {
+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);
@@ -60,7 +60,7 @@ TEST(RecursiveIteratorMapTest, CanMutatePointedToData) {
   EXPECT_THAT(map[1][1][1], 4);
 }
 
-TEST(BoundRecursiveIteratorMapTest, PreIncrementAdvancesIterator) {
+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>{});
@@ -69,7 +69,7 @@ TEST(BoundRecursiveIteratorMapTest, PreIncrementAdvancesIterator) {
   EXPECT_THAT(std::get<2>(*rit), map[2][2]);
 }
 
-TEST(BoundRecursiveIteratorMapTest, PostIncrementReturnsCopyOfPrev) {
+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>{});
@@ -78,7 +78,7 @@ TEST(BoundRecursiveIteratorMapTest, PostIncrementReturnsCopyOfPrev) {
   EXPECT_THAT(std::get<2>(*rit), map[2][2]);
 }
 
-TEST(BoundRecursiveIteratorMapTest, IterDistanceSumOnNLayersSize) {
+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>{});
@@ -86,7 +86,7 @@ TEST(BoundRecursiveIteratorMapTest, IterDistanceSumOnNLayersSize) {
   EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 3);
 }
 
-TEST(BoundRecursiveIteratorMapTest, ElementsAreUnwrappedAsATuple) {
+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{
@@ -96,7 +96,7 @@ TEST(BoundRecursiveIteratorMapTest, ElementsAreUnwrappedAsATuple) {
               ElementsAreArray(expected));
 }
 
-TEST(BoundedRecursiveIteratorMapTest, CanMutatePointedToData) {
+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>{});

test/recursive_iterator_mixed_container_test.cxx

@@ -10,14 +10,14 @@ using iterator::RecursiveIterator;
 
 using testing::ElementsAreArray;
 
-TEST(RecursiveIteratorMapVectorTest, IterDistanceIsSumOfInnerContainerSizes) {
+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(RecursiveIteratorMapVectorTest, ElementsAreUnwrappedAsATuple) {
+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}};
@@ -26,14 +26,14 @@ TEST(RecursiveIteratorMapVectorTest, ElementsAreUnwrappedAsATuple) {
               ElementsAreArray(expected));
 }
 
-TEST(RecursiveIteratorMapVectorTest, CanMutatePointedToData) {
+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(RecursiveIteratorMapMapVectorTest, CanMutatePointedToData) {
+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);
@@ -41,7 +41,7 @@ TEST(RecursiveIteratorMapMapVectorTest, CanMutatePointedToData) {
   EXPECT_THAT(obj[1][1][0], 6);
 }
 
-TEST(RecursiveIteratorVectorMapTest, IterDistanceIsSumOfInnerContainerSizes) {
+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);
@@ -49,7 +49,7 @@ TEST(RecursiveIteratorVectorMapTest, IterDistanceIsSumOfInnerContainerSizes) {
   EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 5);
 }
 
-TEST(RecursiveIteratorVectorMapTest, ElementsAreUnwrappedAsATuple) {
+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{
@@ -59,7 +59,7 @@ TEST(RecursiveIteratorVectorMapTest, ElementsAreUnwrappedAsATuple) {
               ElementsAreArray(expected));
 }
 
-TEST(RecursiveIteratorVectorMapTest, CanMutatePointedToData) {
+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);
@@ -67,7 +67,7 @@ TEST(RecursiveIteratorVectorMapTest, CanMutatePointedToData) {
   EXPECT_THAT(obj[0][1], 6);
 }
 
-TEST(RecursiveIteratorMapVecMapTest, IterDistanceIsSumOfInnerContainerSizes) {
+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}};
@@ -76,7 +76,7 @@ TEST(RecursiveIteratorMapVecMapTest, IterDistanceIsSumOfInnerContainerSizes) {
   EXPECT_THAT(ranges::distance(rit, iterator::sentinel), expected.size());
 }
 
-TEST(RecursiveIteratorMapVecMapTest, ElementsAreUnwrappedAsATuple) {
+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}};
@@ -85,14 +85,14 @@ TEST(RecursiveIteratorMapVecMapTest, ElementsAreUnwrappedAsATuple) {
               ElementsAreArray(expected));
 }
 
-TEST(RecursiveIteratorMapVecMapTest, CanMutatePointedToData) {
+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(RecursiveIteratorVecMapVecTest, IterDistanceIsSumOfInnerContainerSizes) {
+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);
@@ -100,7 +100,7 @@ TEST(RecursiveIteratorVecMapVecTest, IterDistanceIsSumOfInnerContainerSizes) {
   EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 7);
 }
 
-TEST(RecursiveIteratorVecMapVecTest, ElementsAreUnwrappedAsATuple) {
+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{
@@ -110,7 +110,7 @@ TEST(RecursiveIteratorVecMapVecTest, ElementsAreUnwrappedAsATuple) {
               ElementsAreArray(expected));
 }
 
-TEST(RecursiveIteratorVecMapVecTest, CanMutatePointedToData) {
+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);

test/recursive_iterator_single_level_test.cxx

@@ -18,41 +18,41 @@ using iterator::RecursiveIterator;
 
 using testing::ElementsAreArray;
 
-TEST(RecursiveIteratorSingleVectorTest, IterDistanceIsContainerSize) {
+TEST(RecursiveIterator_Vec, IterDistanceIsContainerSize) {
   std::vector<int> const vec{1, 2, 3, 4, 5};
   auto rit = RecursiveIterator(vec);
 
   EXPECT_THAT(ranges::distance(rit, iterator::sentinel), vec.size());
 }
 
-TEST(RecursiveIteratorSingleVectorTest, DataMatchesContainerIterator) {
+TEST(RecursiveIterator_Vec, DataMatchesContainerIterator) {
   std::vector<int> const vec{1, 2, 3, 4, 5};
 
   EXPECT_THAT(vec | views::recursive | ranges::to<std::vector>(),
               ElementsAreArray(vec));
 }
 
-TEST(RecursiveIteratorSingleVectorTest, CanMutatePointedToData) {
+TEST(RecursiveIterator_Vec, CanMutatePointedToData) {
   std::vector<int> vec{1, 2, 3, 4, 5};
   auto rit = RecursiveIterator(vec);
   *rit = 6;
   EXPECT_THAT(vec[0], 6);
 }
 
-TEST(RecursiveIteratorSingleMapTest, IterDistanceIsContainerSize) {
+TEST(RecursiveIterator_Map, IterDistanceIsContainerSize) {
   std::map<int, int> const map{{1, 1}, {2, 2}, {3, 3}};
   auto rit = RecursiveIterator(map);
 
   EXPECT_THAT(ranges::distance(rit, iterator::sentinel), map.size());
 }
 
-TEST(RecursiveIteratorSingleMapTest, DataMatchesContainerIterator) {
+TEST(RecursiveIterator_Map, DataMatchesContainerIterator) {
   std::map<int, int> const map{{1, 1}, {2, 2}, {3, 3}};
 
   EXPECT_THAT((map | views::recursive | ranges::to<std::map<int, int>>()), map);
 }
 
-TEST(RecursiveIteratorSingleMapTest, CanMutatePointedToData) {
+TEST(RecursiveIterator_Map, CanMutatePointedToData) {
   std::map<int, int> map{{1, 1}, {2, 2}, {3, 3}};
   auto rit = RecursiveIterator(map);
   std::get<1>(*rit) = 4;

test/recursive_iterator_vector_test.cxx

@@ -13,7 +13,7 @@ using iterator::RecursiveIterator;
 using testing::ElementsAreArray;
 using testing::IsEmpty;
 
-TEST(RecursiveIteratorVecTest, PreIncrementAdvancesIterator) {
+TEST(RecursiveIterator_VecVec, PreIncrementAdvancesIterator) {
   std::vector<std::vector<std::vector<int>>> const vec{{{1, 2}}, {{3}, {4, 5}}};
   auto rit = RecursiveIterator(vec);
   EXPECT_THAT(*rit, 1);
@@ -21,7 +21,7 @@ TEST(RecursiveIteratorVecTest, PreIncrementAdvancesIterator) {
   EXPECT_THAT(*rit, 2);
 }
 
-TEST(RecursiveIteratorVecTest, PostIncrementReturnsCopyOfPrev) {
+TEST(RecursiveIterator_VecVec, PostIncrementReturnsCopyOfPrev) {
   std::vector<std::vector<std::vector<int>>> const vec{{{1, 2}}, {{3}, {4, 5}}};
   auto rit = RecursiveIterator(vec);
   EXPECT_THAT(*rit, 1);
@@ -29,14 +29,14 @@ TEST(RecursiveIteratorVecTest, PostIncrementReturnsCopyOfPrev) {
   EXPECT_THAT(*rit, 2);
 }
 
-TEST(RecursiveIteratorVecTest, IterDistanceIsSumOfInnerContainerSizes) {
+TEST(RecursiveIterator_VecVec, IterDistanceIsSumOfInnerContainerSizes) {
   std::vector<std::vector<std::vector<int>>> const vec{{{1, 2}}, {{3}, {4, 5}}};
   auto rit = RecursiveIterator(vec);
 
   EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 5);
 }
 
-TEST(RecursiveIteratorVecTest, FlattensVectorDataLikeJoinIterator) {
+TEST(RecursiveIterator_VecVec, FlattensVectorDataLikeJoinIterator) {
   std::vector<std::vector<std::vector<int>>> const vec{{{1, 2}}, {{3}, {4, 5}}};
 
   std::vector<int> const expected{1, 2, 3, 4, 5};
@@ -44,14 +44,14 @@ TEST(RecursiveIteratorVecTest, FlattensVectorDataLikeJoinIterator) {
               ElementsAreArray(expected));
 }
 
-TEST(RecursiveIteratorVecTest, CanMutatePointedToData) {
+TEST(RecursiveIterator_VecVec, CanMutatePointedToData) {
   std::vector<std::vector<std::vector<int>>> vec{{{1, 2}}, {{3}, {4, 5}}};
   auto rit = RecursiveIterator(vec);
   *rit = 6;
   EXPECT_THAT(vec[0][0][0], 6);
 }
 
-TEST(BoundedRecursiveIteratorVecTest, PreIncrementAdvancesIterator) {
+TEST(RecursiveIterator_Vec_Bounded, PreIncrementAdvancesIterator) {
   std::vector<std::vector<std::vector<int>>> const vec{{{1, 2}}, {{3}, {4, 5}}};
   auto rit = RecursiveIterator(vec, bounded<2>{});
   EXPECT_THAT(*rit, vec[0][0]);
@@ -59,7 +59,7 @@ TEST(BoundedRecursiveIteratorVecTest, PreIncrementAdvancesIterator) {
   EXPECT_THAT(*rit, vec[1][0]);
 }
 
-TEST(BoundedRecursiveIteratorVecTest, PostIncrementReturnsCopyOfPrev) {
+TEST(RecursiveIterator_Vec_Bounded, PostIncrementReturnsCopyOfPrev) {
   std::vector<std::vector<std::vector<int>>> const vec{{{1, 2}}, {{3}, {4, 5}}};
   auto rit = RecursiveIterator(vec, bounded<2>{});
   EXPECT_THAT(*rit, vec[0][0]);
@@ -67,14 +67,14 @@ TEST(BoundedRecursiveIteratorVecTest, PostIncrementReturnsCopyOfPrev) {
   EXPECT_THAT(*rit, vec[1][0]);
 }
 
-TEST(BoundedRecursiveIteratorVecTest, IterDistanceSumOnNLayersSize) {
+TEST(RecursiveIterator_Vec_Bounded, IterDistanceSumOnNLayersSize) {
   std::vector<std::vector<std::vector<int>>> const vec{{{1, 2}}, {{3}, {4, 5}}};
   auto rit = RecursiveIterator(vec, bounded<2>{});
 
   EXPECT_THAT(ranges::distance(rit, iterator::sentinel), 3);
 }
 
-TEST(BoundedRecursiveIteratorVecTest, ElementsAreUnwrappedAsATuple) {
+TEST(RecursiveIterator_Vec_Bounded, ElementsAreUnwrappedAsATuple) {
   std::vector<std::vector<std::vector<int>>> const vec{{{1, 2}}, {{3}, {4, 5}}};
 
   std::vector<std::vector<int>> const expected{{1, 2}, {3}, {4, 5}};
@@ -82,7 +82,7 @@ TEST(BoundedRecursiveIteratorVecTest, ElementsAreUnwrappedAsATuple) {
               ElementsAreArray(expected));
 }
 
-TEST(BoundedRecursiveIteratorVecTest, CanMutatePointedToData) {
+TEST(RecursiveIterator_Vec_Bounded, CanMutatePointedToData) {
   std::vector<std::vector<std::vector<int>>> vec{{{1, 2}}, {{3}, {4, 5}}};
   auto rit = RecursiveIterator(vec, bounded<2>{});
   rit->clear();

test/values_iterator_test.cxx

@@ -10,9 +10,10 @@
 using iterator::EndAwareIterator;
 using iterator::ValuesIterator;
 
+using testing::Eq;
 using testing::Ne;
 
-TEST(UnkeyedIteratorTest, IteratorOnlyReturnsValues) {
+TEST(ValuesIterator, IteratorOnlyReturnsValues) {
   std::map<int, int> map{{1, 2}, {2, 3}};
   std::vector<int> const expected{2, 3};
   std::vector<int> const result{ValuesIterator{map.begin()},
@@ -20,14 +21,14 @@ TEST(UnkeyedIteratorTest, IteratorOnlyReturnsValues) {
   EXPECT_THAT(result, expected);
 }
 
-TEST(UnkeyedIteratorTest, CanModifyIteratedCollectionValues) {
+TEST(ValuesIterator, CanModifyIteratedCollectionValues) {
   std::map<int, int> map{{1, 2}, {2, 3}};
   ValuesIterator uit{map.begin()};
   *uit = 4;
   EXPECT_THAT(map[1], 4);
 }
 
-TEST(UnkeyedIteratorTest, PreIncrementAdvancesIterator) {
+TEST(ValuesIterator, PreIncrementAdvancesIterator) {
   std::map<int, int> map{{1, 2}, {2, 3}};
   ValuesIterator it(map.begin());
   EXPECT_THAT(*it, 2);
@@ -35,7 +36,7 @@ TEST(UnkeyedIteratorTest, PreIncrementAdvancesIterator) {
   EXPECT_THAT(*it, 3);
 }
 
-TEST(UnkeyedIteratorTest, PostIncrementReturnsCopyOfPrev) {
+TEST(ValuesIterator, PostIncrementReturnsCopyOfPrev) {
   std::map<int, int> map{{1, 2}, {2, 3}};
   ValuesIterator it(map.begin());
   EXPECT_THAT(*it, 2);
@@ -43,7 +44,7 @@ TEST(UnkeyedIteratorTest, PostIncrementReturnsCopyOfPrev) {
   EXPECT_THAT(*it, 3);
 }
 
-TEST(UnkeyedIteratorTest, PreDecrementAdvancesIterator) {
+TEST(ValuesIterator, PreDecrementAdvancesIterator) {
   std::map<int, int> map{{1, 2}, {2, 3}};
   ValuesIterator it(++map.begin());
   EXPECT_THAT(*it, 3);
@@ -51,7 +52,7 @@ TEST(UnkeyedIteratorTest, PreDecrementAdvancesIterator) {
   EXPECT_THAT(*it, 2);
 }
 
-TEST(UnkeyedIteratorTest, PostDecrementReturnsCopyOfPrev) {
+TEST(ValuesIterator, PostDecrementReturnsCopyOfPrev) {
   std::map<int, int> map{{1, 2}, {2, 3}};
   ValuesIterator it(++map.begin());
   EXPECT_THAT(*it, 3);
@@ -59,19 +60,19 @@ TEST(UnkeyedIteratorTest, PostDecrementReturnsCopyOfPrev) {
   EXPECT_THAT(*it, 2);
 }
 
-TEST(UnkeyedIteratorTest, EqualityIsPassthrough) {
+TEST(ValuesIterator, EqualityIsPassthrough) {
   std::map<int, int> map{{1, 2}, {2, 3}};
   EXPECT_THAT(++ValuesIterator(map.begin()), ValuesIterator(++map.begin()));
   EXPECT_THAT(ValuesIterator(map.begin()), Ne(ValuesIterator(++map.begin())));
 }
 
-TEST(UnkeyedIteratorTest, PropagatesAtEnd) {
+TEST(ValuesIterator, PropagatesAtEnd) {
   std::map<int, int> map{{1, 2}, {2, 3}};
   ValuesIterator end(EndAwareIterator(map.end(), map.end()));
-  EXPECT_EQ(end, iterator::sentinel);
+  EXPECT_THAT(end, Eq(iterator::sentinel));
 }
 
-TEST(UnkeyedIteratorTest, CanPointToObject) {
+TEST(ValuesIterator, CanPointToObject) {
   std::map<int, int> map{{1, 2}, {2, 3}};
   EXPECT_THAT(ValuesIterator(map.begin()).operator->(), &(map.begin()->second));
 }

test/zip_iterator_test.cxx

@@ -24,7 +24,7 @@ using testing::Lt;
 using testing::Ne;
 using testing::StaticAssertTypeEq;
 
-TEST(ZipIteratorTest, CategoryIsMostRestrictiveOfTypes) {
+TEST(ZipIterator, CategoryIsMostRestrictiveOfTypes) {
   std::vector<int> rnd{1, 2, 3};
   std::vector<std::string> ss{"A", "B", "C"};
   std::list<int> bid{1, 2, 3};
@@ -51,7 +51,7 @@ TEST(ZipIteratorTest, CategoryIsMostRestrictiveOfTypes) {
   }
 }
 
-TEST(ZipIteratorTest, CanCombineParallelObjects) {
+TEST(ZipIterator, CanCombineParallelObjects) {
   std::vector<int> is{1, 2, 3};
   std::vector<std::string> ss{"A", "B", "C"};
   ZipIterator zit(is.begin(), ss.begin());
@@ -59,7 +59,7 @@ TEST(ZipIteratorTest, CanCombineParallelObjects) {
   EXPECT_THAT(std::get<1>(*zit), "A");
 }
 
-TEST(ZipIteratorTest, AdvancingMovesAllElements) {
+TEST(ZipIterator, AdvancingMovesAllElements) {
   std::vector<int> is{1, 2, 3};
   std::vector<std::string> ss{"A", "B", "C"};
   ZipIterator zit(is.begin(), ss.begin());
@@ -68,7 +68,7 @@ TEST(ZipIteratorTest, AdvancingMovesAllElements) {
   EXPECT_THAT(std::get<1>(*zit), "B");
 }
 
-TEST(ZipIteratorTest, CanDecrement) {
+TEST(ZipIterator, CanDecrement) {
   std::vector<int> is{1, 2, 3};
   std::vector<std::string> ss{"A", "B", "C"};
   ZipIterator zit(is.begin(), ss.begin());
@@ -78,7 +78,7 @@ TEST(ZipIteratorTest, CanDecrement) {
   EXPECT_THAT(std::get<1>(*zit), "A");
 }
 
-TEST(ZipIteratorTest, CanMoveByAnyAmount) {
+TEST(ZipIterator, CanMoveByAnyAmount) {
   std::vector<int> is{1, 2, 3};
   std::vector<std::string> ss{"A", "B", "C"};
   ZipIterator zit(is.begin(), ss.begin());
@@ -90,7 +90,7 @@ TEST(ZipIteratorTest, CanMoveByAnyAmount) {
   EXPECT_THAT(std::get<1>(*zit), "A");
 }
 
-TEST(ZipIteratorTest, CanMarkDistance) {
+TEST(ZipIterator, CanMarkDistance) {
   std::vector<int> is{1, 2, 3};
   std::vector<std::string> ss{"A", "B", "C"};
   ZipIterator zit(is.begin(), ss.begin());
@@ -98,7 +98,7 @@ TEST(ZipIteratorTest, CanMarkDistance) {
   EXPECT_THAT(zend - zit, 3);
 }
 
-TEST(ZipIteratorTest, CanRandomAccess) {
+TEST(ZipIterator, CanRandomAccess) {
   std::vector<int> is{1, 2, 3};
   std::vector<std::string> ss{"A", "B", "C"};
   ZipIterator zit(is.begin(), ss.begin());
@@ -106,7 +106,7 @@ TEST(ZipIteratorTest, CanRandomAccess) {
   EXPECT_THAT(std::get<1>(zit[1]), "B");
 }
 
-TEST(ZipIteratorTest, CanCompareIterators) {
+TEST(ZipIterator, CanCompareIterators) {
   std::vector<int> is{1, 2, 3};
   std::vector<std::string> ss{"A", "B", "C"};
   ZipIterator const zit(is.begin(), ss.begin());