Features/lazy-expectation

commit d7e8604f014b0837a09406b12b342374d7b51fbe
Author: Katherine Whitlock <[email protected]>
Date:   Fri Apr 29 01:08:35 2016 -0400

    More matchers and refactoring

commit ec9e7653cac7c29ba4c19ec874c8214f9c709691
Author: Katherine Whitlock <[email protected]>
Date:   Thu Apr 28 22:30:13 2016 -0400

    Refactor names to be consistent

commit 60385f5891f5e1817d45cb625ef07d53c7a89248
Author: Katherine Whitlock <[email protected]>
Date:   Thu Apr 28 22:19:56 2016 -0400

    More matchers and a Jasmine-intro port

commit 5eee0910752177f95aa461c27a1dbcbb28538343
Author: Katherine Whitlock <[email protected]>
Date:   Thu Apr 28 19:12:06 2016 -0400

    Working exception test

commit f12b428b99aa5169e4262da07f5862a16cd27141
Author: Katherine Whitlock <[email protected]>
Date:   Thu Apr 28 18:29:26 2016 -0400

    Initial support for lazy evaluation

Author: toroidal-code

examples/sample/CMakeLists.txt

@@ -3,3 +3,6 @@ add_executable(cppspec_sample
 )
 
 target_link_libraries(cppspec_sample c++spec)
+
+add_executable(jasmine_intro jasmine_intro.cpp)
+target_link_libraries(jasmine_intro c++spec)

examples/sample/example_spec.cpp

@@ -49,34 +49,34 @@ describe bool_spec("Some Tests", $ {
 
 
   explain("{1,2,3}", _ {
-    it("includes 1", _ {
-      expect({1,2,3}).to_include({1});
+    it("contains 1", _ {
+      expect({1,2,3}).to_contain({1});
     });
     it("includes [1,2,3]", _ {
-      expect({1,2,3}).to_include({1,2,8});
-      expect({1,2,3}).to_include({1,2,7});
+      expect({1,2,3}).to_contain({1,2,8});
+      expect({1,2,3}).to_contain({1,2,7});
     });
     it("does not include 4", _ {
-      expect({1,2,3}).not_().to_include({4});
+      expect({1,2,3}).not_().to_contain({4});
     });
 
     it("does not include [4,5,6]", _ {
-      expect({1,2,3}).not_().to_include({4,5,6});
+      expect({1,2,3}).not_().to_contain({4,5,6});
     });
   });
 
 
   explain <std::list<int>> ({1,2,3}, _ {
-    it(_ { is_expected().to_include(1); });
+    it(_ { is_expected().to_contain(1); });
 
     it("includes [1,2,3]", _ {
-      expect<std::list<int>>({1,2,3}).to_include({1,2,3});
+      expect<std::list<int>>({1,2,3}).to_contain({1,2,3});
     });
 
-    it( _ { is_expected().not_().to_include(4); });
+    it( _ { is_expected().not_().to_contain(4); });
 
     it("does not include [4,5,6]", _ {
-      is_expected().not_().to_include({4,5,6});
+      is_expected().not_().to_contain({4,5,6});
     });
   });
 
@@ -140,22 +140,22 @@ describe strcmp_spec("int strcmp ( const char * str1, const char * str2 )", $ {
   });
 
   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);
+    expect(strcmp("hello", "world")).to_satisfy(less_than_zero);
+    expect(strcmp("0123", "1321431")).to_satisfy(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);
+    expect(strcmp("yellow", "world")).to_satisfy(greater_than_zero);
+    expect(strcmp("9", "789")).to_satisfy(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);
+    expect({1,2,3,4}).to_contain(2);
   });
 
-  it( _ { is_expected().to_include(2); });
+  it( _ { is_expected().to_contain(2); });
 });
 
 int _count = 0;
