additional unique_resource tests

Author: JeffGarland

tests/unique_resource.test.cpp

@@ -1,31 +1,170 @@
 #include <memory>
 #include <cstdio>
+#include <stdexcept>
 #include <beman/scope/scope.hpp>
 
-constexpr bool open_file_good  = false;
-constexpr bool close_file_good = false;
+// clang-format off
 
-// define only in one cpp file
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch_all.hpp>
 
-TEST_CASE("Construct file unique_resource") {
-
-  {
-    auto file = beman::scope::unique_resource(
-        fopen("example.txt", "w"), // Acquire the FILE*
-        [](FILE* f) {
-            if (f) {
-                fclose(f); // Release (cleanup) the resource
-                close_file_good = true;
-            }
-        }
+using namespace beman::scope;
+TEST_CASE("Construct file unique_resource", "[unique_resource]") {
+    bool open_file_good  = false;
+    bool close_file_good = false;
+
+   {
+       auto file = beman::scope::unique_resource(
+           fopen("example.txt", "w"), // Acquire the FILE*
+           [](FILE* f) { if (f) {
+                            fclose(f); // Release (cleanup) the resource
+                            close_file_good = true;
+                         }
+           } );
+
+       if (!file.get()) {
+           throw std::runtime_error("file didn't open");
+       }
+   }
+   REQUIRE(open_file_good == true);
+   REQUIRE(close_file_good == true);
+}
+
+struct DummyResource {
+    bool* cleanedUp;
+
+    DummyResource(bool* flag) : cleanedUp(flag) {
+        *cleanedUp = false;
+    }
+
+    void do_something() {}
+};
+
+TEST_CASE("unique_resource calls cleanup on destruction", "[unique_resource]") {
+    bool cleaned = false;
+
+    {
+        auto res = unique_resource(
+            DummyResource(&cleaned),
+            [](DummyResource r) { *(r.cleanedUp) = true; }
+        );
+
+        res.get().do_something();
+    }
+
+    REQUIRE(cleaned == true);
+}
+
+TEST_CASE("unique_resource does not clean up after release", "[unique_resource]") {
+    bool cleaned = false;
+
+    {
+        auto res = unique_resource(
+            DummyResource(&cleaned),
+            [](DummyResource r) { *(r.cleanedUp) = true; }
+        );
+
+        [[maybe_unused]] auto raw = res.release();
+    }
+
+    REQUIRE(cleaned == false);
+}
+
+TEST_CASE("unique_resource moves properly", "[unique_resource]") {
+    bool cleaned = false;
+
+    unique_resource<DummyResource, void(*)(DummyResource)> res1(
+        DummyResource(&cleaned),
+        [](DummyResource r) { *(r.cleanedUp) = true; }
+    );
+
+    {
+        auto res2 = std::move(res1);
+        res2.get().do_something();
+    }
+
+    REQUIRE(cleaned == true);
+}
+
+TEST_CASE("unique_resource reset cleans up old resource", "[unique_resource]") {
+    bool cleaned1 = false;
+    bool cleaned2 = false;
+
+    DummyResource res1(&cleaned1);
+    DummyResource res2(&cleaned2);
+
+    auto ur = unique_resource(
+        res1,
+        [](DummyResource r) { *(r.cleanedUp) = true; }
+    );
+
+    ur.reset(res2); // should clean up res1 and now manage res2
+
+    REQUIRE(cleaned1 == true);
+    REQUIRE(cleaned2 == false);
+}
+
+// Simulates throwing in the middle of a function using unique_resource
+void simulate_exception(bool* cleanup_flag) {
+    auto res = unique_resource(
+        DummyResource(cleanup_flag),
+        [](DummyResource r) { *(r.cleanedUp) = true; }
     );
 
-    if (!file.get()) {
-        return 1;
+    throw std::runtime_error("Something went wrong");
+}
+
+TEST_CASE("unique_resource cleans up on exception", "[unique_resource][exception]") {
+    bool cleaned = false;
+
+    try {
+        simulate_exception(&cleaned);
+    } catch (const std::exception& e) {
+        // Expected
     }
-  }
-  REQUIRE(open_file_good == true);
-  REQUIRE(close_file_good == true);
+
+    REQUIRE(cleaned == true);
+}
+
+TEST_CASE("unique_resource does not clean up if released before exception", "[unique_resource][exception]") {
+    bool cleaned = false;
+
+    try {
+        auto res = unique_resource(
+            DummyResource(&cleaned),
+            [](DummyResource r) { *(r.cleanedUp) = true; }
+        );
+
+        [[maybe_unused]] auto raw = res.release(); // disables cleanup
+
+        throw std::runtime_error("Throwing after release");
+
+    } catch (...) {
+        // expected
+    }
+
+    REQUIRE(cleaned == false);
+}
+
+TEST_CASE("unique_resource handles exception during reset", "[unique_resource][exception]") {
+    bool cleaned1 = false;
+    bool cleaned2 = false;
+
+    DummyResource res1(&cleaned1);
+    DummyResource res2(&cleaned2);
+
+    auto ur = unique_resource(
+        res1,
+        [](DummyResource r) { *(r.cleanedUp) = true; }
+    );
+
+    try {
+        ur.reset(res2);
+        throw std::runtime_error("Exception after reset");
+    } catch (...) {
+        // expected
+    }
+
+    REQUIRE(cleaned1 == true);
+    REQUIRE(cleaned2 == false);
 }