cpp-useful-iterators/test/zip_iterator_test.cxx

//
//  zip_iterator_test.cxx
//  iterator-test
//
//  Created by Sam Jaffe on 8/11/20.
//  Copyright © 2020 Sam Jaffe. All rights reserved.
//

#include "iterator/zip_iterator.h"

#include <forward_list>
#include <list>
#include <vector>

#include "xcode_gtest_helper.h"

using iterator::zip_iterator;

using testing::Eq;
using testing::Ge;
using testing::Gt;
using testing::Le;
using testing::Lt;
using testing::Ne;
using testing::StaticAssertTypeEq;

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};
  {
    zip_iterator zit(rnd.begin(), ss.begin());
    StaticAssertTypeEq<std::iterator_traits<decltype(zit)>::iterator_category,
                       std::random_access_iterator_tag>();
  }
  {
    zip_iterator zit(rnd.begin(), bid.begin());
    StaticAssertTypeEq<std::iterator_traits<decltype(zit)>::iterator_category,
                       std::bidirectional_iterator_tag>();
  }
  {
    zip_iterator zit(rnd.begin(), fwd.begin());
    StaticAssertTypeEq<std::iterator_traits<decltype(zit)>::iterator_category,
                       std::forward_iterator_tag>();
  }
  {
    zip_iterator zit(bid.begin(), fwd.begin());
    StaticAssertTypeEq<std::iterator_traits<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());
//  StaticAssertTypeEq<decltype(zit.operator->()), void>();
//}

TEST(ZipIteratorTest, CanCombineParallelObjects) {
  std::vector<int> is{1, 2, 3};
  std::vector<std::string> ss{"A", "B", "C"};
  zip_iterator zit(is.begin(), ss.begin());
  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"};
  zip_iterator zit(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"};
  zip_iterator zit(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"};
  zip_iterator zit(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"};
  zip_iterator zit(is.begin(), ss.begin());
  zip_iterator zend(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"};
  zip_iterator zit(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"};
  zip_iterator const zit(is.begin(), ss.begin());
  zip_iterator const zend(is.end(), ss.end());
  EXPECT_THAT(zit, Eq(zip_iterator(is.begin(), ss.begin())));
  EXPECT_THAT(zit, Ne(zend));
  EXPECT_THAT(zit, Lt(zend));
  EXPECT_THAT(zit, Le(zend));
  EXPECT_THAT(zit, Le(zit));
  EXPECT_THAT(zend, Gt(zit));
  EXPECT_THAT(zend, Ge(zit));
  EXPECT_THAT(zend, Ge(zend));
}