expectation.hpp

#pragma once
 
#include <exception>
#include <optional>
#include <regex>
#include <source_location>
#include <string>
#include <vector>
 
#include "matchers/be_nullptr.hpp"
#include "matchers/contain.hpp"
#include "matchers/equal.hpp"
#include "matchers/errors/fail.hpp"
#include "matchers/errors/have_value.hpp"
#include "matchers/errors/throw.hpp"
#include "matchers/numeric/be_between.hpp"
#include "matchers/numeric/be_greater_than.hpp"
#include "matchers/numeric/be_less_than.hpp"
#include "matchers/numeric/be_within.hpp"
#include "matchers/satisfy.hpp"
#include "matchers/strings/end_with.hpp"
#include "matchers/strings/match.hpp"
#include "matchers/strings/start_with.hpp"
 
#ifdef __cpp_lib_expected
#include "matchers/errors/have_error.hpp"
#endif
 
namespace CppSpec {

template <class A>
class Expectation {
  ItBase* it = nullptr;
  std::source_location location;
 
 protected:
  bool is_positive_ = true;
  // Have we been negated?
  bool ignore_ = false;
 
 public:
  Expectation() = default;
  explicit Expectation(std::source_location location) : location(location) {}

  explicit Expectation(ItBase& it, std::source_location location) : it(&it), location(location) {}

  // virtual const A &get_target() const & { return target; }
  virtual A& get_target() & = 0;
 
  [[nodiscard]] ItBase* get_it() const { return it; }
  [[nodiscard]] std::source_location get_location() const { return location; }

  [[nodiscard]] constexpr bool positive() const { return is_positive_; }
  [[nodiscard]] constexpr bool ignored() const { return ignore_; }
 
  /********* Modifiers *********/
 
  virtual Expectation& not_() = 0;
  virtual Expectation& ignore() = 0;
 
  /********* Matchers *********/
 
  template <class M>
  void to(M matcher, std::string msg = "");
 
  /*-------- to be... ----------*/
 
  void to_be_false(std::string msg = "");
  void to_be_falsy(std::string msg = "");
  void to_be_null(std::string msg = "");
  void to_be_true(std::string msg = "");
  void to_be_truthy(std::string msg = "");
 
  template <typename E>
  void to_be_between(E min, E max, Matchers::RangeMode mode = Matchers::RangeMode::inclusive, std::string msg = "");
 
  template <typename E>
  void to_be_greater_than(E rhs, std::string msg = "");
 
  template <typename E>
  void to_be_less_than(E rhs, std::string msg = "");
 
  template <typename E>
  Matchers::BeWithinHelper<A, E> to_be_within(E expected, std::string msg = "");
 
  /*-------- to... ----------*/
 
  void to_end_with(std::string ending, std::string msg = "");
  void to_fail(std::string msg = "");
  void to_fail_with(std::string failure_message, std::string msg = "");
  void to_match(std::regex regex, std::string msg = "");
  void to_match(std::string str, std::string msg = "");
  void to_partially_match(std::regex regex, std::string msg = "");
  void to_partially_match(std::string str, std::string msg = "");
  template <typename F>
    requires std::invocable<F, A> && std::convertible_to<std::invoke_result_t<F, A>, bool>
  void to_satisfy(F test, std::string msg = "");
  void to_start_with(std::string start, std::string msg = "");
 
  template <typename U>
  void to_contain(std::initializer_list<U> expected, std::string msg = "");
 
  template <typename E>
  void to_contain(E expected, std::string msg = "");
 
  template <typename U>
  void to_end_with(std::initializer_list<U> start, std::string msg = "");
 
  template <typename E>
  void to_equal(E expected, std::string msg = "");
 
  template <typename U>
  void to_start_with(std::initializer_list<U> start, std::string msg = "");
 
