move tests to catch

Author: aminroosta

CMakeLists.txt

@@ -22,10 +22,22 @@ set(CATCH_INCLUDE_DIR           ${CMAKE_BINARY_DIR}/catch-src/single_include/)
 set(TEST_SOURCE_DIR             ${CMAKE_SOURCE_DIR}/tests)
 #file(GLOB TEST_SOURCES          ${TEST_SOURCE_DIR}/*.cc)
 set(TEST_SOURCES 
-    ${TEST_SOURCE_DIR}/readme_example.cc
     ${TEST_SOURCE_DIR}/blob_example.cc
     ${TEST_SOURCE_DIR}/error_log.cc
-    ${TEST_SOURCE_DIR}/error_log2.cc
+    ${TEST_SOURCE_DIR}/exceptions.cc
+    ${TEST_SOURCE_DIR}/prepared_statment.cc
+    ${TEST_SOURCE_DIR}/lvalue_functor.cc
+    ${TEST_SOURCE_DIR}/functors.cc
+    ${TEST_SOURCE_DIR}/std_optional.cc
+    ${TEST_SOURCE_DIR}/flags.cc
+    ${TEST_SOURCE_DIR}/mov_ctor.cc
+    ${TEST_SOURCE_DIR}/shared_connection.cc
+    ${TEST_SOURCE_DIR}/trycatchblocks.cc
+    ${TEST_SOURCE_DIR}/readme_example.cc
+    ${TEST_SOURCE_DIR}/functions.cc
+    ${TEST_SOURCE_DIR}/nullptr_uniqueptr.cc
+    ${TEST_SOURCE_DIR}/simple_examples.cc
+    ${TEST_SOURCE_DIR}/variant.cc
     ${TEST_SOURCE_DIR}/exception_dont_execute.cc
     ${TEST_SOURCE_DIR}/exception_dont_execute_nested.cc
 )

tests/error_log.cc

@@ -3,31 +3,61 @@
 #include <string>
 #include <memory>
 #include <stdexcept>
-#include <catch.hpp>
 #include <sqlite_modern_cpp.h>
 #include <sqlite_modern_cpp/log.h>
+#include <catch.hpp>
 using namespace sqlite;
 using namespace std;
 
