Merge branch 'fix/partially-match-searches'

Author: stellar-aria

include/matchers/strings/match.hpp

@@ -7,16 +7,25 @@
 
 namespace CppSpec::Matchers {
 
+// A std::regex keeps no copy of its source, so a pattern given as text is named by that text; one given as a
+// std::regex is named only as a regex.
+inline std::string describe_pattern(const std::string& pattern) {
+  return pattern.empty() ? std::string{"a regex"} : "\"" + pattern + "\"";
+}
+
 template <typename A>
 class Match : public MatcherBase<A, std::regex> {
+  std::string pattern_;
+
  public:
   explicit Match(Expectation<A>& expectation, std::string expected)
-      : MatcherBase<A, std::regex>(expectation, std::regex(expected)) {}
+      : MatcherBase<A, std::regex>(expectation, std::regex(expected)), pattern_(std::move(expected)) {}
 
   explicit Match(Expectation<A>& expectation, std::regex expected)
       : MatcherBase<A, std::regex>(expectation, expected) {}
 
   std::string verb() override { return "match"; }
+  std::string description() override { return verb() + " " + describe_pattern(pattern_); }
 
   bool match() override {
     std::smatch temp_match;
@@ -26,16 +35,19 @@ class Match : public MatcherBase<A, std::regex> {
 
 template <typename A>
 class MatchPartial : public MatcherBase<A, std::regex> {
+  std::string pattern_;
+
  public:
   explicit MatchPartial(Expectation<A>& expectation, std::string expected)
-      : MatcherBase<A, std::regex>(expectation, std::regex(expected)) {}
+      : MatcherBase<A, std::regex>(expectation, std::regex(expected)), pattern_(std::move(expected)) {}
 
   explicit MatchPartial(Expectation<A>& expectation, std::regex expected)
       : MatcherBase<A, std::regex>(expectation, expected) {}
 
-  std::string description() override { return "partially match " + Pretty::to_word(this->expected()); }
+  std::string description() override { return "partially match " + describe_pattern(pattern_); }
 
-  bool match() override { return std::regex_match(this->actual(), this->expected()); }
+  // A partial match is a match anywhere in the string: a search, not a match of the whole.
+  bool match() override { return std::regex_search(this->actual(), this->expected()); }
 };
 
 }  // namespace CppSpec::Matchers

spec/matchers/string_spec.cpp

@@ -6,6 +6,7 @@
 
 using namespace CppSpec;
 
+// clang-format off
 describe string_spec("string matchers", $ {
   context("to_start_with (string)", _ {
     it("passes when string starts with prefix", _ {
@@ -105,6 +106,32 @@ describe string_spec("string matchers", $ {
     });
   });
 
+  context("to_partially_match (regex search)", _ {
+    it("passes when the pattern occurs anywhere in the string", _ {
+      expect(std::string{"the groove differs"}).to_partially_match("groove");
+    });
+
+    it("passes for a pattern at the start or the end", _ {
+      expect(std::string{"groove differs"}).to_partially_match("^groove");
+      expect(std::string{"it differs"}).to_partially_match("differs$");
+    });
+
+    it("fails when the pattern does not occur", _ {
+      expect(std::string{"the groove differs"}).not_().to_partially_match("drum");
+    });
+
+    it("searches with a regex too", _ {
+      expect(std::string{"OUTPUT 1 DIFFERS"}).to_partially_match(std::regex("output [0-9]", std::regex::icase));
+    });
+
+    it("names a string pattern by its text", _ {
+      auto e = expect(std::string{"x"});
+      expect(Matchers::MatchPartial<std::string>(e, "groove").description())
+          .to_equal(std::string{"partially match \"groove\""});
+      expect(Matchers::Match<std::string>(e, "gr.*ve").description()).to_equal(std::string{"match \"gr.*ve\""});
+    });
+  });
+
   context("string to_contain (char)", _ {
     it("finds a character in a string", _ {
       expect(std::string{"abcde"}).to_contain('c');