cpp-useful-iterators/test/values_iterator_test.cxx

#include "iterator/values_iterator.h"

#include <map>
#include <vector>

#include "xcode_gtest_helper.h"

#include "iterator/end_aware_iterator.h"

using iterator::EndAwareIterator;
using iterator::ValuesIterator;

using testing::Eq;
using testing::Ne;

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()},
                                ValuesIterator{map.end()}};
  EXPECT_THAT(result, expected);
}

TEST(ValuesIterator, CanModifyIteratedCollectionValues) {
  std::map<int, int> map{{1, 2}, {2, 3}};
  ValuesIterator uit{map.begin()};
  *uit = 4;
  EXPECT_THAT(map[1], 4);
}

TEST(ValuesIterator, PreIncrementAdvancesIterator) {
  std::map<int, int> map{{1, 2}, {2, 3}};
  ValuesIterator it(map.begin());
  EXPECT_THAT(*it, 2);
  EXPECT_THAT(*++it, 3);
  EXPECT_THAT(*it, 3);
}

TEST(ValuesIterator, PostIncrementReturnsCopyOfPrev) {
  std::map<int, int> map{{1, 2}, {2, 3}};
  ValuesIterator it(map.begin());
  EXPECT_THAT(*it, 2);
  EXPECT_THAT(*it++, 2);
  EXPECT_THAT(*it, 3);
}

TEST(ValuesIterator, PreDecrementAdvancesIterator) {
  std::map<int, int> map{{1, 2}, {2, 3}};
  ValuesIterator it(++map.begin());
  EXPECT_THAT(*it, 3);
  EXPECT_THAT(*--it, 2);
  EXPECT_THAT(*it, 2);
}

TEST(ValuesIterator, PostDecrementReturnsCopyOfPrev) {
  std::map<int, int> map{{1, 2}, {2, 3}};
  ValuesIterator it(++map.begin());
  EXPECT_THAT(*it, 3);
  EXPECT_THAT(*it--, 3);
  EXPECT_THAT(*it, 2);
}

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(ValuesIterator, PropagatesAtEnd) {
  std::map<int, int> map{{1, 2}, {2, 3}};
  ValuesIterator end(EndAwareIterator(map.end(), map.end()));
  EXPECT_THAT(end, Eq(iterator::sentinel));
}

TEST(ValuesIterator, CanPointToObject) {
  std::map<int, int> map{{1, 2}, {2, 3}};
  EXPECT_THAT(ValuesIterator(map.begin()).operator->(), &(map.begin()->second));
}