it.hpp

Go to the documentation of this file.

#pragma once
 
#include <source_location>
#include <string>
#include <utility>
#include <vector>
 
#include "expectations/expectation.hpp"
 
namespace CppSpec {

class ItD : public ItBase {
 public:
  using Block = std::function<void(ItD&)>;
 
 private:
  const Block block;
 
 public:
  ItD(std::source_location location, const char* description, Block block)
      : ItBase(location, description), block(std::move(block)) {}

  ItD(std::source_location location, Block block) : ItBase(location), block(block) {}
 
  // implemented in description.hpp
  void run() override;
};

template <typename T>
class ItCD : public ItBase {
 public:
  using Block = std::function<void(ItCD<T>&)>;
 
 private:
  const Block block;
 
 public:
  T& subject;
 
  // This is only ever instantiated by ClassDescription<T>
  ItCD(std::source_location location, T& subject, const char* description, Block block)
      : ItBase(location, description), block(block), subject(subject) {}
 
  ItCD(std::source_location location, T& subject, Block block) : ItBase(location), block(block), subject(subject) {}
 
  ExpectationValue<T> is_expected(std::source_location location = std::source_location::current()) {
    return {*this, subject, location};
  }
  void run() override;
};

template <Util::is_not_functional T>
ExpectationValue<T> ItBase::expect(T value, std::source_location location) {
  return {*this, value, location};
}
 
template <Util::is_functional T>
ExpectationFunc<T> ItBase::expect(T block, std::source_location location) {
  return {*this, block, location};
}
 
template <typename T>
ExpectationValue<T> ItBase::expect(Let<T>& let, std::source_location location) {
  return {*this, let.value(), location};
}

template <typename T>
ExpectationValue<std::initializer_list<T>> ItBase::expect(std::initializer_list<T> init_list,
                                                          std::source_location location) {
  return {*this, init_list, location};
}
 
inline ExpectationValue<std::string> ItBase::expect(const char* str, std::source_location location) {
  return {*this, std::string(str), location};
}
 
}  // namespace CppSpec