Add custom what() description for exception

Author: Bill-hbrhbr

src/ystdlib/error_handling/TraceableException.hpp

@@ -3,6 +3,7 @@
 
 #include <exception>
 #include <source_location>
+#include <string>
 #include <system_error>
 
 namespace ystdlib::error_handling {
@@ -19,15 +20,21 @@ namespace ystdlib::error_handling {
  */
 class TraceableException : public std::exception, public std::source_location {
 public:
-    // Constructor
-    TraceableException(
+    // Constructors
+    explicit TraceableException(
             std::error_code error_code,
             std::source_location const& location = std::source_location::current()
+    )
+            : TraceableException{error_code, location.function_name(), location} {}
+
+    explicit TraceableException(
+            std::error_code error_code,
+            char const* what,
+            std::source_location const& location = std::source_location::current()
     )
             : std::source_location{location},
-              m_error_code{error_code} {
-        m_what = std::string{function_name()} + " failed.";
-    }
+              m_error_code{error_code},
+              m_what{what} {}
 
     // Methods
     [[nodiscard]] auto error_code() const -> std::error_code { return m_error_code; }

src/ystdlib/error_handling/test-TraceableException.cpp

@@ -1,3 +1,5 @@
+#include <cassert>
+#include <string>
 #include <system_error>
 
 #include <ystdlib/error_handling/TraceableException.hpp>
@@ -7,19 +9,24 @@
 #include "test-Defs.hpp"
 
 namespace {
+constexpr auto cCustomFailureDescription{"This operation has failed."};
+
 class Worker {
 public:
     YSTDLIB_ERROR_HANDLING_DEFINE_TRACEABLE_EXCEPTION(OperationFailed);
 
-    static void execute_with_success() {
+    static auto execute_with_success() -> void {
         throw OperationFailed(BinaryErrorCode{BinaryErrorCodeEnum::Success});
     }
 
-    static void execute_with_failure() {
-        throw OperationFailed(BinaryErrorCode{BinaryErrorCodeEnum::Failure});
+    static auto execute_with_failure() -> void {
+        throw OperationFailed(
+                BinaryErrorCode{BinaryErrorCodeEnum::Failure},
+                cCustomFailureDescription
+        );
     }
 
-    static void execute_with_invalid_args() {
+    static auto execute_with_invalid_args() -> void {
         throw OperationFailed(std::make_error_code(std::errc::invalid_argument));
     }
 };
@@ -34,62 +41,63 @@ constexpr auto cExecuteWithInvalidArgsFunctionName{
         "static void {anonymous}::Worker::execute_with_invalid_args()"
 };
 constexpr auto cInvalidArgsErrorMsg{"Invalid argument"};
-constexpr auto cExecuteWithSuccessLineNumber{15};
-constexpr auto cExecuteWithFailureLineNumber{19};
-constexpr auto cExecuteWithInvalidArgsLineNumber{23};
+constexpr auto cExecuteWithSuccessLineNumber{19};
+constexpr auto cExecuteWithFailureLineNumber{26};
+constexpr auto cExecuteWithInvalidArgsLineNumber{30};
 
 #ifdef SOURCE_PATH_SIZE
 // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
 constexpr auto cRelativePathFileName{static_cast<char const*>(__FILE__) + SOURCE_PATH_SIZE};
 #else
 constexpr auto cRelativePathFileName{__FILE__};
 #endif
-}  // namespace
 
-TEST_CASE("test_traceable_exception_success", "[error_handling][TraceableException]") {
-    ystdlib::error_handling::TraceableException success_exception{std::error_code{}};
+template <typename Callable>
+[[nodiscard]] auto capture_exception(Callable&& f) -> ystdlib::error_handling::TraceableException;
+
+template <typename Callable>
+auto capture_exception(Callable&& f) -> ystdlib::error_handling::TraceableException {
     try {
-        Worker::execute_with_success();
+        std::forward<Callable>(f)();
     } catch (ystdlib::error_handling::TraceableException& e) {
-        success_exception = e;
+        return e;
     }
+    assert(false && "Needs to pass in a workflow that throws.");
+    return ystdlib::error_handling::TraceableException{std::error_code{}};
+}
+}  // namespace
+
+TEST_CASE("test_traceable_exception_success", "[error_handling][TraceableException]") {
+    auto const success_exception{capture_exception(Worker::execute_with_success)};
     std::error_code const success_error_code{BinaryErrorCode{BinaryErrorCodeEnum::Success}};
     REQUIRE((success_error_code.category() == success_exception.error_code().category()));
     REQUIRE((success_error_code.value() == success_exception.error_code().value()));
     REQUIRE((cSuccessErrorMsg == success_exception.error_code().message()));
+    REQUIRE((cExecuteWithSuccessFunctionName == std::string{success_exception.what()}));
     REQUIRE((cExecuteWithSuccessFunctionName == success_exception.function_name()));
     REQUIRE((cExecuteWithSuccessLineNumber == success_exception.line()));
     REQUIRE((cRelativePathFileName == success_exception.file_name()));
 }
 
 TEST_CASE("test_traceable_exception_failure", "[error_handling][TraceableException]") {
-    ystdlib::error_handling::TraceableException failure_exception{std::error_code{}};
-    try {
-        Worker::execute_with_failure();
-    } catch (ystdlib::error_handling::TraceableException& e) {
-        failure_exception = e;
-    }
+    auto const failure_exception{capture_exception(Worker::execute_with_failure)};
     std::error_code const failure_error_code{BinaryErrorCode{BinaryErrorCodeEnum::Failure}};
     REQUIRE((failure_error_code.category() == failure_exception.error_code().category()));
     REQUIRE((failure_error_code.value() == failure_exception.error_code().value()));
     REQUIRE((cFailureErrorMsg == failure_exception.error_code().message()));
+    REQUIRE((cCustomFailureDescription == std::string{failure_exception.what()}));
     REQUIRE((cExecuteWithFailureFunctionName == failure_exception.function_name()));
     REQUIRE((cExecuteWithFailureLineNumber == failure_exception.line()));
     REQUIRE((cRelativePathFileName == failure_exception.file_name()));
 }
 
 TEST_CASE("test_traceable_exception_invalid_args", "[error_handling][TraceableException]") {
-    ystdlib::error_handling::TraceableException invalid_args_exception{std::error_code{}};
-    try {
-        Worker::execute_with_invalid_args();
-    } catch (ystdlib::error_handling::TraceableException& e) {
-        invalid_args_exception = e;
-    }
-    std::error_code const invalid_args_error_code{std::make_error_code(std::errc::invalid_argument)
-    };
+    auto const invalid_args_exception{capture_exception(Worker::execute_with_invalid_args)};
+    auto const invalid_args_error_code{std::make_error_code(std::errc::invalid_argument)};
     REQUIRE((invalid_args_error_code.category() == invalid_args_exception.error_code().category()));
     REQUIRE((invalid_args_error_code.value() == invalid_args_exception.error_code().value()));
     REQUIRE((cInvalidArgsErrorMsg == invalid_args_exception.error_code().message()));
+    REQUIRE((cExecuteWithInvalidArgsFunctionName == std::string{invalid_args_exception.what()}));
     REQUIRE((cExecuteWithInvalidArgsFunctionName == invalid_args_exception.function_name()));
     REQUIRE((cExecuteWithInvalidArgsLineNumber == invalid_args_exception.line()));
     REQUIRE((cRelativePathFileName == invalid_args_exception.file_name()));