#include <accumulate.hpp>

#include "helpers.hpp"

#include <iterator>

#include <string>

#include <vector>

#include "catch.hpp"

using iter::accumulate;

using itertest::BasicIterable;

using Vec = const std::vector<int>;

TEST_CASE("Simple sum", "[accumulate]") {

Vec ns{1, 2, 3, 4, 5};

std::vector<int> v;

SECTION("Normal call") {

auto a = accumulate(ns);

v.assign(std::begin(a), std::end(a));

}

SECTION("Pipe") {

auto a = ns | accumulate;

v.assign(std::begin(a), std::end(a));

}

Vec vc{1, 3, 6, 10, 15};

REQUIRE(v == vc);

}

TEST_CASE("accumulate: With subtraction lambda", "[accumulate]") {

Vec ns{5, 4, 3, 2, 1};

std::vector<int> v;

SECTION("Normal call") {

auto a = accumulate(ns, [](int a, int b) { return a - b; });

v.assign(std::begin(a), std::end(a));

}

SECTION("Pipe") {

auto a = ns | accumulate([](int a, int b) { return a - b; });

v.assign(std::begin(a), std::end(a));

}

Vec vc{5, 1, -2, -4, -5};

REQUIRE(v == vc);

}

TEST_CASE("accumulate: handles pointer to member function", "[accumulate]") {

using itertest::Point;

std::vector<Point> ps = {{1, 2}, {10, 50}, {300, 600}};

auto a = accumulate(ps, &Point::add);

const std::vector<Point> v(std::begin(a), std::end(a));

const std::vector<Point> vc = {{1, 2}, {11, 52}, {311, 652}};

REQUIRE(v == vc);

}

TEST_CASE("accumulate: const iterators", "[accumulate][const]") {

std::vector<int> v;

SECTION("lvalue") {

Vec ns{1, 2, 3, 4, 5};

const auto a = accumulate(ns);

v.assign(std::begin(a), std::end(a));

}

SECTION("rvalue") {

const auto a = accumulate(Vec{1, 2, 3, 4, 5});

v.assign(std::begin(a), std::end(a));

}

SECTION("const lvalue") {

const Vec ns{1, 2, 3, 4, 5};

const auto a = accumulate(ns);

v.assign(std::begin(a), std::end(a));

}

Vec vc{1, 3, 6, 10, 15};

REQUIRE(v == vc);

}

TEST_CASE(

"accumulate: const iterators can be compared", "[accumulate][const]") {

auto e = accumulate(std::string("hello"));

const auto& ce = e;

(void)(std::begin(e) == std::end(ce));

}

struct Integer {

const int value;

constexpr Integer(int i) : value{i} {}

constexpr Integer operator+(Integer other) const noexcept {

return {this->value + other.value};

}

};

TEST_CASE("accumulate: intermidate type need not be default constructible",

"[accumulate]") {

std::vector<Integer> v = {{2}, {3}, {10}};

auto a = accumulate(v, std::plus<Integer>{});

(void)std::begin(a);

}

TEST_CASE("accumulate: binds reference when it should", "[accumulate]") {

BasicIterable<int> bi{1, 2};

accumulate(bi);

REQUIRE_FALSE(bi.was_moved_from());

}

TEST_CASE("accumulate: moves rvalues when it should", "[accumulate]") {

BasicIterable<int> bi{1, 2};

accumulate(std::move(bi));

REQUIRE(bi.was_moved_from());

}

TEST_CASE("accumulate: operator==", "[accumulate]") {

Vec v;

auto a = accumulate(v);

REQUIRE(std::begin(a) == std::end(a));

}

TEST_CASE("accumulate: postfix ++", "[accumulate]") {

Vec ns{2, 3};

auto a = accumulate(ns);

auto it = std::begin(a);

it++;

REQUIRE(*it == 5);

}

TEST_CASE("accumulate: operator->", "[accumulate]") {

Vec ns{7, 3};

auto a = accumulate(ns);

auto it = std::begin(a);

const int* p = it.operator->();

REQUIRE(*p == 7);

}

TEST_CASE("accumulate: iterator meets requirements", "[accumulate]") {

Vec ns{};

auto a = accumulate(ns, [](int a, int b) { return a + b; });

auto it = std::begin(a);

it = std::begin(a);

REQUIRE(itertest::IsIterator<decltype(std::begin(a))>::value);

}

TEST_CASE(

"accumulate: Works with different begin and end types", "[accumulate]") {

CharRange cr{'d'};

auto a = accumulate(cr);

Vec v(a.begin(), a.end());

Vec vc{'a', 'a' + 'b', 'a' + 'b' + 'c'};

REQUIRE(v == vc);

}

template <typename T>

using ImpT = decltype(accumulate(std::declval<T>()));

TEST_CASE("accumulate: has correct ctor and assign ops", "[accumulate]") {

REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string&>>::value);

REQUIRE(itertest::IsMoveConstructibleOnly<ImpT<std::string>>::value);

}