-TEST_CASE("error_log works with multiple handlers", "[log]") {
-  bool error_detected = false;
-  error_log(
-  	[&](errors::constraint) {
-    	cerr << "Wrong error detected!" << endl;
-  	},
-  	[&](errors::constraint_primarykey e) {
-    	cerr << e.get_code() << '/' << e.get_extended_code() << ": " << e.what() << endl;
-    	error_detected = true;
-  	}
-  );
+struct TrackErrors {
+    TrackErrors() 
+        : constraint_called{false}, primarykey_called{false}
+    {
+          error_log(
+            [this](errors::constraint) {
+                constraint_called = true;
+            },
+            [this](errors::constraint_primarykey e) {
+                primarykey_called = true;
+            }
+            // We are not registering the unique key constraint:
+            // For a unique key error the first handler (errors::constraint) will be called instead.
+          );
+    }
+
+    bool constraint_called;
+    bool primarykey_called;
+    /* bool unique_called; */
+};
+
+// Run before main, before any other sqlite function.
+static TrackErrors track;
+
+
+TEST_CASE("error_log works", "[log]") {
   database db(":memory:");
-  db << "CREATE TABLE person (id integer primary key not null, name TEXT);";
+  db << "CREATE TABLE person (id integer primary key not null, name TEXT unique);";
+
+  SECTION("An extended error code gets called when registered") {
+      try {
+        db << "INSERT INTO person (id,name) VALUES (?,?)" << 1 << "jack";
+        // triger primarykey constraint of 'id'
+        db << "INSERT INTO person (id,name) VALUES (?,?)" << 1 << "bob";
+      } catch (errors::constraint& e) { }
+      REQUIRE(track.primarykey_called == true);
+      REQUIRE(track.constraint_called == false);
+      track.primarykey_called = false;
+  }
 
-  try {
-    db << "INSERT INTO person (id,name) VALUES (?,?)" << 1 << "jack";
-    // inserting again to produce error
-    db << "INSERT INTO person (id,name) VALUES (?,?)" << 1 << "jack";
-  } catch (errors::constraint& e) { }
+  SECTION("Parent gets called when the exact error code is not registered") {
+      try {
+        db << "INSERT INTO person (id,name) VALUES (?,?)" << 1 << "jack";
+        // trigger unique constraint of 'name'
+        db << "INSERT INTO person (id,name) VALUES (?,?)" << 2 << "jack";
+      } catch (errors::constraint& e) { }
 
-  REQUIRE(error_detected);
+      REQUIRE(track.primarykey_called == false);
+      REQUIRE(track.constraint_called == true);
+      track.constraint_called = false;
+  }
 }

tests/error_log2.cc

@@ -4,36 +4,48 @@
 #include <memory>
 #include <stdexcept>
 #include <sqlite_modern_cpp.h>
+#include <catch.hpp>
 using namespace sqlite;
 using namespace std;
 
 
-int main() {
-  database db(":memory:");
-  db << "CREATE TABLE person (id integer primary key not null, name TEXT);";
-  bool expception_thrown = false;
+TEST_CASE("exceptions are thrown", "[exceptions]") {
+    database db(":memory:");
+    db << "CREATE TABLE person (id integer primary key not null, name TEXT);";
+    bool expception_thrown = false;
+    std::string get_sql_result;
 
-  try {
-    db << "INSERT INTO person (id,name) VALUES (?,?)" << 1 << "jack";
-    // inserting again to produce error
-    db << "INSERT INTO person (id,name) VALUES (?,?)" << 1 << "jack";
-  } catch (errors::constraint& e) {
-    cerr << e.get_code() << ": " << e.what() << " during "
-         << quoted(e.get_sql()) << endl;
-    expception_thrown = true;
 #if SQLITE_VERSION_NUMBER >= 3014000
-    if(e.get_sql() != "INSERT INTO person (id,name) VALUES (1,'jack')") {
+    std::string expedted_sql =  "INSERT INTO person (id,name) VALUES (1,'jack')";
 #else
-    if(e.get_sql() != "INSERT INTO person (id,name) VALUES (?,?)") {
+    std::string expedted_sql =  "INSERT INTO person (id,name) VALUES (?,?)";
 #endif
-      cerr << "Wrong statement failed\n";
-      exit(EXIT_FAILURE);
+
+    SECTION("Parent exception works") {
+        try {
+            db << "INSERT INTO person (id,name) VALUES (?,?)" << 1 << "jack";
+            // inserting again to produce error
+            db << "INSERT INTO person (id,name) VALUES (?,?)" << 1 << "jack";
+        } catch (errors::constraint& e) {
+            expception_thrown = true;
+            get_sql_result = e.get_sql();
+        }
+
+        REQUIRE(expception_thrown == true);
+        REQUIRE(get_sql_result == expedted_sql);
     }
-  }
 
-  if(!expception_thrown) {
-    exit(EXIT_FAILURE);
-  }
-  
-  exit(EXIT_SUCCESS);
+    SECTION("Extended exception works") {
+        try {
+            db << "INSERT INTO person (id,name) VALUES (?,?)" << 1 << "jack";
+            // inserting again to produce error
+            db << "INSERT INTO person (id,name) VALUES (?,?)" << 1 << "jack";
+        } catch (errors::constraint_primarykey& e) {
+            expception_thrown = true;
+            get_sql_result = e.get_sql();
+        }
+
+        REQUIRE(expception_thrown == true);
+        REQUIRE(get_sql_result == expedted_sql);
+    }
 }