  void to_have_value(std::string msg = "");
#if __cpp_lib_expected
  void to_have_error(std::string msg = "");
#endif
};

template <typename A>
template <class M>
void Expectation<A>::to(M matcher, std::string msg) {
  static_assert(std::is_base_of_v<Matchers::MatcherBase<A, typename M::expected_t>, M>,
                "Matcher is not a subclass of BaseMatcher.");
  // auto base_matcher = static_cast<Matchers::BaseMatcher<A,typename
  // M::expected_t>>(matcher);
  matcher.set_message(std::move(msg)).run();
}

template <typename A>
void Expectation<A>::to_be_false(std::string msg) {
  static_assert(std::is_same_v<A, bool>,
                ".to_be_false() can only be used on booleans or functions that return booleans");
  to_equal(false, msg);
}

template <typename A>
void Expectation<A>::to_be_falsy(std::string msg) {
  to_satisfy([](const A& t) { return !static_cast<bool>(t); }, msg);
}

template <typename A>
void Expectation<A>::to_be_null(std::string msg) {
  Matchers::BeNullptr<A>(*this).set_message(std::move(msg)).run();
}

template <typename A>
void Expectation<A>::to_be_true(std::string msg) {
  static_assert(std::is_same_v<A, bool>,
                ".to_be_true() can only be used on booleans or functions that return booleans");
  // return to_be([](A t) { return static_cast<bool>(t); }, msg);
  to_equal(true, msg);
}

template <typename A>
void Expectation<A>::to_be_truthy(std::string msg) {
  to_satisfy([](const A& t) { return static_cast<bool>(t); }, msg);
}

template <typename A>
template <typename E>
void Expectation<A>::to_be_between(E min, E max, Matchers::RangeMode mode, std::string msg) {
  Matchers::BeBetween<A, E>(*this, min, max, mode).set_message(std::move(msg)).run();
}
 
template <typename A>
template <typename E>
void Expectation<A>::to_be_less_than(E rhs, std::string msg) {
  Matchers::BeLessThan<A, E>(*this, rhs).set_message(std::move(msg)).run();
}
 
template <typename A>
template <typename E>
void Expectation<A>::to_be_greater_than(E rhs, std::string msg) {
  Matchers::BeGreaterThan<A, E>(*this, rhs).set_message(std::move(msg)).run();
}

template <typename A>
template <typename U>
void Expectation<A>::to_contain(std::initializer_list<U> expected, std::string msg) {
  Matchers::Contain<A, std::vector<U>, U>(*this, expected).set_message(std::move(msg)).run();
}

template <typename A>
template <typename E>
void Expectation<A>::to_contain(E expected, std::string msg) {
  Matchers::Contain<A, E, E>(*this, expected).set_message(std::move(msg)).run();
}

template <typename A>
template <typename E>
void Expectation<A>::to_equal(E expected, std::string msg) {
  Matchers::Equal<A, E>(*this, expected).set_message(std::move(msg)).run();
}

template <typename A>
template <typename E>
Matchers::BeWithinHelper<A, E> Expectation<A>::to_be_within(E expected, std::string msg) {
  Matchers::BeWithinHelper<A, E> matcher(*this, expected);
  matcher.set_message(std::move(msg));
  return matcher;
}
 
template <typename A>
void Expectation<A>::to_fail(std::string msg) {
  static_assert(is_result_v<A>, ".to_fail() must be used on an expression that returns a Result.");
  Matchers::Fail<Result>(*this).set_message(std::move(msg)).run();
}
 
template <typename A>
void Expectation<A>::to_fail_with(std::string failure_message, std::string msg) {
  static_assert(is_result_v<A>, ".to_fail_with() must be used on an expression that returns a Result.");
  Matchers::FailWith<A>(*this, failure_message).set_message(std::move(msg)).run();
}
 
template <typename A>
void Expectation<A>::to_match(std::string str, std::string msg) {
  Matchers::Match<A>(*this, str).set_message(std::move(msg)).run();
}
 
template <typename A>
void Expectation<A>::to_match(std::regex regex, std::string msg) {
  Matchers::Match<A>(*this, regex).set_message(std::move(msg)).run();
}
 
template <typename A>
void Expectation<A>::to_partially_match(std::string str, std::string msg) {
  Matchers::MatchPartial<A>(*this, str).set_message(std::move(msg)).run();
}
 
template <typename A>
void Expectation<A>::to_partially_match(std::regex regex, std::string msg) {
  Matchers::MatchPartial<A>(*this, regex).set_message(std::move(msg)).run();
}

template <typename A>
template <typename F>
  requires std::invocable<F, A> && std::convertible_to<std::invoke_result_t<F, A>, bool>
void Expectation<A>::to_satisfy(F test, std::string msg) {
  Matchers::Satisfy<A>(*this, std::function<bool(A)>(std::move(test))).set_message(std::move(msg)).run();
}
 
template <typename A>
void Expectation<A>::to_start_with(std::string start, std::string msg) {
  Matchers::StartWith<std::string, std::string>(*this, start).set_message(std::move(msg)).run();
}
 
template <typename A>
template <typename U>
void Expectation<A>::to_start_with(std::initializer_list<U> start_sequence, std::string msg) {
  Matchers::StartWith<A, std::initializer_list<U>>(*this, start_sequence).set_message(std::move(msg)).run();
}
 
template <typename A>
void Expectation<A>::to_end_with(std::string ending, std::string msg) {
  Matchers::EndWith<std::string, std::string>(*this, ending).set_message(std::move(msg)).run();
}
 
template <typename A>
template <typename U>
void Expectation<A>::to_end_with(std::initializer_list<U> end_sequence, std::string msg) {
  Matchers::EndWith<A, std::initializer_list<U>>(*this, end_sequence).set_message(std::move(msg)).run();
}
 
template <typename A>
void Expectation<A>::to_have_value(std::string msg) {
  Matchers::HaveValue<A>(*this).set_message(std::move(msg)).run();
}
 
#if __cpp_lib_expected
template <typename A>
void Expectation<A>::to_have_error(std::string msg) {
  Matchers::HaveError<A>(*this).set_message(std::move(msg)).run();
}
#endif
 
template <typename A>
class ExpectationValue : public Expectation<A> {
  A value;
 
