Add in_interval matcher

jimporter · Feb 25, 2024 · 54518c8 · 54518c8
1 parent bda6660
commit 54518c8
Show file tree

Hide file tree

Showing 3 changed files with 105 additions and 0 deletions.
diff --git a/doc/built-in-matchers.md b/doc/built-in-matchers.md
@@ -81,6 +81,16 @@ according to the `<` operator.
 A matcher that returns `true` when the actual value is less than or equal to
 `value` according to the `<=` operator.
 
+### in_interval(*low*, *high*[, *bounds*])
+
+A matcher that returns `true` when the actual value is between `low` and `high`.
+`bounds` can be one of the following:
+
+* `interval::closed`: expects `low <= actual <= high`
+* `interval::left_open`: expects `low < actual <= high`
+* `interval::right_open`: expects `low <= actual < high` (the default)
+* `interval::open`: expects `low < actual < high`
+
 ## Arithmetic
 *&lt;mettle/matchers/arithmetic.hpp&gt;*
 {: .subtitle}

diff --git a/include/mettle/matchers/relational.hpp b/include/mettle/matchers/relational.hpp
@@ -34,6 +34,62 @@ namespace mettle {
     return basic_matcher(std::forward<T>(expected), std::less_equal<>(), "<= ");
   }
 
+  enum class interval {
+    closed     = 0b00,
+    left_open  = 0b10,
+    right_open = 0b01,
+    open       = 0b11
+  };
+
+  template<typename Low, typename High>
+  class in_interval : public matcher_tag {
+  public:
+    in_interval(detail::any_capture<Low> low, detail::any_capture<High> high,
+                interval bounds = interval::right_open) :
+      low_(std::move(low)), high_(std::move(high)), bounds_(bounds) {}
+
+    template<typename U>
+    bool operator ()(U &&actual) const {
+      if (left_open()) {
+        if (actual <= low_.value) return false;
+      } else {
+        if (actual < low_.value) return false;
+      }
+
+      if (right_open()) {
+        if (actual >= high_.value) return false;
+      } else {
+        if (actual > high_.value) return false;
+      }
+
+      return true;
+    }
+
+    std::string desc() const {
+      std::ostringstream ss;
+      ss << "in " << (left_open() ? "(" : "[") << to_printable(low_.value)
+         << " .. " << to_printable(high_.value) << (right_open() ? ")" : "]");
+      return ss.str();
+    }
+  private:
+    inline bool left_open() const {
+      return static_cast<int>(bounds_) & static_cast<int>(interval::left_open);
+    }
+
+    inline bool right_open() const {
+      return static_cast<int>(bounds_) & static_cast<int>(interval::right_open);
+    }
+
+    detail::any_capture<Low> low_;
+    detail::any_capture<High> high_;
+    interval bounds_;
+  };
+
+  template<typename Low, typename High>
+  in_interval(Low &&, High &&) -> in_interval<Low, High>;
+  template<typename Low, typename High>
+  in_interval(Low &&, High &&, interval) -> in_interval<Low, High>;
+
 } // namespace mettle
 
 #endif
diff --git a/test/matchers/test_matchers.cpp b/test/matchers/test_matchers.cpp
@@ -221,6 +221,45 @@ suite<> test_matchers("matchers", [](auto &_) {
 
       expect(less_equal(123).desc(), equal_to("<= 123"));
     });
+
+    subsuite<>(_, "in_interval()", [](auto &_) {
+      _.test("right_open", []() {
+        expect(123, in_interval(100, 200));
+        expect(100, in_interval(100, 200));
+        expect(200, is_not(in_interval(100, 200)));
+        expect(in_interval(100, 200).desc(), equal_to("in [100 .. 200)"));
+
+        expect(123, in_interval(100, 200, interval::right_open));
+        expect(100, in_interval(100, 200, interval::right_open));
+        expect(200, is_not(in_interval(100, 200, interval::right_open)));
+        expect(in_interval(100, 200, interval::right_open).desc(),
+               equal_to("in [100 .. 200)"));
+      });
+
+      _.test("left_open", [] () {
+        expect(123, in_interval(100, 200, interval::left_open));
+        expect(100, is_not(in_interval(100, 200, interval::left_open)));
+        expect(200, in_interval(100, 200, interval::left_open));
+        expect(in_interval(100, 200, interval::left_open).desc(),
+               equal_to("in (100 .. 200]"));
+      });
+
+      _.test("open", [] () {
+        expect(123, in_interval(100, 200, interval::open));
+        expect(100, is_not(in_interval(100, 200, interval::open)));
+        expect(200, is_not(in_interval(100, 200, interval::open)));
+        expect(in_interval(100, 200, interval::open).desc(),
+               equal_to("in (100 .. 200)"));
+      });
+
+      _.test("closed", [] () {
+        expect(123, in_interval(100, 200, interval::closed));
+        expect(100, in_interval(100, 200, interval::closed));
+        expect(200, in_interval(100, 200, interval::closed));
+        expect(in_interval(100, 200, interval::closed).desc(),
+               equal_to("in [100 .. 200]"));
+      });
+    });
   });
 
   subsuite<>(_, "arithmetic", [](auto &_) {