Finished lets

Author: toroidal-code

examples/sample/example_spec.cpp

@@ -5,11 +5,16 @@
 
 
 describe bool_spec("Some Tests", $ {
-    // context("true is", _ {
-    //     it("true", _ {
-    //         expect(true).to_be;
-    //       });
-    //   });
+    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", _ {
@@ -75,6 +80,7 @@ describe bool_spec("Some Tests", $ {
           });
       });
 
+
     // context("std::map {{1,2},{3,4},{5,6}}", _ {
     //     it("includes 1", _ {
     //         std::map<int,int> m = {{1,2},{3,4},{5,6}};
@@ -93,22 +99,6 @@ describe bool_spec("Some Tests", $ {
     //         expect({1,2,3}).not_().to_include({4,5,6});
     //       });
     //   });
-
-    // before("each", _ {
-    //     n = rand();
-    //   });
-
-    // context("argument is positive", _ {
-    //     it("return positive", _ {
-    //         expect_to_equal(fabs(n), n);
-    //       });
-    //   });
-
-    // context("argument is negative", _ {
-    //     it("return positive", _ {
-    //         expect(fabs(-n).to(equal(n));
-    //       });
-    //   });
   });
 
 describe abs_spec("abs", $ {
@@ -141,40 +131,48 @@ describe abs_spec("abs", $ {
 });
 
 
+/* Here is the description of strcmp */
+describe strcmp_spec("int strcmp ( const char * str1, const char * str2 )", $ {
+  auto greater_than_zero = [](int i){return i>=0;};
+  auto less_than_zero = [](int i){return i<0;};
 
+  it("returns 0 only when strings are equal", _ {
+    expect(strcmp("hello", "hello")).to_equal(0);
+  });
 
+  it("returns a negative integer when str1 is less than str2", _ {
+    expect(strcmp("hello", "world")).to_be(less_than_zero);
+    expect(strcmp("0123", "1321431")).to_be(less_than_zero);
+  });
 
+  it("returns a positive integer if str1 is greater than str2", _ {
+    expect(strcmp("yellow", "world")).to_be(greater_than_zero);
+    expect(strcmp("9", "789")).to_be(greater_than_zero);
+  });
+});
 
+describe_a <std::vector<int>> vector_spec({1,2,3,4}, $ {
+  it("should contain 2", _ {
+    expect({1,2,3,4}).to_include(2);
+  });
 
+  it( _ { is_expected().to_include(2); });
+});
 
+int _count = 0;
+describe let_spec("let", $ {
+  let(count, [&]{ return ++_count ;});
+    
+  it("memoizes the value", _ {
+    expect(count).to_equal(1);
+    expect(count).to_equal(1);
+  });
 
-
-
-
-
-/* Here is the description of strcmp */
-// describe strcmp_spec("int strcmp ( const char * str1, const char * str2 )", _ {
-//   it( "returns 0 only when strings are equal", _ {
-//       // should_equal( strcmp("hello", "hello"), 0);
-//       // should_not_be_null( strcmp("hello", "world") );
-//   });
-
-//   it( "returns a negative integer when str1 is less than str2", _ {
-//       // should_be_true( strcmp("hello", "world") < 0 );
-//       // should_be_true( strcmp("0123", "1321431") < 0 );
-//   });
-
-//   it( "returns a positive integer if str1 is greater than str2", _ {
-//       // should_be_true( strcmp("yellow", "world") > 0 );
-//       // should_be_true( strcmp("9", "789") > 0 );
-//   });
-// });
-
-describe_a <std::vector<int>> vector_spec({1,2,3,4}, $ {
-    it("should contain 2", _ {
-        expect({1,2,3,4}).to_include(6);
-      });
+  it("is not cached across examples", _ {
+    expect(count).to_equal(2);
   });
+});
+
 
 // describe_a<std::vector<int>> another_vector_spec({1,2,3,4}, _ {
 //     // it(_ { assert(static_cast<ClassDescription<std::vector<int>>*>(self.get_parent()) != nullptr); });
@@ -185,11 +183,6 @@ describe_a <std::vector<int>> vector_spec({1,2,3,4}, $ {
 //  });
 //   });
 
-describe_a <std::vector<int>> another_vector_spec({1,2,3,4}, $ {
-    it( _ { is_expected().to_include(6); });
-  });
-
-
 describe list_spec("A list spec", $ {
     explain <std::list<int>> ({1,2,3,4}, _ {
         it( _ { is_expected().to_include(6); });
@@ -201,8 +194,9 @@ int main(){
   bool r = true;
   r &= bool_spec.run();
   r &= abs_spec.run();
+  r &= strcmp_spec.run();
   r &= vector_spec.run();
-  r &= another_vector_spec.run();
+  r &= let_spec.run();
 // #undef expect
 // #undef it
 //  Description d("halp", _ {});

include/class_description.hpp

@@ -220,4 +220,23 @@ bool ClassDescription<T>::run() {
   return this->get_status();
 }
 
+template <class T>
+Expectations::Expectation<T> ItCd<T>::is_expected() {
+  auto cd = static_cast<ClassDescription<T>*>(this->get_parent());
+  Expectations::Expectation<T> expectation(cd->get_subject());
+  expectation.set_parent(this);
+  return expectation;
+}
+
+template <class T>
+bool ItCd<T>::run() {
+  if (!this->needs_descr()) {
+    std::cout << padding() << get_descr() << std::endl;
+  }
+  body(*this);
+  auto cd = static_cast<ClassDescription<T>*>(this->get_parent());
+  cd->reset_lets();
+  return this->get_status();
+}
+
 #endif /* CLASS_DESCRIPTION_H */

include/cppspec.hpp

@@ -16,7 +16,7 @@
 #define after_each self.after_each
 #define let(name, body)              \
   auto name = make_let(#name, body); \
-  self.let(#name, name)
+  self.let(#name, name);
 
 typedef Description describe;
 

include/description.hpp

@@ -66,9 +66,10 @@ class Description : public Runnable {
   void exec_before_eaches();
   void exec_after_eaches();
 
-  void let(std::string name, Runnable &body);
-
+  void let(std::string, Runnable &body);
   bool run();
+  void reset_lets();
+  Runnable *find_let(std::string);
 };
 
 typedef Description Context;
@@ -128,7 +129,8 @@ void Description::before_each(rule_block_t b) {
   // Due to how lambdas and their contexts are passed around, we need to prime
   // the environment by executing the before_each, so that when an 'it'
   // declaration's lambda captures that env, it has the correct values for the
-  // variables. Truthfully, 'before_each' is a misnomer, as they are not getting
+  // variables. Truthfully, 'before_each' is a misnomer, as they are not
+  // getting
   // executed directly before the lambda's execution as one might expect, but
   // instead before the *next* lambda is declared.
   b();
@@ -149,8 +151,7 @@ void Description::exec_after_eaches() {
 }
 
 void Description::let(std::string name, Runnable &body) {
-  auto p = lets.insert({name, &body});
-  if (!p.second) p.first->second = &body;  // assign if the key is already there
+  lets.insert({name, &body});
 }
 
 bool Description::run() {
@@ -161,4 +162,53 @@ bool Description::run() {
   return this->get_status();
 }
 
+void Description::reset_lets() {
+  for (auto &pair : lets) {
+    auto base = static_cast<LetBase *>(pair.second);  // downcast.
+    base->reset();
+  }
+
+  if (has_parent()) {
+    auto parent = static_cast<Description *>(get_parent());
+    parent->reset_lets();
+  }
+}
+
+Runnable *Description::find_let(std::string name) {
+  auto got = lets.find(name);
+
+  if (got == lets.end()) {
+    if (this->has_parent()) {
+      auto parent = static_cast<Description *>(get_parent());
+      return parent->find_let(name);
+    } else {  // this should never, *ever* happen.
+      throw(std::out_of_range("Could not find let '" + name + "'"));
+    }
+  } else {
+    return got->second;
+  }
+}
+
+template <class T>
+Expectations::Expectation<T> ItExpBase::expect(Let<T> let) {
+  auto parent = static_cast<Description *>(this->get_parent());
+  Let<T> *actual_let = static_cast<Let<T> *>(parent->find_let(let.get_name()));
+  T res = actual_let->get_result();
+  Expectations::Expectation<T> expectation(res);
+  expectation.set_parent(this);
+  return expectation;
+}
+
+bool ItD::run() {
+  if (!this->needs_descr()) {
+    std::cout << padding() << get_descr() << std::endl;
+  }
+  body(*this);
+
+  auto parent = static_cast<Description *>(this->get_parent());
+  parent->reset_lets();
+
+  return this->get_status();
+}
+
 #endif /* DESCRIPTION_H */

include/expectations/expectation.hpp

@@ -3,6 +3,7 @@
 #include <functional>
 #include <vector>
 #include "runnable.hpp"
+#include "let.hpp"
 #include "matchers/basematcher.hpp"
 #include "matchers/be.hpp"
 #include "matchers/be_between.hpp"
@@ -59,6 +60,8 @@ class Expectation : public Child {
    *
    * @return The constructed Expectation.
    */
+  // TODO: create a "lazy" parameter for differentiating between delayed and
+  // immediate execution
   Expectation(std::function<A(void)> block) : block(block), has_block(true) {}
 
   /**

include/it.hpp

@@ -2,23 +2,26 @@
 #define IT_H
 #include <string>
 #include <functional>
+#include <unordered_map>
+#include "it_base.hpp"
 #include "expectations/expectation.hpp"
 
-class Description;
-
-template <class T>
-class ClassDescription;
-
 class ItExpBase : public ItBase {
  public:
   ItExpBase() : ItBase(){};
   ItExpBase(std::string descr) : ItBase(descr){};
   template <class U>
   Expectations::Expectation<U> expect(U value);
 
+  // template <class U>
+  // Expectations::Expectation<U> expect(U &value);
+
   template <class U>
   Expectations::Expectation<std::vector<U>> expect(
       std::initializer_list<U> init_list);
+
+  template <class U>
+  Expectations::Expectation<U> expect(Let<U> let);
 };
 
 class ItD : public ItExpBase {
@@ -65,6 +68,13 @@ Expectations::Expectation<T> ItExpBase::expect(T value) {
   return expectation;
 }
 
+// template <class T>
+// Expectations::Expectation<T> ItExpBase::expect(T const &value) {
+//   Expectations::Expectation<T> expectation(value);
+//   expectation.set_parent(this);
+//   return expectation;
+// }
+
 /**
  * @brief An expect for initializer_list subjects
  *
@@ -80,29 +90,4 @@ Expectations::Expectation<std::vector<T>> ItExpBase::expect(
   return expectation;
 }
 
-template <class T>
-Expectations::Expectation<T> ItCd<T>::is_expected() {
-  auto cd = static_cast<ClassDescription<T> *>(this->get_parent());
-  Expectations::Expectation<T> expectation(cd->get_subject());
-  expectation.set_parent(this);
-  return expectation;
-}
-
-bool ItD::run() {
-  if (!this->needs_descr()) {
-    std::cout << padding() << get_descr() << std::endl;
-  }
-  body(*this);
-  return this->get_status();
-}
-
-template <class T>
-bool ItCd<T>::run() {
-  if (!this->needs_descr()) {
-    std::cout << padding() << get_descr() << std::endl;
-  }
-  body(*this);
-  return this->get_status();
-}
-
 #endif /* IT_H */