Revert to using enum for BeBetween

Author: toroidal-code

examples/sample/example_spec.cpp

@@ -5,102 +5,102 @@
 
 
 describe bool_spec("Some Tests", $ {
-    context("true is", _ {
-        it("true", _ {
-            expect(static_cast<bool>(1)).to_equal(true);
-          });
-
-        it("true", _ {
-            expect(true).to_equal(true);
-          });
-
-      });
-
-    int i = 4;    
-    explain("4", _ {
-        it("equals 4", _ {
-            expect(i).to_equal(4);
-          });
-        it("does not equal 5", _ {
-            expect(i).not_().to_equal(5);
-          });
-
-        it("plus 1 equals 5", _ {
-            expect(i+1).to_equal(5);
-          });
-      });
-
-    explain("0 is", _ {
-        it("between -1 and 1 (exclusive)", _ {
-            expect(0).to_be_between(-1, 1).exclusive();
-          });
-        it("between -0 and 0 (inclusive)", _ {
-            expect(0).to_be_between(-0,0).inclusive();
-          });
-        it("not between -0 and 0 (exclusive)", _ {
-            expect(0).not_().to_be_between(-0,0).exclusive();
-          });
-        it("not between 1 and -1 (inclusive)", _ {
-            expect(0).not_().to_be_between(1,-1).inclusive();
-          });
-        it("between -1.0 and 1.0 (exclusive)", _ {
-            expect(0).to_be_between(-1.0, 1.0).exclusive();
-          });
-      });
-
-
-    explain("{1,2,3}", _ {
-        it("includes 1", _ {
-            expect({1,2,3}).to_include({1});
-          });
-        it("includes [1,2,3]", _ {
-            expect({1,2,3}).to_include({1,2,3});
-          });
-        it("does not include 4", _ {
-            expect({1,2,3}).not_().to_include({4});
-          });
-
-        it("does not include [4,5,6]", _ {
-            expect({1,2,3}).not_().to_include({4,5,6});
-          });
-      });
-
-
-    explain <std::list<int>> ({1,2,3}, _ {
-        it(_ { is_expected().to_include(1); });
-
-        it("includes [1,2,3]", _ {
-            expect<std::list<int>>({1,2,3}).to_include({1,2,3});
-          });
-
-        it( _ { is_expected().not_().to_include(4); });
-
-        it("does not include [4,5,6]", _ {
-            is_expected().not_().to_include({4,5,6});
-          });
-      });
-
-
-    // context("std::map {{1,2},{3,4},{5,6}}", _ {
-    //     it("includes 1", _ {
-    //         std::map<int,int> m = {{1,2},{3,4},{5,6}};
-    //         expect(m).to_include({1});
-    //       });
-    //     it("includes [1,2,3]", _ {
-    //         std::map<int,int> m = {{1,2},{3,4},{5,6}};
-    //         expect(m).to_include({1,2,3});
-    //       });
-    //     it("does not include 4", _ {
-    //         std::map<int,int> m = {{1,2},{3,4},{5,6}};
-    //         expect(m).not_().to_include({4});
-    //       });
-    //     it("does not include 4,5,6", _ {
-    //         std::map<int,int> m = {{1,2},{3,4},{5,6}};
-    //         expect({1,2,3}).not_().to_include({4,5,6});
-    //       });
-    //   });
+  context("true is", _ {
+    it("true", _ {
+      expect(static_cast<bool>(1)).to_equal(true);
+    });
+
+    it("true", _ {
+      expect(true).to_equal(true);
+    });
+
+  });
+
+  int i = 4;
+  explain("4", _ {
+    it("equals 4", _ {
+      expect(i).to_equal(4);
+    });
+    it("does not equal 5", _ {
+      expect(i).not_().to_equal(5);
+    });
+
+    it("plus 1 equals 5", _ {
+      expect(i+1).to_equal(5);
+    });
+  });
+
+  explain("0 is", _ {
+    using namespace Matchers;
+    it("between -1 and 1 (exclusive)", _ {
+      expect(0).to_be_between(-1, 1, RangeMode::exclusive);
+    });
+    it("between -0 and 0 (inclusive)", _ {
+      expect(0).to_be_between(-0,0, RangeMode::inclusive);
+    });
+    it("not between -0 and 0 (exclusive)", _ {
+      expect(0).not_().to_be_between(-0,0, RangeMode::exclusive);
+    });
+    it("not between 1 and -1", _ {
+      expect(0).not_().to_be_between(1,-1);
+    });
+    it("between -1.0 and 1.0 (exclusive)", _ {
+      expect(0).to_be_between(-1.0, 1.0, RangeMode::exclusive);
+    });
+  });
+
+
+  explain("{1,2,3}", _ {
+    it("includes 1", _ {
+      expect({1,2,3}).to_include({1});
+    });
+    it("includes [1,2,3]", _ {
+      expect({1,2,3}).to_include({1,2,3});
+    });
+    it("does not include 4", _ {
+      expect({1,2,3}).not_().to_include({4});
+    });
+
+    it("does not include [4,5,6]", _ {
+      expect({1,2,3}).not_().to_include({4,5,6});
+    });
+  });
+
+
+  explain <std::list<int>> ({1,2,3}, _ {
+    it(_ { is_expected().to_include(1); });
+
+    it("includes [1,2,3]", _ {
+      expect<std::list<int>>({1,2,3}).to_include({1,2,3});
+    });
+
+    it( _ { is_expected().not_().to_include(4); });
+
+    it("does not include [4,5,6]", _ {
+      is_expected().not_().to_include({4,5,6});
+    });
   });
 
+  // context("std::map {{1,2},{3,4},{5,6}}", _ {
+  //     it("includes 1", _ {
+  //         std::map<int,int> m = {{1,2},{3,4},{5,6}};
+  //         expect(m).to_include({1});
+  //       });
+  //     it("includes [1,2,3]", _ {
+  //         std::map<int,int> m = {{1,2},{3,4},{5,6}};
+  //         expect(m).to_include({1,2,3});
+  //       });
+  //     it("does not include 4", _ {
+  //         std::map<int,int> m = {{1,2},{3,4},{5,6}};
+  //         expect(m).not_().to_include({4});
+  //       });
+  //     it("does not include 4,5,6", _ {
+  //         std::map<int,int> m = {{1,2},{3,4},{5,6}};
+  //         expect({1,2,3}).not_().to_include({4,5,6});
+  //       });
+  //   });
+});
+
 describe abs_spec("abs", $ {
   // you can use the `explain` keyword to
   // group behavior and nest descriptions
@@ -184,10 +184,10 @@ describe let_spec("let", $ {
 //   });
 
 describe list_spec("A list spec", $ {
-    explain <std::list<int>> ({1,2,3,4}, _ {
-        it( _ { is_expected().to_include(6); });
-      });
+  explain <std::list<int>> ({1,2,3,4}, _ {
+    it( _ { is_expected().to_include(6); });
   });
+});
 
 /* Here is the declaration of fabs description defined in an other file (fabs_spec.c in this sample)*/
 int main(){

include/expectations/expectation.hpp

@@ -103,7 +103,9 @@ class Expectation : public Child {
   bool to_include(E expected, std::string msg = "");
 
   template <typename E>
-  Matchers::BeBetween<A, E> to_be_between(E min, E max, std::string msg = "");
+  bool to_be_between(E min, E max,
+                     Matchers::RangeMode mode = Matchers::RangeMode::inclusive,
+                     std::string msg = "");
 
   template <typename E>
   bool to_equal(E expected, std::string msg = "");
@@ -186,11 +188,11 @@ bool Expectation<A>::to_be_false(std::string msg) {
  */
 template <typename A>
 template <typename E>
-Matchers::BeBetween<A, E> Expectation<A>::to_be_between(E min, E max,
-                                                        std::string msg) {
-  Matchers::BeBetween<A, E> matcher(*this, min, max);
-  matcher.set_message(msg);
-  return matcher;
+bool Expectation<A>::to_be_between(E min, E max, Matchers::RangeMode mode,
+                                   std::string msg) {
+  return Matchers::BeBetween<A, E>(*this, min, max, mode)
+      .set_message(msg)
+      .run();
 }
 
 /**

include/matchers/be_between.hpp

@@ -4,57 +4,39 @@
 #include "basematcher.hpp"
 
 namespace Matchers {
+enum class RangeMode { exclusive, inclusive };
+
 template <typename A, typename E>
 class BeBetween : public BaseMatcher<A, E> {
-  enum class RangeMode { exclusive, inclusive };
   E min;
   E max;
-  RangeMode mode = RangeMode::inclusive;
+  RangeMode mode;
   enum class LtOp { lt, lt_eq } lt_op;
   enum class GtOp { gt, gt_eq } gt_op;
 
  public:
-  BeBetween(Expectations::Expectation<A> &expectation, E min, E max)
-      : BaseMatcher<A, E>(expectation), min(min), max(max) {}
+  //  BeBetween(Expectations::Expectation<A> &expectation, E min, E max)
+  //      : BaseMatcher<A, E>(expectation), min(min), max(max) {}
 
-  bool inclusive();
-  bool exclusive();
+  BeBetween(Expectations::Expectation<A> &expectation, E min, E max,
+            RangeMode mode = RangeMode::inclusive)
+      : BaseMatcher<A, E>(expectation), min(min), max(max), mode(mode) {
+    switch (mode) {
+      case RangeMode::inclusive:
+        lt_op = LtOp::lt_eq;
+        gt_op = GtOp::gt_eq;
+        break;
+      case RangeMode::exclusive:
+        lt_op = LtOp::lt;
+        gt_op = GtOp::gt;
+        break;
+    }
+  }
 
   bool match() override;
   std::string description() override;
 };
 
-/**
- * Makes the between comparison inclusive
- *
- * @example
- *   expect(4).to(be_between(2,3).inclusive())
- *
- * @note The matcher is inclusive by default; this simply
- *       provides a way to be more explicit about it.
- */
-template <typename A, typename E>
-bool BeBetween<A, E>::inclusive() {
-  lt_op = LtOp::lt_eq;
-  gt_op = GtOp::gt_eq;
-  mode = RangeMode::inclusive;
-  return this->run();
-}
-
-/**
- * Makes the between comparison exclusive
- *
- * @example
- *   expect(4).to(be_between(2,3).exclusive())
- */
-template <typename A, typename E>
-bool BeBetween<A, E>::exclusive() {
-  lt_op = LtOp::lt;
-  gt_op = GtOp::gt;
-  mode = RangeMode::exclusive;
-  return this->run();
-}
-
 template <typename A, typename E>
 bool BeBetween<A, E>::match() {
   auto actual = this->get_actual();

spec/CMakeLists.txt

@@ -10,6 +10,9 @@ 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_between_spec matchers/be_between_spec.cpp )
+target_link_libraries( be_between_spec c++spec ${CMAKE_THREAD_LIBS_INIT} )
+add_test ( be_between_spec be_between_spec )
 
 add_executable( be_within_spec matchers/be_within_spec.cpp )
 target_link_libraries( be_within_spec c++spec ${CMAKE_THREAD_LIBS_INIT} )

spec/matchers/be_between_spec.cpp

@@ -0,0 +1,30 @@
+#include "cppspec.hpp"
+
+//describe be_between_spec("BeBetween", $ {
+//  class SizeMatters : public Matchers::BaseMatcher<std::string, std::string> {
+//    SizeMatters(Expectations::Expectation<std::string> &expectation, std::string expected)
+//        : Matchers::BaseMatcher<std::string,std::string>(expectation, expected){};
+//    bool match() { return this->get_actual() == this->get_expected(); }
+//  };
+//
+//  describe("expect(...).to_be_between(min, max) (inclusive)", _ {
+//    it_behaves_like("be_between", &Matchers::BeBetween::inclusive, _ {
+//      Matchers::BeBetween matcher(auto min, auto max) {
+//        return Matchers::BeBetween(self, min, max);
+//      }
+//    });
+//
+//    it("is inclusive", _ {
+//      expect(1).to_be_between(1, 10).run();
+//      expect(10).to_be_between(1, 10).run();
+//    });
+//
+//    it("indicates it was not comparable if it does not respond to <= and >=", _ {
+//      expect([=]{
+//        expect(nullptr).to_be_between(0,10).run();
+//      }).to_fail_with("expected nullptr to be between 0 and 10")
+//    });
+//  });
+//});
+
+int main() { return EXIT_SUCCESS; }