Add test coverage, fix bug in >=, add dummy operator->().

include/iterator/zip_iterator.hpp

@@ -27,6 +27,8 @@ namespace iterator {
       return reference(*std::get<Iterators>(iterators_)...);
     }
 
+    pointer operator->() const;
+
     zip_iterator & operator++() {
       [[maybe_unused]] auto l = {(++(std::get<Iterators>(iterators_)), 0)...};
       return *this;
@@ -91,7 +93,7 @@ namespace iterator {
       return iterators_ > rhs.iterators_;
     }
     bool operator>=(zip_iterator const & rhs) const {
-      return iterators_ <= rhs.iterators_;
+      return iterators_ >= rhs.iterators_;
     }
   };
 

test/zip_iterator_test.cxx

@@ -14,6 +14,40 @@
 
 #include <gmock/gmock.h>
 
+TEST(ZipIteratorTest, CategoryIsMostRestrictiveOfTypes) {
+  std::vector<int> rnd{1, 2, 3};
+  std::vector<std::string> ss{"A", "B", "C"};
+  std::list<int> bid{1, 2, 3};
+  std::forward_list<int> fwd{1, 2, 3};
+  {
+    auto zit = make_zip_iterator(rnd.begin(), ss.begin());
+    testing::StaticAssertTypeEq<decltype(zit)::iterator_category,
+                                std::random_access_iterator_tag>();
+  }
+  {
+    auto zit = make_zip_iterator(rnd.begin(), bid.begin());
+    testing::StaticAssertTypeEq<decltype(zit)::iterator_category,
+                                std::bidirectional_iterator_tag>();
+  }
+  {
+    auto zit = make_zip_iterator(rnd.begin(), fwd.begin());
+    testing::StaticAssertTypeEq<decltype(zit)::iterator_category,
+                                std::forward_iterator_tag>();
+  }
+  {
+    auto zit = make_zip_iterator(bid.begin(), fwd.begin());
+    testing::StaticAssertTypeEq<decltype(zit)::iterator_category,
+                                std::forward_iterator_tag>();
+  }
+}
+
+TEST(ZipIteratorTest, CannotInvokeOperatorArrow) {
+  std::vector<int> is{1, 2, 3};
+  std::vector<std::string> ss{"A", "B", "C"};
+  auto zit = make_zip_iterator(is.begin(), ss.begin());
+  testing::StaticAssertTypeEq<decltype(zit.operator->()), void>();
+}
+
 TEST(ZipIteratorTest, CanCombineParallelObjects) {
   std::vector<int> is{1, 2, 3};
   std::vector<std::string> ss{"A", "B", "C"};
@@ -21,3 +55,65 @@ TEST(ZipIteratorTest, CanCombineParallelObjects) {
   EXPECT_THAT(std::get<0>(*zit), 1);
   EXPECT_THAT(std::get<1>(*zit), "A");
 }
+
+TEST(ZipIteratorTest, AdvancingMovesAllElements) {
+  std::vector<int> is{1, 2, 3};
+  std::vector<std::string> ss{"A", "B", "C"};
+  auto zit = make_zip_iterator(is.begin(), ss.begin());
+  zit++;
+  EXPECT_THAT(std::get<0>(*zit), 2);
+  EXPECT_THAT(std::get<1>(*zit), "B");
+}
+
+TEST(ZipIteratorTest, CanDecrement) {
+  std::vector<int> is{1, 2, 3};
+  std::vector<std::string> ss{"A", "B", "C"};
+  auto zit = make_zip_iterator(is.begin(), ss.begin());
+  ++zit;
+  zit--;
+  EXPECT_THAT(std::get<0>(*zit), 1);
+  EXPECT_THAT(std::get<1>(*zit), "A");
+}
+
+TEST(ZipIteratorTest, CanMoveByAnyAmount) {
+  std::vector<int> is{1, 2, 3};
+  std::vector<std::string> ss{"A", "B", "C"};
+  auto zit = make_zip_iterator(is.begin(), ss.begin());
+  zit = 2 + zit;
+  EXPECT_THAT(std::get<0>(*zit), 3);
+  EXPECT_THAT(std::get<1>(*zit), "C");
+  zit = zit - 2;
+  EXPECT_THAT(std::get<0>(*zit), 1);
+  EXPECT_THAT(std::get<1>(*zit), "A");
+}
+
+TEST(ZipIteratorTest, CanMarkDistance) {
+  std::vector<int> is{1, 2, 3};
+  std::vector<std::string> ss{"A", "B", "C"};
+  auto zit = make_zip_iterator(is.begin(), ss.begin());
+  auto zend = make_zip_iterator(is.end(), ss.end());
+  EXPECT_THAT(zend - zit, 3);
+}
+
+TEST(ZipIteratorTest, CanRandomAccess) {
+  std::vector<int> is{1, 2, 3};
+  std::vector<std::string> ss{"A", "B", "C"};
+  auto zit = make_zip_iterator(is.begin(), ss.begin());
+  EXPECT_THAT(std::get<0>(zit[1]), 2);
+  EXPECT_THAT(std::get<1>(zit[1]), "B");
+}
+
+TEST(ZipIteratorTest, CanCompareIterators) {
+  std::vector<int> is{1, 2, 3};
+  std::vector<std::string> ss{"A", "B", "C"};
+  auto const zit = make_zip_iterator(is.begin(), ss.begin());
+  auto const zend = make_zip_iterator(is.end(), ss.end());
+  EXPECT_THAT(zit, testing::Eq(make_zip_iterator(is.begin(), ss.begin())));
+  EXPECT_THAT(zit, testing::Ne(zend));
+  EXPECT_THAT(zit, testing::Lt(zend));
+  EXPECT_THAT(zit, testing::Le(zend));
+  EXPECT_THAT(zit, testing::Le(zit));
+  EXPECT_THAT(zend, testing::Gt(zit));
+  EXPECT_THAT(zend, testing::Ge(zit));
+  EXPECT_THAT(zend, testing::Ge(zend));
+}