.fail[_with] and related specs

Author: toroidal-code

include/expectations/expectation.hpp

@@ -10,6 +10,7 @@
 #include "matchers/be_within.hpp"
 #include "matchers/include.hpp"
 #include "matchers/equal.hpp"
+#include "matchers/fail.hpp"
 
 namespace Expectations {
 
@@ -102,6 +103,8 @@ class Expectation : public Child {
   Result to_be_null(std::string msg = "");
   Result to_be_true(std::string msg = "");
   Result to_be_false(std::string msg = "");
+  Result to_fail(std::string msg = "");
+  Result to_fail_with(std::string failure_message, std::string msg = "");
 
   template <typename U>
   Result to_include(std::initializer_list<U> expected, std::string msg = "");
@@ -271,6 +274,39 @@ Matchers::BeWithin<A, E> Expectation<A>::to_be_within(E expected,
   return matcher;
 }
 
+template <typename A>
+Result Expectation<A>::to_fail(std::string msg) {
+  static_assert(std::is_same<A, Result>::value,
+                "Error: to_fail must me used on an expression that "
+                "returns a Result.");
+  return Matchers::Fail<Result>(*this).set_message(msg).run();
+}
+
+// template <typename A>
+// Result Expectation<A>::to_fail(std::string) {
+//  static_assert(
+//      false,
+//      "Error: to_fail must me used on an expression that returns a Result");
+//  return Result::failure;
+//}
+
+template <typename A>
+Result Expectation<A>::to_fail_with(std::string failure_message,
+                                    std::string msg) {
+  static_assert(std::is_same<A, Result>::value,
+                "Error: to_fail_with must be used on an expression that "
+                "returns a Result.");
+  return Matchers::FailWith<A>(*this, failure_message).set_message(msg).run();
+}
+//
+// template <typename A>
+// Result Expectation<A>::to_fail_with(std::string, std::string) {
+//  static_assert(
+//      false,
+//      "Error: to_fail must me used on an expression that returns a Result");
+//  return Result::failure;
+//}
+
 template <typename A>
 template <class M>
 Result Expectation<A>::to(M matcher, std::string msg) {

include/matchers/fail.hpp

@@ -0,0 +1,36 @@
+#ifndef CPPSPEC_FAIL_HPP
+#define CPPSPEC_FAIL_HPP
+#include "basematcher.hpp"
+
+namespace Matchers {
+template <typename A>
+class Fail : public BaseMatcher<A, void *> {
+ public:
+  static_assert(std::is_same<A, Result>::value,
+                ".fail must be matched against a Result.");
+  Fail(Expectations::Expectation<A> &expectation)
+      : BaseMatcher<A, void *>(expectation, nullptr){};
+  typename std::enable_if<std::is_same<A, Result>::value, bool>::type match() {
+    return not this->get_actual().get_status();
+  }
+};
+
+template <typename A>
+class FailWith : public Matchers::BaseMatcher<A, std::string> {
+ public:
+  FailWith(Expectations::Expectation<A> &expectation, std::string expected)
+      : Matchers::BaseMatcher<A, std::string>(expectation, expected){};
+  typename std::enable_if<std::is_same<A, Result>::value, bool>::type match();
+};
+
+template <typename A>
+typename std::enable_if<std::is_same<A, Result>::value, bool>::type
+FailWith<A>::match() {
+  static_assert(std::is_same<A, Result>::value,
+                ".fail_with must be matched against a Result.");
+  return (not this->get_actual().get_status()) &&
+         this->get_actual().get_message() == this->get_expected();
+}
+}
+
+#endif  // CPP_SPEC_FAIL_HPP

include/runnable.hpp

@@ -76,27 +76,49 @@ class Child {
 
 class Result {
   bool value;
-  std::string failure_message = "";
+  std::string message = "";
   Result(){};
   Result(bool value, std::string failure_message = "")
-      : value(value), failure_message(failure_message){};
+      : value(value), message(failure_message){};
 
  public:
-  Result(Result const& copy)
-      : value(copy.value), failure_message(copy.failure_message) {}
+  Result(Result const& copy) : value(copy.value), message(copy.message) {}
   operator bool() const { return value; }
   static Result success;
+  static Result success_with(std::string success_message) {
+    return Result(true, success_message);
+  }
   static Result failure;
   static Result failure_with(std::string failure_message) {
     return Result(false, failure_message);
   }
 
-  std::string get_message() { return failure_message; }
+  std::string get_message() { return message; }
+  const std::string get_message() const { return message; }
+  Result& set_message(std::string message) {
+    message = message;
+    return *this;
+  }
   bool get_status() { return value; }
+
+  friend std::ostream& operator<<(std::ostream& os, const Result& res);
 };
 
 Result Result::success = Result(true);
 Result Result::failure = Result(false);
+std::ostream& operator<<(std::ostream& os, const Result& res) {
+  std::string str;
+  if (res) {
+    str = "Result::success" + (not res.get_message().empty()
+                                   ? "(\"" + res.get_message() + "\")"
+                                   : "");
+  } else {
+    str = "Result::failure" + (not res.get_message().empty()
+                                   ? "(\"" + res.get_message() + "\")"
+                                   : "");
+  }
+  return os << str;
+}
 
 /**
  * @brief Abstract base class for executable objects

spec/expectations/expectation_spec.cpp

@@ -35,6 +35,43 @@ describe expectation_spec("Expectation", $ {
     });
   });
 
+  context(".to_fail", _ {
+    it("is true when Result is false", _ {
+      expect(Result::failure).to_fail();
+    });
+
+    it("is false when Result is true", _ {
+      expect(expect(Result::success).ignore().to_fail().get_status()).to_be_false();
+      expect(expect(Result::success).ignore().to_fail()).to_fail();
+    });
+  });
+
+  context(".to_fail_with", _ {
+    it("is true when Result is false and messages match", _ {
+      expect(Result::failure_with("failure")).to_fail_with("failure");
+    });
+
+    context("is false when Result", _ {
+      it("is false and messages don't match", _ {
+        expect(
+          expect(Result::failure_with("fail")).ignore().to_fail_with("failure").get_status()
+        ).to_be_false();
+      });
+
+      it("is true and messages match", _ {
+        expect(
+            expect(Result::success_with("failure")).ignore().to_fail_with("failure").get_status()
+        ).to_be_false();
+      });
+
+      it("is true and messages don't match", _ {
+        expect(
+            expect(Result::success_with("fail")).ignore().to_fail_with("failure").get_status()
+        ).to_be_false();
+      });
+    });
+  });
+
   context(".ignore()", [=] (Description &self) {
     ItD i(self, _ {});
 #undef expect