feat(dlutils): Replace boolean returns with exceptions for error

- Changed DlLibBase::SelfDlOpen() and SelfDlSym() to throw
- std::runtime_error instead of returning boolean Removed unused
- MakeString vector overload and related tests Updated test
- expectations to catch exceptions instead of checking boolean
- returns Removed function cache tracking mechanism and related
- methods Improved error messages with file, line, and detailed
- context information Fixed minor formatting issues and removed
- unnecessary includes

Author: Jamie-Cui

include/dlutils/dlutils.hpp

@@ -27,7 +27,6 @@
 
 #include <functional>
 #include <sstream>
-#include <vector>
 
 /// @brief A header-only C++ library for dynamic loading utilities
 ///
@@ -85,24 +84,6 @@ template <typename... Args> std::string MakeString(const Args &...args) {
   return std::string(ss.str());
 }
 
-/// @brief Creates a string from vector elements with optional delimiter
-/// @tparam T The type of elements in the vector
-/// @param v The vector of elements to convert to string
-/// @param delim The delimiter to use between elements (default: space)
-/// @return A string containing all vector elements separated by the delimiter
-template <typename T>
-std::string MakeString(const std::vector<T> &v,
-                       const std::string &delim = " ") {
-  std::stringstream ss;
-  for (auto it = v.begin(); it < v.end(); it++) {
-    if (it != v.begin()) {
-      MakeStringInternal(ss, delim);
-    }
-    MakeStringInternal(ss, *it);
-  }
-  return std::string(ss.str());
-}
-
 // Specializations for already-a-string types.
 /// @brief Specialization for std::string objects
 /// @param str The string to return