@@ -184,7 +184,8 @@ describe let_spec("let", $ {
 
 describe list_spec("A list spec", $ {
   explain <std::list<int>> ({1,2,3,4}, _ {
-    it( _ { is_expected().to_include(8); });
+    it( _ { is_expected().to_contain(8); });
+    it( _ { is_expected().to_start_with({1,2,3}); });
   });
 });
 

examples/sample/jasmine_intro.cpp

@@ -0,0 +1,269 @@
+// Copyright 2016 Katherine Whitlock
+
+#include "cppspec.hpp"
+
+describe a_suite("A suite", $ {
+  it("contains a spec with an expectation", _ {
+    expect(true).to_be_true();
+  });
+});
+
+describe suite_object("A suite is just an object wrapping a lambda", $ {
+  bool a = false;
+
+  it("and so is a spec", _ {
+    a = true;
+    expect(a).to_be_true();
+  });
+});
+
+describe to_be_compare("The 'to_satisfy' matcher compares equality via evaluation",
+                       $ {
+  it("and has a positive case", _ {
+    expect(true).to_satisfy([](const bool &b) { return b == true; });
+  });
+
+  it("and can have a negative case", _ {
+    expect(false).not_().to_satisfy([](const bool &b) { return b == true; });
+  });
+});
+
+
+describe to_equal_compare("The 'to_equal' matcher compares with '=='", $ {
+  it("and has a positive case", _ {
+    expect(true).to_equal(true);
+  });
+
+  it("and can have a negative case", _ {
+    expect(false).not_().to_equal(true);
+  });
+});
+
+struct AB { int a; int b; };
+inline bool operator==(const AB& lhs, const AB&rhs) {
+  return lhs.a == rhs.a && lhs.b == rhs.b;
+}
+
+
+describe included_matchers("Included matchers:", $ {
+  it("The 'to_be' matcher compares equality via lambda evaluation", _ {
+    int a = 12;
+    int b = a;
+
+    expect(a).to_satisfy([b](const int &value) -> bool { return value == b;});
+    // to_equal is shorter for things that can be compared
+    // with operator==
+    expect(a).to_equal(b);
+  });
+
+  context("The 'to_equal' matcher", _ {
+    it("works for simple literals and variables", _ {
+      auto a = 12;
+      expect(a).to_equal(12);
+    });
+
+    it("should work for objects with operator== defined", _ {
+      AB foo;
+      foo.a = 12;
+      foo.b = 34;
+
+      AB bar;
+      bar.a = 12;
+      bar.b = 34;
+
+      expect(foo).to_equal(bar);
+    });
+  });
+    // Not yet implemented
+//    it("The 'to_match' matcher is for regular expressions", _ {
+//      std::string message = "foo bar baz";
+//
+//      expect(message).to_match(std::regex("bar"));
+//      expect(message).to_match("bar");
+//      expect(message).not_().to_match(std::regex("quux"));
+//    });
+
+  it("The 'to_be_truthy' matcher is for boolean casting testing", _ {
+    void* a = nullptr;
+    //auto foo = "foo";
+
+//    expect(foo).to_be_truthy();
+    expect(a).not_().to_be_truthy();
+  });
+
+  it("The 'to_be_falsy' matcher is for boolean casting testing", _ {
+    void* a = nullptr;
+    //auto foo = "foo";
+
+    expect(a).to_be_falsy();
+//    expect(foo).not_().to_be_falsy();
+  });
+
+  it("The 'to_include' matcher is for finding an item in a container", _ {
+    auto a = {"foo", "bar", "baz"};
+
+    expect(a).to_contain("bar");
+    expect(a).not_().to_contain("quux");
+  });
+
+  it("The 'to_be_less_than' matcher is for mathematical comparisons", _ {
+    auto pi = 3.1415926,
+        e = 2.78;
+
+    expect(e).to_be_less_than(pi);
+    expect(pi).not_().to_be_less_than(e);
+  });
+
+  it("The 'to_be_greater_than' matcher is for mathematical comparisons", _ {
+    auto pi = 3.1415926,
+        e = 2.78;
+
+    expect(pi).to_be_greater_than(e);
+    expect(e).not_().to_be_greater_than(pi);
+  });
+
+// TODO: take another look at Jasmine's toBeCloseTo
+//    it("The 'to_be_within' matcher is for precision match comparison", _ {
+//      auto pi = 3.1415926,
+//          e = 2.78;
+//
+//      expect(pi).not_().to_be_within(0.5).of(e);
+//    });
+
+  it("The 'to_throw' matcher is for testing if a function throws an exception", _ {
+    std::function<int()> foo = [] {
+      return 1 + 2;
+    };
+    std::function<void*()> bar = [] {
+      throw(std::exception());
+      return nullptr;
+    };
+
+    expect(foo).not_().to_throw();
+    expect(bar).to_throw();
+  });
+});
+
+
+//describe fail_function_spec("A spec using the fail function", $ {
+//  auto foo = [](auto &x, auto &callback) {
+//    if (x) {
+//      callback();
+//    }
+//  };
+//
+//  it("should not call the callback", _ {
+//    foo(false, [] -> {
+//      fail("Callback has been called");
+//    });
+//  });
+//});
+
+describe a_spec("A spec", $ {
+  it("is just a function, so it can contain any code", _ {
+    auto foo = 0;
+    foo += 1;
+    expect(foo).to_equal(1);
+  });
+
+  it("can have more than one expectation", _ {
+    auto foo = 0;
+    foo += 1;
+
+    expect(foo).to_equal(1);
+    expect(true).to_equal(true);
+  });
+});
+
+describe a_spec_using_be_ae("A spec using before_each and after_each", $ {
+  auto foo = 0;
+
+  before_all([&foo]{ foo = 1; });
+  after_all([&foo]{ foo = 0; });
+
+  it("sets the initial value of foo before specs run", [&](auto &self) {
+    expect(foo).to_equal(1);
+    foo += 1;
+  });
+
+  it("does not reset foo between specs", _ {
+    expect(foo).to_equal(2);
+  });
+});
+
+describe a_spec_before_each("A spec", $ {
+  int foo;
+  before_each([&foo]{ foo = 0; });
+
+  it("can use a variable to share state", _ {
+    expect(foo).to_equal(0);
+    foo += 1;
+  });
+
+  it("prevents test pollution by starting with a clean test environment", _ {
+    expect(foo).to_equal(0);
+  });
+});
+
+describe a_spec_nesting("A spec", $ {
+  int foo;
+
+  before_each([&foo] {
+    foo = 0;
+    foo += 1;
+  });
+
+  after_each([&foo] {
+    foo = 0;
+  });
+
+  it("is just a function, so it can contain any code", _ {
+    expect(foo).to_equal(1);
+  });
+
+  it("can have more than one expectation", _ {
+    expect(foo).to_equal(1);
+    expect(true).to_equal(true);
+  });
+
+  explain("nested contexts", _ {
+    int bar;
+
+    before_each([&bar] {
+      bar = 1;
+    });
+
+    it("can reference both scopes as needed", _ {
+      expect(foo).to_equal(bar);
+    });
+  });
+});
+
+// xdescribes are unnecessary, as test are simply not run or
+// added to the Runner object.
+
+// TODO: pending specs
+
+describe to_include_matcher("to contain", $ {
+  let(foo, ([]() -> std::vector<int> { return {1,2,3,4}; }));
+
+  it("matches arrays with some of the values", _ {
+    expect(foo).to_contain({3,1});
+    expect(foo).not_().to_contain(6);
+  });
+});
+
+int main() {
+  return CppSpec::Runner(CppSpec::Formatters::verbose)
+             .add_spec(a_suite)
+             .add_spec(suite_object)
+             .add_spec(to_be_compare)
+             .add_spec(to_equal_compare)
+             .add_spec(included_matchers)
+             .add_spec(a_spec)
+             .add_spec(a_spec_using_be_ae)
+             .add_spec(a_spec_before_each)
+             .add_spec(a_spec_nesting)
+             .add_spec(to_include_matcher)
+             .exec() ? EXIT_SUCCESS : EXIT_FAILURE;
+}

include/class_description.hpp

@@ -262,9 +262,9 @@ Result ClassDescription<T>::run(Formatters::BaseFormatter &printer) {
 }
 
 template <class T>
-Expectations::Expectation<T> ItCd<T>::is_expected() {
+Expectations::ExpectationValue <T> ItCd<T>::is_expected() {
   auto cd = static_cast<ClassDescription<T> *>(this->get_parent());
-  Expectations::Expectation<T> expectation(*this, cd->subject);
+  Expectations::ExpectationValue<T> expectation(*this, cd->subject);
   return expectation;
 }