Befores and Afters

Author: toroidal-code

examples/sample/example_spec.cpp

@@ -1,3 +1,5 @@
+#include <cmath>
+#include <cstdlib>
 #include <list>
 #include "cppspec.hpp"
 
@@ -109,6 +111,47 @@ describe bool_spec("Some Tests", $ {
     //   });
   });
 
+describe abs_spec("abs", $ {
+  // you can use the `explain` keyword to
+  // group behavior and nest descriptions
+  explain("argument is zero", _ {
+    it("return zero", _ {
+      expect(abs(0)).to_equal(0);
+    });
+  });
+
+  before_all([]{ std::srand(std::time(0)); });
+  
+  int n = 0;
+  before_each([&]{ n = std::rand(); });
+
+  // you can also use `context` instead of
+  // `explain`, just like in RSpec
+  context("argument is positive", _ {
+    it("return positive", _ {
+      expect(abs(n)).to_equal(n, "abs(" + std::to_string(n) + ") didn't equal " + std::to_string(n));
+    });
+  });
+
+  explain("argument is negative", _ {
+    it("return positive", _ {
+      expect(abs(-n)).to_equal(n);
+    });
+  });
+});
+
+
+
+
+
+
+
+
+
+
+
+
+
 /* 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", _ {
@@ -157,6 +200,7 @@ describe list_spec("A list spec", $ {
 int main(){
   bool r = true;
   r &= bool_spec.run();
+  r &= abs_spec.run();
   r &= vector_spec.run();
   r &= another_vector_spec.run();
 // #undef expect

include/class_description.hpp

@@ -86,6 +86,8 @@ bool ClassDescription<T>::context(T subject,
                                   std::function<void(ClassDescription&)> body) {
   ClassContext<T> context(subject, body);
   context.set_parent(this);
+  context.before_eaches = this->before_eaches;
+  context.after_eaches = this->after_eaches;
   return context.run();
 }
 
@@ -99,6 +101,8 @@ template <class T>
 bool ClassDescription<T>::context(std::function<void(ClassDescription&)> body) {
   ClassContext<T> context(body);
   context.set_parent(this);
+  context.before_eaches = this->before_eaches;
+  context.after_eaches = this->after_eaches;
   return context.run();
 }
 
@@ -108,6 +112,8 @@ bool Description::context(T subject,
   ClassContext<T> context(body);
   context.set_subject(subject);
   context.set_parent(this);
+  context.before_eaches = this->before_eaches;
+  context.after_eaches = this->after_eaches;
   return context.run();
 }
 
@@ -122,6 +128,8 @@ bool Description::context(std::initializer_list<U> init_list,
                           std::function<void(ClassDescription<T>&)> body) {
   ClassContext<T> context(T(init_list), body);
   context.set_parent(this);
+  context.before_eaches = this->before_eaches;
+  context.after_eaches = this->after_eaches;
   return context.run();
 }
 
@@ -151,7 +159,10 @@ bool ClassDescription<T>::it(std::string name,
                              std::function<void(ItCd<T>&)> body) {
   ItCd<T> it(name, body);
   it.set_parent(this);
-  return it.run();
+  bool result = it.run();
+  exec_after_eaches();
+  exec_before_eaches();
+  return result;
 }
 
 /**
@@ -179,7 +190,10 @@ template <class T>
 bool ClassDescription<T>::it(std::function<void(ItCd<T>&)> body) {
   ItCd<T> it(body);
   it.set_parent(this);
-  return it.run();
+  bool result = it.run();
+  exec_after_eaches();
+  exec_before_eaches();
+  return result;
 }
 
 template <class T>

include/cppspec.hpp

@@ -10,6 +10,10 @@
 #define explain context
 #define expect self.template expect
 #define is_expected self.is_expected
+#define before_all self.before_all
+#define before_each self.before_each
+#define after_all self.after_all
+#define after_each self.after_each
 
 typedef Description describe;
 

include/description.hpp

@@ -2,11 +2,12 @@
 #define DESCRIPTION_H
 
 #include <string>
-#include <vector>
+#include <queue>
 #include <map>
 #include <functional>
 #include <iostream>
 #include <memory>
+#include "util.hpp"
 #include "runnable.hpp"
 #include "it.hpp"
 
@@ -15,14 +16,14 @@ class ClassDescription;
 
 class Description : public Runnable {
   typedef std::function<void(Description &)> block_t;
+  typedef std::function<void()> rule_block_t;
   block_t body;
 
  protected:
   std::string descr = "";
-  // std::vector<block_t> before_all;
-  // std::vector<block_t> after_all;
-  // std::vector<block_t> before_each;
-  // std::vector<block_t> after_each;
+  std::deque<rule_block_t> after_alls;
+  std::deque<rule_block_t> before_eaches;
+  std::deque<rule_block_t> after_eaches;
 
   explicit Description(std::string descr) : descr(descr){};
 
@@ -47,8 +48,6 @@ class Description : public Runnable {
   bool context(std::initializer_list<U> init_list,
                std::function<void(ClassDescription<T> &)> body);
 
-  void before(std::string descr, block_t body);
-
   template <class T>
   ClassDescription<T> subject(T subject);
 
@@ -58,6 +57,13 @@ class Description : public Runnable {
   template <class T>
   ClassDescription<std::vector<T>> subject(std::initializer_list<T> init_list);
 
+  void before_each(rule_block_t block);
+  void before_all(rule_block_t block);
+  void after_each(rule_block_t block);
+  void after_all(rule_block_t block);
+  void exec_before_eaches();
+  void exec_after_eaches();
+
   bool run();
 };
 
@@ -67,19 +73,27 @@ bool Description::context(std::string name,
                           std::function<void(Description &)> body) {
   Context context(name, body);
   context.set_parent(this);
+  context.before_eaches = this->before_eaches;
+  context.after_eaches = this->after_eaches;
   return context.run();
 }
 
 bool Description::it(std::string name, std::function<void(ItD &)> body) {
   ItD it(name, body);
   it.set_parent(this);
-  return it.run();
+  bool result = it.run();
+  exec_after_eaches();
+  exec_before_eaches();
+  return result;
 }
 
 bool Description::it(std::function<void(ItD &)> body) {
   ItD it(body);
   it.set_parent(this);
-  return it.run();
+  bool result = it.run();
+  exec_after_eaches();
+  exec_before_eaches();
+  return result;
 }
 
 template <class U>
@@ -104,9 +118,36 @@ ClassDescription<std::vector<U>> Description::subject(
   return cd;
 }
 
+void Description::before_each(rule_block_t b) {
+  before_eaches.push_back(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
+  // executed directly before the lambda's execution as one might expect, but
+  // instead before the *next* lambda is declared.
+  b();
+}
+
+void Description::before_all(rule_block_t b) { b(); }
+
+void Description::after_each(rule_block_t b) { after_eaches.push_back(b); }
+
+void Description::after_all(rule_block_t b) { after_alls.push_back(b); }
+
+void Description::exec_before_eaches() {
+  for (rule_block_t b : before_eaches) b();
+}
+
+void Description::exec_after_eaches() {
+  for (rule_block_t b : after_eaches) b();
+}
+
 bool Description::run() {
   std::cout << padding() << descr << std::endl;
   body(*this);
+  for (auto a : after_alls) a();
   std::cout << std::endl;
   return this->get_status();
 }