 public:
  ExpectationValue(ItBase& it, A value, std::source_location location) : Expectation<A>(it, location), value(value) {}
  explicit ExpectationValue(A value, std::source_location location = std::source_location::current())
      : Expectation<A>(location), value(value) {}

  template <typename U>
  ExpectationValue(ItBase& it, std::initializer_list<U> init_list, std::source_location location)
      : Expectation<A>(it, location), value(std::vector<U>(init_list)) {}

  A& get_target() & override { return value; }
 
  ExpectationValue& not_() override {
    this->is_positive_ = not this->is_positive_;
    return *this;
  }
 
  ExpectationValue& ignore() override {
    this->ignore_ = true;
    return *this;
  }
};
 
template <Util::is_functional F>
class ExpectationFunc : public Expectation<decltype(std::declval<F>()())> {
  using block_ret_t = decltype(std::declval<F>()());
  F block;
  std::optional<block_ret_t> computed = std::nullopt;
 
 public:
  ExpectationFunc(ExpectationFunc<F> const& copy, std::source_location location)
      : Expectation<block_ret_t>(copy, location), block(copy.block) {}

  ExpectationFunc(ItBase& it, F block, std::source_location location)
      : Expectation<block_ret_t>(it, location), block(block) {}

  // TODO: create a "lazy" parameter for differentiating between delayed and
  // immediate execution
  //  ExpectationFunc(BaseIt &it, std::function<A()> block)
  //      : Expectation(it), block(block()){};  // block(block), has_block(true)
  //      {}

  block_ret_t& get_target() & override {
    if (!computed.has_value()) {
      computed.emplace(block());
    }
    return *computed;
  }
 
  // auto get_target() &  override -> decltype(std::declval<A>()()) & { return
  // Expectation<A>::get_target()(); }
 
  ExpectationFunc& not_() override {
    this->is_positive_ = !this->is_positive_;
    return *this;
  }
 
  ExpectationFunc& ignore() override {
    this->ignore_ = true;
    return *this;
  }
 
  Expectation<decltype(block())>& casted() { return static_cast<decltype(block())>(*this); }
 
  template <typename Ex = std::exception>
  void to_throw(std::string msg = "");
};
 
template <Util::is_functional F>
template <typename Ex>
void ExpectationFunc<F>::to_throw(std::string msg) {
  Matchers::Throw<decltype(this->block.operator()()), Ex>(*this).set_message(std::move(msg)).run();
}
 
}  // namespace CppSpec