@@ -189,7 +170,7 @@ class DlLibBase {
 
   /// @brief Destructor (default)
   ~DlLibBase() {
-    if(libptr_ != nullptr) {
+    if (libptr_ != nullptr) {
       dlclose(libptr_);
     }
   }
@@ -201,10 +182,15 @@ class DlLibBase {
   /// filename contains a slash ("/"), then it is interpreted as a (relative or
   /// absolute) pathname. Otherwise, the dynamic linker searches for the object.
   ///
-  /// @return true if the library was successfully loaded, false otherwise
-  bool SelfDlOpen() {
+  /// @throws std::runtime_error if the library fails to load
+  void SelfDlOpen() {
     libptr_ = dlopen(libName_.data(), RTLD_NOW | RTLD_GLOBAL);
-    return libptr_ != nullptr;
+    if (libptr_ == nullptr) {
+      throw std::runtime_error(
+          internal::MakeString("[", __FILE__, ":", __LINE__,
+                               "] Fatal Error: failed to load library '",
+                               libName_, "'. dlopen error: ", dlerror()));
+    }
   }
 
   /// @brief Load a symbol from the dynamic library
@@ -221,47 +207,42 @@ class DlLibBase {
   /// @tparam Args The parameter types of the function
   /// @param funName The name of the function to load
   /// @param outFun The DlFun object to populate with the function
-  /// @return true if the symbol lookup was attempted (even if it failed), false
-  /// if preconditions were not met
+  /// @throws std::runtime_error if the library is not loaded or symbol lookup
+  /// fails
   template <class R, class... Args>
-  bool SelfDlSym(std::string_view funName, DlFun<R, Args...> &outFun) {
-    if (libptr_ == nullptr || funName.empty()) {
-      return false;
+  void SelfDlSym(std::string_view funName, DlFun<R, Args...> &outFun) {
+    if (libptr_ == nullptr) {
+      throw std::runtime_error(internal::MakeString(
+          "[", __FILE__, ":", __LINE__, "] Fatal Error: cannot load symbol '",
+          funName, "' because library '", libName_, "' is not loaded."));
+    }
+
+    if (funName.empty()) {
+      throw std::runtime_error(
+          internal::MakeString("[", __FILE__, ":", __LINE__,
+                               "] Fatal Error: function name is empty."));
     }
 
+    // Clear dlerror before calling dlsym
+    dlerror();
     void *funPtr = dlsym(libptr_, funName.data());
-    funCache_.push_back(
-        funPtr); // Store all function pointers, including failed ones
-    outFun =
-        DlFun<R, Args...>(funName, reinterpret_cast<R (*)(Args...)>(funPtr));
-    return true;
-  }
+    char *error = dlerror();
 
-  /// @brief Check if all functions in the cache were successfully loaded
-  /// @return true if all functions were successfully loaded, false otherwise
-  bool CheckFunCache() const {
-    for (const auto *p : funCache_) {
-      if (p == nullptr) {
-        return false;
-      }
+    if (error != nullptr || funPtr == nullptr) {
+      throw std::runtime_error(internal::MakeString(
+          "[", __FILE__, ":", __LINE__,
+          "] Fatal Error: failed to load symbol '", funName, "' from library '",
+          libName_, "'. dlsym error: ", error));
     }
-    return true;
-  }
 
-  /// @brief Get the number of functions in the cache
-  /// @return The number of functions in the cache
-  size_t GetFunCacheSize() const { return funCache_.size(); }
+    outFun =
+        DlFun<R, Args...>(funName, reinterpret_cast<R (*)(Args...)>(funPtr));
+  }
 
 private:
   void *libptr_ = nullptr; ///< Handle to the loaded library (default: nullptr)
   const std::string libName_ =
       "unknown"; ///< The name of the library to load (default: "unknown")
-
-  /// @brief Cache of function pointers obtained through dlsym
-  ///
-  /// WARNING: DO NOT manually manipulate these pointers.
-  /// The cache does NOT own these pointers; they should be read-only.
-  std::vector<void *> funCache_;
 };
 
 /// @brief Macro to simplify loading symbols from dynamic libraries

test/dllibase_extended_test.cpp

@@ -32,103 +32,55 @@ class ExtendedMockDlLib : public DlLibBase {
 public:
   explicit ExtendedMockDlLib(std::string_view lib) : DlLibBase(lib) {}
 
-  bool OpenLib() { return SelfDlOpen(); }
+  void OpenLib() { SelfDlOpen(); }
 
   template <class R, class... Args>
-  bool LoadSymbol(std::string_view funName, DlFun<R, Args...> &outFun) {
-    return SelfDlSym(funName, outFun);
+  void LoadSymbol(std::string_view funName, DlFun<R, Args...> &outFun) {
+    SelfDlSym(funName, outFun);
   }
-
-  bool CheckCache() { return CheckFunCache(); }
-
-  size_t CacheSize() { return GetFunCacheSize(); }
 };
 
 // Tests for DlLibBase class with invalid library
 TEST(DlLibBaseExtendedTest, OpenInvalidLibrary) {
   ExtendedMockDlLib lib("libnonexistent.so");
-  EXPECT_FALSE(lib.OpenLib());
+  EXPECT_THROW(lib.OpenLib(), std::runtime_error);
 }
 
 // Tests for DlLibBase class with invalid function name
 TEST(DlLibBaseExtendedTest, LoadInvalidFunction) {
   ExtendedMockDlLib lib("libnonexistent.so");
   DlFun<int, int, int> func;
-  // This should return false because the library wasn't opened
-  EXPECT_FALSE(lib.LoadSymbol("nonexistent_function", func));
-  // The function name should still be "unknown" because LoadSymbol didn't
-  // succeed
-  EXPECT_EQ(func.GetName(), "unknown");
+  // This should throw because the library wasn't opened
+  EXPECT_THROW(lib.LoadSymbol("nonexistent_function", func), std::runtime_error);
 }
 
 // Tests for DlLibBase class with null library pointer
 TEST(DlLibBaseExtendedTest, LoadSymbolWithNullLibPtr) {
   ExtendedMockDlLib lib("libnonexistent.so");
   // Not calling OpenLib, so libptr_ remains nullptr
   DlFun<int, int, int> func;
-  EXPECT_FALSE(lib.LoadSymbol("some_function", func));
+  EXPECT_THROW(lib.LoadSymbol("some_function", func), std::runtime_error);
 }
 
 // Tests for DlLibBase class with empty function name
 TEST(DlLibBaseExtendedTest, LoadSymbolWithEmptyName) {
   ExtendedMockDlLib lib("libnonexistent.so");
   DlFun<int, int, int> func;
-  EXPECT_FALSE(lib.LoadSymbol("", func));
-}
-
-// Tests for DlLibBase class function cache size
-TEST(DlLibBaseExtendedTest, FunCacheSizeInitiallyZero) {
-  ExtendedMockDlLib lib("libnonexistent.so");
-  EXPECT_EQ(lib.CacheSize(), 0u);
-}
-
-// Tests for DlLibBase class CheckFunCache initially true
-TEST(DlLibBaseExtendedTest, CheckFunCacheInitiallyTrue) {
-  ExtendedMockDlLib lib("libnonexistent.so");
-
-  // Initially no functions loaded, so should return true
-  EXPECT_TRUE(lib.CheckCache());
+  EXPECT_THROW(lib.LoadSymbol("", func), std::runtime_error);
 }
 
 // Additional extended tests for DlLibBase class
-TEST(DlLibBaseExtendedTest, FunCacheSizeAfterMultipleLoads) {
+TEST(DlLibBaseExtendedTest, MultipleFunctionLoadsWithoutLibrary) {
   ExtendedMockDlLib lib("libnonexistent.so");
   DlFun<int, int, int> func1;
   DlFun<double, double> func2;
   DlFun<void> func3;
 
-  // Cache size should be 0 initially
-  EXPECT_EQ(lib.CacheSize(), 0u);
-  
   // Try to load functions without opening library
-  // These should return false and not add to cache since preconditions aren't met
-  EXPECT_FALSE(lib.LoadSymbol("func1", func1));
-  EXPECT_FALSE(lib.LoadSymbol("func2", func2));
-  EXPECT_FALSE(lib.LoadSymbol("func3", func3));
-  
-  // Cache size should still be 0 since SelfDlSym returns false when preconditions aren't met
-  EXPECT_EQ(lib.CacheSize(), 0u);
-  
-  // CheckFunCache should return true since cache is empty
-  EXPECT_TRUE(lib.CheckCache());
-}
-
-TEST(DlLibBaseExtendedTest, FunCacheSizeAfterMixedSuccessFailure) {
-  ExtendedMockDlLib lib("libnonexistent.so");
-  DlFun<int, int, int> func1;
-  DlFun<double, double> func2;
-  
-  // Cache size should be 0 initially
-  EXPECT_EQ(lib.CacheSize(), 0u);
-  
-  // Try to load one function without opening library (should fail)
-  EXPECT_FALSE(lib.LoadSymbol("func1", func1));
-  
-  // Cache size should still be 0 since SelfDlSym returns false when preconditions aren't met
-  EXPECT_EQ(lib.CacheSize(), 0u);
-  
-  // CheckFunCache should return true since cache is empty
-  EXPECT_TRUE(lib.CheckCache());
+  // These should throw exceptions since library is not loaded
+  EXPECT_THROW(lib.LoadSymbol("func1", func1), std::runtime_error);
+  EXPECT_THROW(lib.LoadSymbol("func2", func2), std::runtime_error);
+  EXPECT_THROW(lib.LoadSymbol("func3", func3), std::runtime_error);
 }
 
 TEST(DlLibBaseExtendedTest, ConstructorWithLongLibraryName) {
@@ -143,8 +95,7 @@ TEST(DlLibBaseExtendedTest, LoadSymbolWithVeryLongFunctionName) {
   ExtendedMockDlLib lib("libnonexistent.so");
   DlFun<int, int, int> func;
   std::string longFuncName(1000, 'f');
-  EXPECT_FALSE(lib.LoadSymbol(longFuncName, func));
-  EXPECT_EQ(func.GetName(), "unknown");
+  EXPECT_THROW(lib.LoadSymbol(longFuncName, func), std::runtime_error);
 }
 
 } // namespace dlutils

test/dlutils_test.cpp

@@ -24,7 +24,6 @@
 #include "gtest/gtest.h"
 
 #include <string>
-#include <vector>
 
 namespace dlutils {
 namespace internal {
@@ -51,23 +50,7 @@ TEST(MakeStringTest, WithNumbers) {
   EXPECT_EQ(result, "Value: 42 and 3.14");
 }
 
-TEST(MakeStringTest, WithVector) {
-  std::vector<int> vec = {1, 2, 3, 4, 5};
-  std::string result = internal::MakeString(vec);
-  EXPECT_EQ(result, "1 2 3 4 5");
-}
-
-TEST(MakeStringTest, WithVectorAndCustomDelimiter) {
-  std::vector<int> vec = {1, 2, 3, 4, 5};
-  std::string result = internal::MakeString(vec, std::string(","));
-  EXPECT_EQ(result, "1,2,3,4,5");
-}
 
-TEST(MakeStringTest, WithEmptyVector) {
-  std::vector<int> vec = {};
-  std::string result = internal::MakeString(vec);
-  EXPECT_EQ(result, "");
-}
 
 // Additional tests for MakeStringInternal
 TEST(MakeStringTest, WithStdString) {
@@ -154,16 +137,12 @@ class MockDlLib : public DlLibBase {
 public:
   explicit MockDlLib(std::string_view lib) : DlLibBase(lib) {}
 
-  bool OpenLib() { return SelfDlOpen(); }
+  void OpenLib() { SelfDlOpen(); }
 
   template <class R, class... Args>
-  bool LoadSymbol(std::string_view funName, DlFun<R, Args...> &outFun) {
-    return SelfDlSym(funName, outFun);
+  void LoadSymbol(std::string_view funName, DlFun<R, Args...> &outFun) {
+    SelfDlSym(funName, outFun);
   }
-
-  bool CheckCache() { return CheckFunCache(); }
-
-  size_t CacheSize() { return GetFunCacheSize(); }
 };
 
 // Tests for DlLibBase class
@@ -173,16 +152,7 @@ TEST(DlLibBaseTest, Constructor) {
   SUCCEED();
 }
 
-TEST(DlLibBaseTest, GetFunCacheSizeInitiallyZero) {
-  MockDlLib lib("libtest.so");
-  EXPECT_EQ(lib.CacheSize(), 0u);
-}
 
-TEST(DlLibBaseTest, CheckFunCacheInitiallyTrue) {
-  MockDlLib lib("libtest.so");
-  // Initially no functions loaded, so should return true
-  EXPECT_TRUE(lib.CheckCache());
-}
 
 // Additional tests for DlLibBase class
 TEST(DlLibBaseTest, ConstructorWithEmptyString) {
@@ -208,35 +178,24 @@ TEST(DlLibBaseTest, SelfDlOpenWithEmptyLibraryName) {
 TEST(DlLibBaseTest, SelfDlSymWithEmptyFunctionName) {
   MockDlLib lib("libtest.so");
   DlFun<int, int, int> func;
-  EXPECT_FALSE(lib.LoadSymbol("", func));
-  EXPECT_EQ(func.GetName(), "unknown");
+  EXPECT_THROW(lib.LoadSymbol("", func), std::runtime_error);
 }
 
 TEST(DlLibBaseTest, SelfDlSymWithoutOpeningLibrary) {
   MockDlLib lib("libtest.so");
   DlFun<int, int, int> func;
-  EXPECT_FALSE(lib.LoadSymbol("test_function", func));
-  EXPECT_EQ(func.GetName(), "unknown");
+  EXPECT_THROW(lib.LoadSymbol("test_function", func), std::runtime_error);
 }
 
 TEST(DlLibBaseTest, MultipleFunctionLoads) {
   MockDlLib lib("libtest.so");
   DlFun<int, int, int> func1;
   DlFun<double, double> func2;
 
-  // Cache size should be 0 initially
-  EXPECT_EQ(lib.CacheSize(), 0u);
-  
   // Try to load functions without opening library
-  // These should return false and not add to cache since preconditions aren't met
-  EXPECT_FALSE(lib.LoadSymbol("func1", func1));
-  EXPECT_FALSE(lib.LoadSymbol("func2", func2));
-  
-  // Cache size should still be 0 since SelfDlSym returns false when preconditions aren't met
-  EXPECT_EQ(lib.CacheSize(), 0u);
-  
-  // CheckFunCache should return true since cache is empty
-  EXPECT_TRUE(lib.CheckCache());
+  // These should throw exceptions since library is not loaded
+  EXPECT_THROW(lib.LoadSymbol("func1", func1), std::runtime_error);
+  EXPECT_THROW(lib.LoadSymbol("func2", func2), std::runtime_error);
 }
 
 } // namespace dlutils

test/openssl.hpp

@@ -45,24 +45,15 @@ class LibCrypto : public DlLibBase {
     return instance;
   }
 
-  // Check wheter dlopen and dlsym has succeed
-  bool CheckOk() { return CheckFunCache(); }
-
   // Reload all functions
-  bool Reload() {
-    LoadAll();
-    return CheckFunCache();
-  }
-
-  // Size() function will not check if all functions are callable
-  size_t Size() { return GetFunCacheSize(); }
+  void Reload() { LoadAll(); }
 
   // Declare all functions that you need
   // NOTE Please make sure the class instance is inited before calling those
   // functions
   DlFun<EVP_MD_CTX *> EVP_MD_CTX_new;
   DlFun<const EVP_MD *> EVP_sha256;
-  DlFun<const EVP_MD *> EVP_sha1;  // Additional hash function for testing
+  DlFun<const EVP_MD *> EVP_sha1; // Additional hash function for testing
   DlFun<int, EVP_MD_CTX *, const EVP_MD *, ENGINE *> EVP_DigestInit_ex;
   DlFun<int, EVP_MD_CTX *, const void *, size_t> EVP_DigestUpdate;
   DlFun<int, EVP_MD_CTX *, unsigned char *, unsigned int *> EVP_DigestFinal_ex;