#include <internal/iteratoriterator.hpp>

#include <string>

#include <vector>

#include <utility>

#include "catch.hpp"

using iter::impl::IterIterWrapper;

TEST_CASE("Iterator over a vector of vector iterators", "[iteratoriterator]") {

using std::vector;

vector<int> v = {2, 4, 6, 8};

IterIterWrapper<vector<vector<int>::iterator>> itr;

itr.get().push_back(std::begin(v) + 1);

itr.get().push_back(std::end(v) - 1);

itr.get().push_back(std::begin(v));

auto it = std::begin(itr);

REQUIRE(*it == 4);

REQUIRE(it != std::end(itr));

++it;

REQUIRE(*it == 8);

it++;

REQUIRE(*it == 2);

++it;

REQUIRE(it == std::end(itr));

REQUIRE(itr[0] == 4);

REQUIRE(itr[1] == 8);

REQUIRE(itr[2] == 2);

auto rit = itr.rbegin();

REQUIRE(*rit == 2);

REQUIRE(rit != itr.rend());

++rit;

REQUIRE(*rit == 8);

++rit;

REQUIRE(*rit == 4);

++rit;

REQUIRE(rit == itr.rend());

}

TEST_CASE("IteratorIterator operator->", "[iteratoriterator]") {

using std::vector;

using std::string;

vector<string> v = {"hello", "everyone"};

IterIterWrapper<vector<vector<string>::iterator>> itritr;

itritr.get().push_back(std::end(v) - 1);

itritr.get().push_back(std::begin(v));

auto it = std::begin(itritr);

REQUIRE(it->size() == 8);

}

TEST_CASE("Iterate over a vector of string iterators", "[iteratoriterator]") {

std::string str = "hello world";

IterIterWrapper<std::vector<std::string::iterator>> itritr;

auto it = std::begin(itritr);

static_assert(std::is_same<decltype(*it),

std::iterator_traits<decltype(it)>::reference>::value,

"iterator is mis marked");

}

TEST_CASE("IteratorIterator supports mutable RandomAccessIterator operators",

"[iteratoriterator]") {

using std::vector;

struct S {

int value;

};

vector<S> v = {{2}, {4}, {6}, {8}};

IterIterWrapper<vector<vector<S>::iterator>> itr;

itr.get().push_back(std::begin(v) + 1);

itr.get().push_back(std::end(v) - 1);

itr.get().push_back(std::begin(v));

// RandomAccessIterator (and ForwardIterator):

auto a = itr.begin();

auto r = a;

auto r2 = r;

((r += 2) -= 2) += 2;

REQUIRE(&(++r2) == &r2); // Required by OutputIterator.

REQUIRE(&(*r2++) == &a[1]);

REQUIRE(r == r2);

auto test_const_or_not = [&itr](auto& a, auto& b) {

REQUIRE(!(b == a));

REQUIRE(b == a + 2);

REQUIRE(b == 2 + a);

REQUIRE(b - 2 == a);

REQUIRE(&a[2] == &b[0]);

REQUIRE(b - a == 2);

REQUIRE(a < b);

REQUIRE(!(a < a));

REQUIRE(b > a);

REQUIRE(!(a > a));

REQUIRE(a <= b);

REQUIRE(!(b <= a));

REQUIRE(a <= a);

REQUIRE(b >= a);

REQUIRE(!(a >= b));

REQUIRE(a >= a);

// InputIterator:

REQUIRE(b != a);

REQUIRE(!(a != a));

REQUIRE(&(*a) != &(*b));

REQUIRE(&(a->value) == &(*a).value);

// Added methods, not from ...Iterator:

REQUIRE(a.get() == std::begin(itr.get()));

};

test_const_or_not(a, r);

test_const_or_not(std::as_const(a), r);

test_const_or_not(a, std::as_const(r));

test_const_or_not(std::as_const(a), std::as_const(r));

// BidirectionalIterator (and RandomAccessIterator):

REQUIRE((--r)-- == a + 1);

REQUIRE(r == a);

REQUIRE(&(*r2--) == &a[2]);

// OutputIterator (and RandomAccessIterator):

*r++ = {10};

REQUIRE(r == a + 1);

REQUIRE(v[1].value == 10);

*++r = {12};

REQUIRE(r == a + 2);

REQUIRE(v[0].value == 12);

*r = {14};

REQUIRE(r == a + 2);

REQUIRE(v[0].value == 14);

a[1] = {16};

REQUIRE(a == itr.begin());

REQUIRE(v[3].value == 16);

}

TEST_CASE("IterIterWrapper supports several SequenceContainer methodes",

"[iteratoriterator]") {

using std::vector;

vector<int> v = {2, 4, 6, 8};

IterIterWrapper<vector<vector<int>::iterator>> itr;

itr.get().push_back(std::begin(v) + 1);

itr.get().push_back(std::end(v) - 1);

auto test_const_or_not = [&v](auto& c) {

REQUIRE(c.at(0) == 4);

REQUIRE(c.at(1) == 8);

REQUIRE(c[0] == 4);

REQUIRE(c[1] == 8);

REQUIRE(!c.empty());

REQUIRE(c.size() == 2);

REQUIRE(*c.begin() == 4);

REQUIRE(*(c.end() - 1) == 8);

REQUIRE(*c.cbegin() == 4);

REQUIRE(*(c.cend() - 1) == 8);

REQUIRE(*c.rbegin() == 8);

REQUIRE(*(c.rend() - 1) == 4);

REQUIRE(*c.crbegin() == 8);

REQUIRE(*(c.crend() - 1) == 4);

// Added methods, not from SequenceContainer:

REQUIRE(c.get()[0] == std::begin(v) + 1);

};

test_const_or_not(itr);

test_const_or_not(std::as_const(itr));

}