Custom matchers and Expectation::to

Author: toroidal-code

include/expectations/expectation.hpp

@@ -37,14 +37,21 @@ class Expectation : public Child {
   bool is_positive = true;  // Have we been negated?
 
  public:
+  Expectation(Expectation const &copy)
+      :  // Child(((Expectation)copy).get_parent())
+        target(copy.target),
+        block(copy.block),
+        has_block(copy.has_block),
+        is_positive(copy.is_positive){};
+
   /**
    * @brief Create an Expectation using a value.
    *
    * @param value The target to test, an explicit value.
    *
    * @return The constructed Expectation.
    */
-  Expectation(ItBase &it, A &value) : Child(it), target(value) {}
+  Expectation(ItBase &it, A value) : Child(it), target(value) {}
 
   /**
    * @brief Create an Expectation using a function.
@@ -81,6 +88,9 @@ class Expectation : public Child {
 
   Expectation &not_();
 
+  template <class M>
+  bool to(M matcher, std::string msg = "");
+
   bool to_be(std::function<bool(A)>, std::string msg = "");
   bool to_be_null(std::string msg = "");
   bool to_be_true(std::string msg = "");
@@ -107,7 +117,7 @@ class Expectation : public Child {
  */
 template <typename A>
 Expectation<A> &Expectation<A>::not_() {
-  is_positive = not is_positive;
+  this->is_positive = not this->is_positive;
   return *this;
 }
 
@@ -244,6 +254,18 @@ Matchers::BeWithin<A, E> Expectation<A>::to_be_within(E expected,
   matcher.set_message(msg);
   return matcher;
 }
+
+template <typename A>
+template <class M>
+bool Expectation<A>::to(M matcher, std::string msg) {
+  static_assert(
+      std::is_base_of<Matchers::BaseMatcher<A, typename M::expected_t>,
+                      M>::value,
+      "Matcher is not a subclass of BaseMatcher.");
+  // auto base_matcher = static_cast<Matchers::BaseMatcher<A,typename
+  // M::expected_t>>(matcher);
+  return matcher.set_message(msg).run();
+}
 }
 
 #endif /* EXPECTATION_H */

include/matchers/basematcher.hpp

@@ -41,11 +41,14 @@ class BaseMatcher : public Runnable, public Pretty {
   virtual std::string description();
   Actual &get_actual() { return expectation.get_target(); }
   Expected &get_expected() { return expected; }
+  Expectation<Actual> &get_expectation() { return expectation; }
   virtual BaseMatcher &set_message(std::string message) {
     this->message = message;
     return *this;
   }
   bool run() override;
+
+  typedef Expected expected_t;
 };
 
 template <typename A, typename E>
@@ -65,7 +68,9 @@ std::string BaseMatcher<A, E>::failure_message_when_negated() {
 template <typename A, typename E>
 std::string BaseMatcher<A, E>::description() {
   std::stringstream ss;
-  ss << this->name_to_sentance() << this->to_sentance(expected);
+  std::string pretty_expected = this->to_sentance(expected);
+  ss << "match " << this->name_to_sentance(Util::demangle(typeid(*this).name()))
+     << "(" << pretty_expected.substr(1, pretty_expected.length()) << ")";
   return ss.str();
 }
 

include/matchers/pretty_matchers.hpp

@@ -19,8 +19,8 @@ class BaseMatcher;
  */
 struct Pretty {
   std::string _name = "";
-  std::string name();
-  std::string name_to_sentance();
+  std::string name(std::string name);
+  std::string name_to_sentance(std::string name);
   static std::string split_words(std::string sym);
   static std::string underscore(std::string camel_cased_word);
   static std::string last(const std::string &s, const char delim);
@@ -164,11 +164,13 @@ std::string Pretty::to_word_type(T &item) {
   return word;
 }
 
-std::string Pretty::name_to_sentance() { return split_words(name()); }
+std::string Pretty::name_to_sentance(std::string n) {
+  return split_words(name(n));
+}
 
-std::string Pretty::name() {
+std::string Pretty::name(std::string name) {
   if (_name.empty()) {
-    return last(typeid(this).name(), ':');
+    return last(name, ':');
   } else {
     return _name;
   }

spec/CMakeLists.txt

@@ -6,6 +6,11 @@ add_executable( describe_a_spec describe_a_spec.cpp )
 target_link_libraries( describe_a_spec c++spec ${CMAKE_THREAD_LIBS_INIT} )
 add_test ( describe_a_spec describe_a_spec )
 
+add_executable( expectation_spec expectations/expectation_spec.cpp )
+target_link_libraries( expectation_spec c++spec ${CMAKE_THREAD_LIBS_INIT} )
+add_test ( expectation_spec expectation_spec )
+
+
 add_executable( be_within_spec matchers/be_within_spec.cpp )
 target_link_libraries( be_within_spec c++spec ${CMAKE_THREAD_LIBS_INIT} )
 add_test ( be_within_spec be_within_spec )

spec/expectations/expectation_spec.cpp

@@ -0,0 +1,22 @@
+#include "cppspec.hpp"
+
+// Very simple int<=>int custom matcher
+struct CustomMatcher : public Matchers::BaseMatcher<int, int> {
+  CustomMatcher(CustomMatcher const &copy)
+      : Matchers::BaseMatcher<int,int>(((CustomMatcher)copy).get_expectation(),
+                                       ((CustomMatcher)copy).get_expected()){};
+  CustomMatcher(Expectations::Expectation<int> &expectation, int expected)
+      : Matchers::BaseMatcher<int,int>(expectation, expected){};
+  bool match() { return get_expected() == get_actual(); }
+};
+
+describe expectation_spec("Expectation", $ {
+  context("Extensible .to", _ {
+    it("accepts a custom BaseMatcher subclass", _ {
+      auto e = expect(2);
+      e.to(CustomMatcher(e, 4));
+    });
+  });
+});
+
+int main() { return expectation_spec.run() ? EXIT_SUCCESS : EXIT_FAILURE; }