Implement check_throws() and check_nothrows()

include/jtest/jtest.hpp

@@ -14,73 +14,90 @@
 #include <string>
 #include <functional>
 
-namespace jtest
-{
-    class check_fail {};
-    class check_eq_fail : public check_fail {};
-    class check_ne_fail : public check_fail {};
+namespace jtest {
+    class check_fail {
+    };
+
+    class check_eq_fail : public check_fail {
+    };
+
+    class check_ne_fail : public check_fail {
+    };
 
     /// Raises an exception if the given condition is false.
-    void check(bool condition)
-    {
+    void check(bool condition) {
         if (!condition)
             throw check_fail();
     }
 
     /// Raises an exception if the given types do not evaluate as equal.
-    template <typename T>
-    void check_eq(T a, T b)
-    {
+    template<typename T>
+    void check_eq(T a, T b) {
         if (a != b)
             throw check_eq_fail();
     }
 
     /// Raises an exception if the given types do evaluate as equal.
-    template <typename T>
-    void check_ne(T a, T b)
-    {
+    template<typename T>
+    void check_ne(T a, T b) {
         if (a == b)
             throw check_ne_fail();
     }
 
     /// Raises an exception of the given float values are not equal (up to the given epsilon).
-    void check_float_eq(float a, float b, float epsilon = 1e-3f)
-    {
-        if ( ! (std::abs(a - b) <= epsilon))
+    void check_float_eq(float a, float b, float epsilon = 1e-3f) {
+        if (!(std::abs(a - b) <= epsilon))
             throw check_eq_fail();
     }
 
-    void check_float_ne(float a, float b, float epsilon = 1e-3f)
-    {
-        if ( (std::abs(a - b) <= epsilon))
+    void check_float_ne(float a, float b, float epsilon = 1e-3f) {
+        if ((std::abs(a - b) <= epsilon))
             throw check_ne_fail();
     }
 
-    void check_float_eq_exact(float a, float b)
-    {
+    void check_float_eq_exact(float a, float b) {
         if (a != b)
             throw check_eq_fail();
     }
 
 
-    void check_string_eq(std::string a, std::string b)
-    {
+    void check_string_eq(std::string a, std::string b) {
         if (a != b)
             throw check_eq_fail();
     }
 
-    void check_string_ne(std::string a, std::string b)
-    {
+    void check_string_ne(std::string a, std::string b) {
         if (a == b)
             throw check_ne_fail();
     }
-    void check_throws(std::function<void()> callback);
-    void check_nothrows(std::function<void()> callback);
+
+    void check_throws(std::function<void()> callback)
+    {
+        try {
+            callback();
+            throw check_fail();
+        } catch(...)
+        {
+            // Do nothing, the callback threw as expected...
+        }
+    }
+    void check_nothrows(std::function<void()> callback)
+    {
+        try {
+            callback();
+        } catch(...)
+        {
+            throw check_fail();
+        }
+    }
 
     // TODO: Implement death check:
     // Spawn a new process, and execute the callback in that process.
     // This verifies that a piece of code would cause the process to terminate.
-    void check_death(std::function<void()> callback);
+    void check_death(std::function<void()> callback)
+    {
+        check_throws(callback);
+    }
 
 
     /// Raises an exception, which causes the test to fail.