Started implementing execute/describe/it and expect.

examples/example.cpp

@@ -5,6 +5,8 @@
 #include <vector>
 #include <tuple>
 #include <stdexcept>
+#include <iostream>
+#include <sstream>
 
 using namespace JTest;
 using namespace MyNS;
@@ -23,10 +25,6 @@ testresults_t test_ClassToTest_main(const vector<string>& argv) {
                 {
                     it("should do the thing", [](){
                         // Throw exception if somethings goes wrong
-
-
-                        // TODO: This unnecessary, by throwing exceptions.
-                        return (test_t){};
                     }),
 
                     it("should do the other thing", [](){
@@ -95,6 +93,120 @@ testresults_t test_ClassToTest_2(const vector<string>& argv) {
     );
 }
 
+template<typename T>
+class Expectable {
+    public:
+        Expectable(const T& actual);
+        virtual ~Expectable();
+        virtual void toEqual(const T& value);
+        virtual void toNotEqual(const T& value);
+        // Maybe these funcs should return tuple<bool, string> instead.
+        virtual void toBe(std::function<std::tuple<bool, std::optional<std::string>>(const T& actual)> evaluator);
+        //virtual void toBeNull();
+        //virtual void toNotBeNull();
+        //virtual void toThrow(...);
+    private:
+        const T& actual_;
+};
+
+template<typename T>
+Expectable<T>::Expectable(const T& actual)
+: actual_(actual) {}
+
+template<typename T>
+Expectable<T>::~Expectable() {}
+
+class FailedExpectation: std::runtime_error {
+    public:
+        FailedExpectation(const std::string& message);
+        virtual ~FailedExpectation();
+};
+
+FailedExpectation::FailedExpectation(const std::string& message)
+: runtime_error(message) {
+}
+
+FailedExpectation::~FailedExpectation() {}
+
+template<typename T>
+void Expectable<T>::toEqual(const T& value) {
+    if (actual_ != value) {
+        std::ostringstream os;
+        os << "Expected: " << actual_ << " to be " << value;
+        throw(FailedExpectation(os.str()));
+    }
+}
+
+template<typename T>
+void Expectable<T>::toNotEqual(const T& value) {
+    if (actual_ == value) {
+        std::ostringstream os;
+        os << "Expected: " << actual_ << " to not be " << value;
+        throw(FailedExpectation(os.str()));
+    }
+}
+
+template<typename T>
+void Expectable<T>::toBe(std::function<std::tuple<bool, std::optional<std::string>>(const T& actual)> evaluator) {
+    auto result = evaluator(actual_);
+    if (!std::get<0>(result)) {
+        std::ostringstream os;
+        // std::optional<std::string> message = std::get<1>;
+        std::optional<std::string> message = std::get<1>(result);
+        if (message.has_value()) {
+            os << "Expected: " << actual_ << " to pass validation, but " << message.value();
+        } else {
+            os << "Expected: " << actual_ << " to pass validation.";
+        }
+        throw(FailedExpectation(os.str()));
+    }
+}
+
+// template<typename T>
+// void Expectable<T>::toBeNull() {
+//     if (actual_ != nullptr) {
+//         std::ostringstream os;
+//         os << "Expected null, but got " << actual_;
+//         throw(FailedExpectation(os.str()));
+//     }
+// }
+
+// template<typename T>
+// void Expectable<T>::toNotBeNull() {
+//     if (actual_ == nullptr) {
+//         throw(FailedExpectation("Expected non-null, but got null"));
+//     }
+// }
+
+// template<typename T>
+// void Expectable<T>::toThrow(...) {}
+
+template<typename T>
+Expectable<T> expect(const T& actual);
+
+template<typename T>
+Expectable<T> expect(const T& actual) {
+    return Expectable<T>(actual);
+}
+        
+int MyAddFunction(int a, int b) {
+    return 0;
+}
+
+testresults_t test_BasicExpectable_main(const vector<string>& argv) {
+    return execute(
+        describe("MyAddFunction", [](){
+            return make_testbundle({
+                it("should add 2 and 2 to get 4", [](){
+                    expect(MyAddFunction(2, 2)).toEqual(4);
+                }),
+                it("should ", [](){
+                    // Throw exception if somethings goes wrong
+                }),
+            }, make_describeoptions());
+        }));
+}
+
 // Dummy test harness
 int main(int argc, char* argv[]) {
     try {
@@ -102,6 +214,7 @@ int main(int argc, char* argv[]) {
         testresults_t results;
 
         results = add(results, test_ClassToTest_main(args));
+        results = add(results, test_BasicExpectable_main(args));
 
         print_test_results(results, cout);
     }